
(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}
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}
Herbie found 23 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}
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}
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (* (* 0.005555555555555556 PI) (fabs angle))))
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 1.1e+136)
(*
(* (* (sin (/ (* PI (fabs angle)) 180.0)) (* 2.0 (- b a))) (+ a b))
(cos t_0))
(* (* (* 2.0 (* (- b a) (+ b a))) (sin t_0)) 1.0)))))double code(double a, double b, double angle) {
double t_0 = (0.005555555555555556 * ((double) M_PI)) * fabs(angle);
double tmp;
if (fabs(angle) <= 1.1e+136) {
tmp = ((sin(((((double) M_PI) * fabs(angle)) / 180.0)) * (2.0 * (b - a))) * (a + b)) * cos(t_0);
} else {
tmp = ((2.0 * ((b - a) * (b + a))) * sin(t_0)) * 1.0;
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = (0.005555555555555556 * Math.PI) * Math.abs(angle);
double tmp;
if (Math.abs(angle) <= 1.1e+136) {
tmp = ((Math.sin(((Math.PI * Math.abs(angle)) / 180.0)) * (2.0 * (b - a))) * (a + b)) * Math.cos(t_0);
} else {
tmp = ((2.0 * ((b - a) * (b + a))) * Math.sin(t_0)) * 1.0;
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = (0.005555555555555556 * math.pi) * math.fabs(angle) tmp = 0 if math.fabs(angle) <= 1.1e+136: tmp = ((math.sin(((math.pi * math.fabs(angle)) / 180.0)) * (2.0 * (b - a))) * (a + b)) * math.cos(t_0) else: tmp = ((2.0 * ((b - a) * (b + a))) * math.sin(t_0)) * 1.0 return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = Float64(Float64(0.005555555555555556 * pi) * abs(angle)) tmp = 0.0 if (abs(angle) <= 1.1e+136) tmp = Float64(Float64(Float64(sin(Float64(Float64(pi * abs(angle)) / 180.0)) * Float64(2.0 * Float64(b - a))) * Float64(a + b)) * cos(t_0)); else tmp = Float64(Float64(Float64(2.0 * Float64(Float64(b - a) * Float64(b + a))) * sin(t_0)) * 1.0); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = (0.005555555555555556 * pi) * abs(angle); tmp = 0.0; if (abs(angle) <= 1.1e+136) tmp = ((sin(((pi * abs(angle)) / 180.0)) * (2.0 * (b - a))) * (a + b)) * cos(t_0); else tmp = ((2.0 * ((b - a) * (b + a))) * sin(t_0)) * 1.0; end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[(0.005555555555555556 * Pi), $MachinePrecision] * N[Abs[angle], $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 1.1e+136], N[(N[(N[(N[Sin[N[(N[(Pi * N[Abs[angle], $MachinePrecision]), $MachinePrecision] / 180.0), $MachinePrecision]], $MachinePrecision] * N[(2.0 * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision], N[(N[(N[(2.0 * N[(N[(b - a), $MachinePrecision] * N[(b + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_0 := \left(0.005555555555555556 \cdot \pi\right) \cdot \left|angle\right|\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 1.1 \cdot 10^{+136}:\\
\;\;\;\;\left(\left(\sin \left(\frac{\pi \cdot \left|angle\right|}{180}\right) \cdot \left(2 \cdot \left(b - a\right)\right)\right) \cdot \left(a + b\right)\right) \cdot \cos t\_0\\
\mathbf{else}:\\
\;\;\;\;\left(\left(2 \cdot \left(\left(b - a\right) \cdot \left(b + a\right)\right)\right) \cdot \sin t\_0\right) \cdot 1\\
\end{array}
\end{array}
if angle < 1.1e136Initial program 53.8%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval53.9%
Applied rewrites53.9%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval53.9%
Applied rewrites53.9%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6457.9%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6457.9%
Applied rewrites57.9%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
Applied rewrites67.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
metadata-evalN/A
mult-flipN/A
*-commutativeN/A
associate-*r/N/A
lift-*.f64N/A
lower-/.f6467.1%
Applied rewrites67.1%
if 1.1e136 < angle Initial program 53.8%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval53.9%
Applied rewrites53.9%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval53.9%
Applied rewrites53.9%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6457.9%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6457.9%
Applied rewrites57.9%
Taylor expanded in angle around 0
Applied rewrites56.5%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (/ (fabs angle) 180.0)))
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 9e+94)
(*
(* (* (sin (* t_0 PI)) (* 2.0 (- (fabs b) a))) (+ a (fabs b)))
(cos (* (* 0.005555555555555556 PI) (fabs angle))))
(*
(* (* 2.0 (fma (- a) a (* (fabs b) (fabs b)))) (sin (* PI t_0)))
1.0)))))double code(double a, double b, double angle) {
double t_0 = fabs(angle) / 180.0;
double tmp;
if (fabs(angle) <= 9e+94) {
tmp = ((sin((t_0 * ((double) M_PI))) * (2.0 * (fabs(b) - a))) * (a + fabs(b))) * cos(((0.005555555555555556 * ((double) M_PI)) * fabs(angle)));
} else {
tmp = ((2.0 * fma(-a, a, (fabs(b) * fabs(b)))) * sin((((double) M_PI) * t_0))) * 1.0;
}
return copysign(1.0, angle) * tmp;
}
function code(a, b, angle) t_0 = Float64(abs(angle) / 180.0) tmp = 0.0 if (abs(angle) <= 9e+94) tmp = Float64(Float64(Float64(sin(Float64(t_0 * pi)) * Float64(2.0 * Float64(abs(b) - a))) * Float64(a + abs(b))) * cos(Float64(Float64(0.005555555555555556 * pi) * abs(angle)))); else tmp = Float64(Float64(Float64(2.0 * fma(Float64(-a), a, Float64(abs(b) * abs(b)))) * sin(Float64(pi * t_0))) * 1.0); end return Float64(copysign(1.0, angle) * tmp) end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[Abs[angle], $MachinePrecision] / 180.0), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 9e+94], N[(N[(N[(N[Sin[N[(t$95$0 * Pi), $MachinePrecision]], $MachinePrecision] * N[(2.0 * N[(N[Abs[b], $MachinePrecision] - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(a + N[Abs[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(N[(0.005555555555555556 * Pi), $MachinePrecision] * N[Abs[angle], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(N[(2.0 * N[((-a) * a + N[(N[Abs[b], $MachinePrecision] * N[Abs[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(Pi * t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_0 := \frac{\left|angle\right|}{180}\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 9 \cdot 10^{+94}:\\
\;\;\;\;\left(\left(\sin \left(t\_0 \cdot \pi\right) \cdot \left(2 \cdot \left(\left|b\right| - a\right)\right)\right) \cdot \left(a + \left|b\right|\right)\right) \cdot \cos \left(\left(0.005555555555555556 \cdot \pi\right) \cdot \left|angle\right|\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(2 \cdot \mathsf{fma}\left(-a, a, \left|b\right| \cdot \left|b\right|\right)\right) \cdot \sin \left(\pi \cdot t\_0\right)\right) \cdot 1\\
\end{array}
\end{array}
if angle < 8.99999999999999944e94Initial program 53.8%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval53.9%
Applied rewrites53.9%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval53.9%
Applied rewrites53.9%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6457.9%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6457.9%
Applied rewrites57.9%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
Applied rewrites67.3%
lift-*.f64N/A
*-commutativeN/A
metadata-evalN/A
mult-flipN/A
lower-/.f6467.2%
Applied rewrites67.2%
if 8.99999999999999944e94 < angle Initial program 53.8%
lift--.f64N/A
sub-flipN/A
+-commutativeN/A
lift-pow.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6456.4%
lift-pow.f64N/A
unpow2N/A
lower-*.f6456.4%
Applied rewrites56.4%
Taylor expanded in angle around 0
Applied rewrites55.2%
(FPCore (a b angle)
:precision binary64
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 2.25e+136)
(*
(*
(cos (* (* PI (fabs angle)) -0.005555555555555556))
(* (* (sin (* (* PI 0.005555555555555556) (fabs angle))) (- b a)) 2.0))
(+ a b))
(*
(*
(* 2.0 (* (- b a) (+ b a)))
(sin (* (* 0.005555555555555556 PI) (fabs angle))))
1.0))))double code(double a, double b, double angle) {
double tmp;
if (fabs(angle) <= 2.25e+136) {
tmp = (cos(((((double) M_PI) * fabs(angle)) * -0.005555555555555556)) * ((sin(((((double) M_PI) * 0.005555555555555556) * fabs(angle))) * (b - a)) * 2.0)) * (a + b);
} else {
tmp = ((2.0 * ((b - a) * (b + a))) * sin(((0.005555555555555556 * ((double) M_PI)) * fabs(angle)))) * 1.0;
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (Math.abs(angle) <= 2.25e+136) {
tmp = (Math.cos(((Math.PI * Math.abs(angle)) * -0.005555555555555556)) * ((Math.sin(((Math.PI * 0.005555555555555556) * Math.abs(angle))) * (b - a)) * 2.0)) * (a + b);
} else {
tmp = ((2.0 * ((b - a) * (b + a))) * Math.sin(((0.005555555555555556 * Math.PI) * Math.abs(angle)))) * 1.0;
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): tmp = 0 if math.fabs(angle) <= 2.25e+136: tmp = (math.cos(((math.pi * math.fabs(angle)) * -0.005555555555555556)) * ((math.sin(((math.pi * 0.005555555555555556) * math.fabs(angle))) * (b - a)) * 2.0)) * (a + b) else: tmp = ((2.0 * ((b - a) * (b + a))) * math.sin(((0.005555555555555556 * math.pi) * math.fabs(angle)))) * 1.0 return math.copysign(1.0, angle) * tmp
function code(a, b, angle) tmp = 0.0 if (abs(angle) <= 2.25e+136) tmp = Float64(Float64(cos(Float64(Float64(pi * abs(angle)) * -0.005555555555555556)) * Float64(Float64(sin(Float64(Float64(pi * 0.005555555555555556) * abs(angle))) * Float64(b - a)) * 2.0)) * Float64(a + b)); else tmp = Float64(Float64(Float64(2.0 * Float64(Float64(b - a) * Float64(b + a))) * sin(Float64(Float64(0.005555555555555556 * pi) * abs(angle)))) * 1.0); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) tmp = 0.0; if (abs(angle) <= 2.25e+136) tmp = (cos(((pi * abs(angle)) * -0.005555555555555556)) * ((sin(((pi * 0.005555555555555556) * abs(angle))) * (b - a)) * 2.0)) * (a + b); else tmp = ((2.0 * ((b - a) * (b + a))) * sin(((0.005555555555555556 * pi) * abs(angle)))) * 1.0; end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 2.25e+136], N[(N[(N[Cos[N[(N[(Pi * N[Abs[angle], $MachinePrecision]), $MachinePrecision] * -0.005555555555555556), $MachinePrecision]], $MachinePrecision] * N[(N[(N[Sin[N[(N[(Pi * 0.005555555555555556), $MachinePrecision] * N[Abs[angle], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision], N[(N[(N[(2.0 * N[(N[(b - a), $MachinePrecision] * N[(b + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[(0.005555555555555556 * Pi), $MachinePrecision] * N[Abs[angle], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision]]), $MachinePrecision]
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 2.25 \cdot 10^{+136}:\\
\;\;\;\;\left(\cos \left(\left(\pi \cdot \left|angle\right|\right) \cdot -0.005555555555555556\right) \cdot \left(\left(\sin \left(\left(\pi \cdot 0.005555555555555556\right) \cdot \left|angle\right|\right) \cdot \left(b - a\right)\right) \cdot 2\right)\right) \cdot \left(a + b\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(2 \cdot \left(\left(b - a\right) \cdot \left(b + a\right)\right)\right) \cdot \sin \left(\left(0.005555555555555556 \cdot \pi\right) \cdot \left|angle\right|\right)\right) \cdot 1\\
\end{array}
if angle < 2.25e136Initial program 53.8%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval53.9%
Applied rewrites53.9%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval53.9%
Applied rewrites53.9%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6457.9%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6457.9%
Applied rewrites57.9%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
Applied rewrites67.3%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
Applied rewrites67.1%
if 2.25e136 < angle Initial program 53.8%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval53.9%
Applied rewrites53.9%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval53.9%
Applied rewrites53.9%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6457.9%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6457.9%
Applied rewrites57.9%
Taylor expanded in angle around 0
Applied rewrites56.5%
(FPCore (a b angle)
:precision binary64
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 2.25e+136)
(* (+ b a) (* (sin (* 0.011111111111111112 (* PI (fabs angle)))) (- b a)))
(*
(*
(* 2.0 (* (- b a) (+ b a)))
(sin (* (* 0.005555555555555556 PI) (fabs angle))))
1.0))))double code(double a, double b, double angle) {
double tmp;
if (fabs(angle) <= 2.25e+136) {
tmp = (b + a) * (sin((0.011111111111111112 * (((double) M_PI) * fabs(angle)))) * (b - a));
} else {
tmp = ((2.0 * ((b - a) * (b + a))) * sin(((0.005555555555555556 * ((double) M_PI)) * fabs(angle)))) * 1.0;
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (Math.abs(angle) <= 2.25e+136) {
tmp = (b + a) * (Math.sin((0.011111111111111112 * (Math.PI * Math.abs(angle)))) * (b - a));
} else {
tmp = ((2.0 * ((b - a) * (b + a))) * Math.sin(((0.005555555555555556 * Math.PI) * Math.abs(angle)))) * 1.0;
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): tmp = 0 if math.fabs(angle) <= 2.25e+136: tmp = (b + a) * (math.sin((0.011111111111111112 * (math.pi * math.fabs(angle)))) * (b - a)) else: tmp = ((2.0 * ((b - a) * (b + a))) * math.sin(((0.005555555555555556 * math.pi) * math.fabs(angle)))) * 1.0 return math.copysign(1.0, angle) * tmp
function code(a, b, angle) tmp = 0.0 if (abs(angle) <= 2.25e+136) tmp = Float64(Float64(b + a) * Float64(sin(Float64(0.011111111111111112 * Float64(pi * abs(angle)))) * Float64(b - a))); else tmp = Float64(Float64(Float64(2.0 * Float64(Float64(b - a) * Float64(b + a))) * sin(Float64(Float64(0.005555555555555556 * pi) * abs(angle)))) * 1.0); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) tmp = 0.0; if (abs(angle) <= 2.25e+136) tmp = (b + a) * (sin((0.011111111111111112 * (pi * abs(angle)))) * (b - a)); else tmp = ((2.0 * ((b - a) * (b + a))) * sin(((0.005555555555555556 * pi) * abs(angle)))) * 1.0; end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 2.25e+136], N[(N[(b + a), $MachinePrecision] * N[(N[Sin[N[(0.011111111111111112 * N[(Pi * N[Abs[angle], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(2.0 * N[(N[(b - a), $MachinePrecision] * N[(b + a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[(0.005555555555555556 * Pi), $MachinePrecision] * N[Abs[angle], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision]]), $MachinePrecision]
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 2.25 \cdot 10^{+136}:\\
\;\;\;\;\left(b + a\right) \cdot \left(\sin \left(0.011111111111111112 \cdot \left(\pi \cdot \left|angle\right|\right)\right) \cdot \left(b - a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(2 \cdot \left(\left(b - a\right) \cdot \left(b + a\right)\right)\right) \cdot \sin \left(\left(0.005555555555555556 \cdot \pi\right) \cdot \left|angle\right|\right)\right) \cdot 1\\
\end{array}
if angle < 2.25e136Initial program 53.8%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lift-sin.f64N/A
lift-cos.f64N/A
Applied rewrites67.2%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
Applied rewrites67.2%
if 2.25e136 < angle Initial program 53.8%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval53.9%
Applied rewrites53.9%
lift-*.f64N/A
*-commutativeN/A
lift-/.f64N/A
mult-flipN/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f64N/A
metadata-eval53.9%
Applied rewrites53.9%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6457.9%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6457.9%
Applied rewrites57.9%
Taylor expanded in angle around 0
Applied rewrites56.5%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (* PI (fabs angle))))
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 6.5e+143)
(* (+ b a) (* (sin (* 0.011111111111111112 t_0)) (- b a)))
(* (* 2.0 (* (+ a b) (- b a))) (sin (* 0.005555555555555556 t_0)))))))double code(double a, double b, double angle) {
double t_0 = ((double) M_PI) * fabs(angle);
double tmp;
if (fabs(angle) <= 6.5e+143) {
tmp = (b + a) * (sin((0.011111111111111112 * t_0)) * (b - a));
} else {
tmp = (2.0 * ((a + b) * (b - a))) * sin((0.005555555555555556 * t_0));
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.PI * Math.abs(angle);
double tmp;
if (Math.abs(angle) <= 6.5e+143) {
tmp = (b + a) * (Math.sin((0.011111111111111112 * t_0)) * (b - a));
} else {
tmp = (2.0 * ((a + b) * (b - a))) * Math.sin((0.005555555555555556 * t_0));
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = math.pi * math.fabs(angle) tmp = 0 if math.fabs(angle) <= 6.5e+143: tmp = (b + a) * (math.sin((0.011111111111111112 * t_0)) * (b - a)) else: tmp = (2.0 * ((a + b) * (b - a))) * math.sin((0.005555555555555556 * t_0)) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = Float64(pi * abs(angle)) tmp = 0.0 if (abs(angle) <= 6.5e+143) tmp = Float64(Float64(b + a) * Float64(sin(Float64(0.011111111111111112 * t_0)) * Float64(b - a))); else tmp = Float64(Float64(2.0 * Float64(Float64(a + b) * Float64(b - a))) * sin(Float64(0.005555555555555556 * t_0))); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = pi * abs(angle); tmp = 0.0; if (abs(angle) <= 6.5e+143) tmp = (b + a) * (sin((0.011111111111111112 * t_0)) * (b - a)); else tmp = (2.0 * ((a + b) * (b - a))) * sin((0.005555555555555556 * t_0)); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[Abs[angle], $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 6.5e+143], N[(N[(b + a), $MachinePrecision] * N[(N[Sin[N[(0.011111111111111112 * t$95$0), $MachinePrecision]], $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * N[(N[(a + b), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(0.005555555555555556 * t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_0 := \pi \cdot \left|angle\right|\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 6.5 \cdot 10^{+143}:\\
\;\;\;\;\left(b + a\right) \cdot \left(\sin \left(0.011111111111111112 \cdot t\_0\right) \cdot \left(b - a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(2 \cdot \left(\left(a + b\right) \cdot \left(b - a\right)\right)\right) \cdot \sin \left(0.005555555555555556 \cdot t\_0\right)\\
\end{array}
\end{array}
if angle < 6.4999999999999997e143Initial program 53.8%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lift-sin.f64N/A
lift-cos.f64N/A
Applied rewrites67.2%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
Applied rewrites67.2%
if 6.4999999999999997e143 < angle Initial program 53.8%
lift--.f64N/A
sub-flipN/A
+-commutativeN/A
lift-pow.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6456.4%
lift-pow.f64N/A
unpow2N/A
lower-*.f6456.4%
Applied rewrites56.4%
Applied rewrites57.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6456.4%
Applied rewrites56.4%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (* PI (/ (fabs angle) 180.0))))
(*
(copysign 1.0 angle)
(if (<=
(* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin t_0)) (cos t_0))
2e-17)
(*
(+ b a)
(* (sin (* 0.011111111111111112 (* PI (fabs angle)))) (- b a)))
(*
(+ b a)
(* (sin (* (* (fabs angle) 0.011111111111111112) PI)) (- b a)))))))double code(double a, double b, double angle) {
double t_0 = ((double) M_PI) * (fabs(angle) / 180.0);
double tmp;
if ((((2.0 * (pow(b, 2.0) - pow(a, 2.0))) * sin(t_0)) * cos(t_0)) <= 2e-17) {
tmp = (b + a) * (sin((0.011111111111111112 * (((double) M_PI) * fabs(angle)))) * (b - a));
} else {
tmp = (b + a) * (sin(((fabs(angle) * 0.011111111111111112) * ((double) M_PI))) * (b - a));
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.PI * (Math.abs(angle) / 180.0);
double tmp;
if ((((2.0 * (Math.pow(b, 2.0) - Math.pow(a, 2.0))) * Math.sin(t_0)) * Math.cos(t_0)) <= 2e-17) {
tmp = (b + a) * (Math.sin((0.011111111111111112 * (Math.PI * Math.abs(angle)))) * (b - a));
} else {
tmp = (b + a) * (Math.sin(((Math.abs(angle) * 0.011111111111111112) * Math.PI)) * (b - a));
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = math.pi * (math.fabs(angle) / 180.0) tmp = 0 if (((2.0 * (math.pow(b, 2.0) - math.pow(a, 2.0))) * math.sin(t_0)) * math.cos(t_0)) <= 2e-17: tmp = (b + a) * (math.sin((0.011111111111111112 * (math.pi * math.fabs(angle)))) * (b - a)) else: tmp = (b + a) * (math.sin(((math.fabs(angle) * 0.011111111111111112) * math.pi)) * (b - a)) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = Float64(pi * Float64(abs(angle) / 180.0)) tmp = 0.0 if (Float64(Float64(Float64(2.0 * Float64((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0)) <= 2e-17) tmp = Float64(Float64(b + a) * Float64(sin(Float64(0.011111111111111112 * Float64(pi * abs(angle)))) * Float64(b - a))); else tmp = Float64(Float64(b + a) * Float64(sin(Float64(Float64(abs(angle) * 0.011111111111111112) * pi)) * Float64(b - a))); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = pi * (abs(angle) / 180.0); tmp = 0.0; if ((((2.0 * ((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0)) <= 2e-17) tmp = (b + a) * (sin((0.011111111111111112 * (pi * abs(angle)))) * (b - a)); else tmp = (b + a) * (sin(((abs(angle) * 0.011111111111111112) * pi)) * (b - a)); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(N[Abs[angle], $MachinePrecision] / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[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], 2e-17], N[(N[(b + a), $MachinePrecision] * N[(N[Sin[N[(0.011111111111111112 * N[(Pi * N[Abs[angle], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(b + a), $MachinePrecision] * N[(N[Sin[N[(N[(N[Abs[angle], $MachinePrecision] * 0.011111111111111112), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]
\begin{array}{l}
t_0 := \pi \cdot \frac{\left|angle\right|}{180}\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left(\left(2 \cdot \left({b}^{2} - {a}^{2}\right)\right) \cdot \sin t\_0\right) \cdot \cos t\_0 \leq 2 \cdot 10^{-17}:\\
\;\;\;\;\left(b + a\right) \cdot \left(\sin \left(0.011111111111111112 \cdot \left(\pi \cdot \left|angle\right|\right)\right) \cdot \left(b - a\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b + a\right) \cdot \left(\sin \left(\left(\left|angle\right| \cdot 0.011111111111111112\right) \cdot \pi\right) \cdot \left(b - a\right)\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) < 2.00000000000000014e-17Initial program 53.8%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lift-sin.f64N/A
lift-cos.f64N/A
Applied rewrites67.2%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
Applied rewrites67.2%
if 2.00000000000000014e-17 < (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) Initial program 53.8%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lift-sin.f64N/A
lift-cos.f64N/A
Applied rewrites67.2%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
Applied rewrites67.2%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6467.4%
Applied rewrites67.4%
(FPCore (a b angle)
:precision binary64
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 1e-23)
(* (* (* (fabs angle) (+ a b)) (- b a)) (* PI 0.011111111111111112))
(*
(* (- b a) (+ a b))
(sin (* (* (fabs angle) PI) 0.011111111111111112))))))double code(double a, double b, double angle) {
double tmp;
if (fabs(angle) <= 1e-23) {
tmp = ((fabs(angle) * (a + b)) * (b - a)) * (((double) M_PI) * 0.011111111111111112);
} else {
tmp = ((b - a) * (a + b)) * sin(((fabs(angle) * ((double) M_PI)) * 0.011111111111111112));
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (Math.abs(angle) <= 1e-23) {
tmp = ((Math.abs(angle) * (a + b)) * (b - a)) * (Math.PI * 0.011111111111111112);
} else {
tmp = ((b - a) * (a + b)) * Math.sin(((Math.abs(angle) * Math.PI) * 0.011111111111111112));
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): tmp = 0 if math.fabs(angle) <= 1e-23: tmp = ((math.fabs(angle) * (a + b)) * (b - a)) * (math.pi * 0.011111111111111112) else: tmp = ((b - a) * (a + b)) * math.sin(((math.fabs(angle) * math.pi) * 0.011111111111111112)) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) tmp = 0.0 if (abs(angle) <= 1e-23) tmp = Float64(Float64(Float64(abs(angle) * Float64(a + b)) * Float64(b - a)) * Float64(pi * 0.011111111111111112)); else tmp = Float64(Float64(Float64(b - a) * Float64(a + b)) * sin(Float64(Float64(abs(angle) * pi) * 0.011111111111111112))); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) tmp = 0.0; if (abs(angle) <= 1e-23) tmp = ((abs(angle) * (a + b)) * (b - a)) * (pi * 0.011111111111111112); else tmp = ((b - a) * (a + b)) * sin(((abs(angle) * pi) * 0.011111111111111112)); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 1e-23], N[(N[(N[(N[Abs[angle], $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b - a), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[(N[Abs[angle], $MachinePrecision] * Pi), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 10^{-23}:\\
\;\;\;\;\left(\left(\left|angle\right| \cdot \left(a + b\right)\right) \cdot \left(b - a\right)\right) \cdot \left(\pi \cdot 0.011111111111111112\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b - a\right) \cdot \left(a + b\right)\right) \cdot \sin \left(\left(\left|angle\right| \cdot \pi\right) \cdot 0.011111111111111112\right)\\
\end{array}
if angle < 9.9999999999999996e-24Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f6462.0%
Applied rewrites62.0%
if 9.9999999999999996e-24 < angle Initial program 53.8%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-sin.f64N/A
lift-cos.f64N/A
2-sinN/A
count-2N/A
Applied rewrites57.8%
(FPCore (a b angle) :precision binary64 (* (+ b a) (* (sin (* 0.011111111111111112 (* PI angle))) (- b a))))
double code(double a, double b, double angle) {
return (b + a) * (sin((0.011111111111111112 * (((double) M_PI) * angle))) * (b - a));
}
public static double code(double a, double b, double angle) {
return (b + a) * (Math.sin((0.011111111111111112 * (Math.PI * angle))) * (b - a));
}
def code(a, b, angle): return (b + a) * (math.sin((0.011111111111111112 * (math.pi * angle))) * (b - a))
function code(a, b, angle) return Float64(Float64(b + a) * Float64(sin(Float64(0.011111111111111112 * Float64(pi * angle))) * Float64(b - a))) end
function tmp = code(a, b, angle) tmp = (b + a) * (sin((0.011111111111111112 * (pi * angle))) * (b - a)); end
code[a_, b_, angle_] := N[(N[(b + a), $MachinePrecision] * N[(N[Sin[N[(0.011111111111111112 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\left(b + a\right) \cdot \left(\sin \left(0.011111111111111112 \cdot \left(\pi \cdot angle\right)\right) \cdot \left(b - a\right)\right)
Initial program 53.8%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lift-sin.f64N/A
lift-cos.f64N/A
Applied rewrites67.2%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
Applied rewrites67.2%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (- b (fabs a))))
(if (<= (fabs a) 3.5e-139)
(* b (* (sin (* 0.011111111111111112 (* PI angle))) t_0))
(* (* (* angle (+ (fabs a) b)) t_0) (* PI 0.011111111111111112)))))double code(double a, double b, double angle) {
double t_0 = b - fabs(a);
double tmp;
if (fabs(a) <= 3.5e-139) {
tmp = b * (sin((0.011111111111111112 * (((double) M_PI) * angle))) * t_0);
} else {
tmp = ((angle * (fabs(a) + b)) * t_0) * (((double) M_PI) * 0.011111111111111112);
}
return tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = b - Math.abs(a);
double tmp;
if (Math.abs(a) <= 3.5e-139) {
tmp = b * (Math.sin((0.011111111111111112 * (Math.PI * angle))) * t_0);
} else {
tmp = ((angle * (Math.abs(a) + b)) * t_0) * (Math.PI * 0.011111111111111112);
}
return tmp;
}
def code(a, b, angle): t_0 = b - math.fabs(a) tmp = 0 if math.fabs(a) <= 3.5e-139: tmp = b * (math.sin((0.011111111111111112 * (math.pi * angle))) * t_0) else: tmp = ((angle * (math.fabs(a) + b)) * t_0) * (math.pi * 0.011111111111111112) return tmp
function code(a, b, angle) t_0 = Float64(b - abs(a)) tmp = 0.0 if (abs(a) <= 3.5e-139) tmp = Float64(b * Float64(sin(Float64(0.011111111111111112 * Float64(pi * angle))) * t_0)); else tmp = Float64(Float64(Float64(angle * Float64(abs(a) + b)) * t_0) * Float64(pi * 0.011111111111111112)); end return tmp end
function tmp_2 = code(a, b, angle) t_0 = b - abs(a); tmp = 0.0; if (abs(a) <= 3.5e-139) tmp = b * (sin((0.011111111111111112 * (pi * angle))) * t_0); else tmp = ((angle * (abs(a) + b)) * t_0) * (pi * 0.011111111111111112); end tmp_2 = tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(b - N[Abs[a], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Abs[a], $MachinePrecision], 3.5e-139], N[(b * N[(N[Sin[N[(0.011111111111111112 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(angle * N[(N[Abs[a], $MachinePrecision] + b), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision] * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
t_0 := b - \left|a\right|\\
\mathbf{if}\;\left|a\right| \leq 3.5 \cdot 10^{-139}:\\
\;\;\;\;b \cdot \left(\sin \left(0.011111111111111112 \cdot \left(\pi \cdot angle\right)\right) \cdot t\_0\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(angle \cdot \left(\left|a\right| + b\right)\right) \cdot t\_0\right) \cdot \left(\pi \cdot 0.011111111111111112\right)\\
\end{array}
if a < 3.50000000000000001e-139Initial program 53.8%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
lift-sin.f64N/A
lift-cos.f64N/A
Applied rewrites67.2%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.2%
Applied rewrites67.2%
Taylor expanded in a around 0
Applied rewrites42.2%
if 3.50000000000000001e-139 < a Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f6462.0%
Applied rewrites62.0%
(FPCore (a b angle)
:precision binary64
(*
(copysign 1.0 angle)
(if (<= (fabs angle) 0.0001)
(* (* (* (fabs angle) (+ a b)) (- b a)) (* PI 0.011111111111111112))
(* 0.011111111111111112 (* (fabs angle) (* PI (fma (- a) a (* b b))))))))double code(double a, double b, double angle) {
double tmp;
if (fabs(angle) <= 0.0001) {
tmp = ((fabs(angle) * (a + b)) * (b - a)) * (((double) M_PI) * 0.011111111111111112);
} else {
tmp = 0.011111111111111112 * (fabs(angle) * (((double) M_PI) * fma(-a, a, (b * b))));
}
return copysign(1.0, angle) * tmp;
}
function code(a, b, angle) tmp = 0.0 if (abs(angle) <= 0.0001) tmp = Float64(Float64(Float64(abs(angle) * Float64(a + b)) * Float64(b - a)) * Float64(pi * 0.011111111111111112)); else tmp = Float64(0.011111111111111112 * Float64(abs(angle) * Float64(pi * fma(Float64(-a), a, Float64(b * b))))); end return Float64(copysign(1.0, angle) * tmp) end
code[a_, b_, angle_] := N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[Abs[angle], $MachinePrecision], 0.0001], N[(N[(N[(N[Abs[angle], $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[Abs[angle], $MachinePrecision] * N[(Pi * N[((-a) * a + N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left|angle\right| \leq 0.0001:\\
\;\;\;\;\left(\left(\left|angle\right| \cdot \left(a + b\right)\right) \cdot \left(b - a\right)\right) \cdot \left(\pi \cdot 0.011111111111111112\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left|angle\right| \cdot \left(\pi \cdot \mathsf{fma}\left(-a, a, b \cdot b\right)\right)\right)\\
\end{array}
if angle < 1.00000000000000005e-4Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f6462.0%
Applied rewrites62.0%
if 1.00000000000000005e-4 < angle Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
fp-cancel-sub-sign-invN/A
lift-neg.f64N/A
+-commutativeN/A
lower-fma.f6453.4%
lift-pow.f64N/A
pow2N/A
lift-*.f6453.4%
Applied rewrites53.4%
(FPCore (a b angle) :precision binary64 (* (* (* angle (+ a b)) (- b a)) (* PI 0.011111111111111112)))
double code(double a, double b, double angle) {
return ((angle * (a + b)) * (b - a)) * (((double) M_PI) * 0.011111111111111112);
}
public static double code(double a, double b, double angle) {
return ((angle * (a + b)) * (b - a)) * (Math.PI * 0.011111111111111112);
}
def code(a, b, angle): return ((angle * (a + b)) * (b - a)) * (math.pi * 0.011111111111111112)
function code(a, b, angle) return Float64(Float64(Float64(angle * Float64(a + b)) * Float64(b - a)) * Float64(pi * 0.011111111111111112)) end
function tmp = code(a, b, angle) tmp = ((angle * (a + b)) * (b - a)) * (pi * 0.011111111111111112); end
code[a_, b_, angle_] := N[(N[(N[(angle * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]
\left(\left(angle \cdot \left(a + b\right)\right) \cdot \left(b - a\right)\right) \cdot \left(\pi \cdot 0.011111111111111112\right)
Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f6462.0%
Applied rewrites62.0%
(FPCore (a b angle) :precision binary64 (* (* (* 0.011111111111111112 (* (- b a) angle)) (+ a b)) PI))
double code(double a, double b, double angle) {
return ((0.011111111111111112 * ((b - a) * angle)) * (a + b)) * ((double) M_PI);
}
public static double code(double a, double b, double angle) {
return ((0.011111111111111112 * ((b - a) * angle)) * (a + b)) * Math.PI;
}
def code(a, b, angle): return ((0.011111111111111112 * ((b - a) * angle)) * (a + b)) * math.pi
function code(a, b, angle) return Float64(Float64(Float64(0.011111111111111112 * Float64(Float64(b - a) * angle)) * Float64(a + b)) * pi) end
function tmp = code(a, b, angle) tmp = ((0.011111111111111112 * ((b - a) * angle)) * (a + b)) * pi; end
code[a_, b_, angle_] := N[(N[(N[(0.011111111111111112 * N[(N[(b - a), $MachinePrecision] * angle), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]
\left(\left(0.011111111111111112 \cdot \left(\left(b - a\right) \cdot angle\right)\right) \cdot \left(a + b\right)\right) \cdot \pi
Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6462.1%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6462.1%
Applied rewrites62.1%
(FPCore (a b angle) :precision binary64 (* 0.011111111111111112 (* (* (- b a) angle) (* (+ a b) PI))))
double code(double a, double b, double angle) {
return 0.011111111111111112 * (((b - a) * angle) * ((a + b) * ((double) M_PI)));
}
public static double code(double a, double b, double angle) {
return 0.011111111111111112 * (((b - a) * angle) * ((a + b) * Math.PI));
}
def code(a, b, angle): return 0.011111111111111112 * (((b - a) * angle) * ((a + b) * math.pi))
function code(a, b, angle) return Float64(0.011111111111111112 * Float64(Float64(Float64(b - a) * angle) * Float64(Float64(a + b) * pi))) end
function tmp = code(a, b, angle) tmp = 0.011111111111111112 * (((b - a) * angle) * ((a + b) * pi)); end
code[a_, b_, angle_] := N[(0.011111111111111112 * N[(N[(N[(b - a), $MachinePrecision] * angle), $MachinePrecision] * N[(N[(a + b), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
0.011111111111111112 \cdot \left(\left(\left(b - a\right) \cdot angle\right) \cdot \left(\left(a + b\right) \cdot \pi\right)\right)
Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*l*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6462.0%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6462.0%
Applied rewrites62.0%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (- (fabs b) (fabs a))) (t_1 (* PI (/ (fabs angle) 180.0))))
(*
(copysign 1.0 angle)
(if (<=
(*
(* (* 2.0 (- (pow (fabs b) 2.0) (pow (fabs a) 2.0))) (sin t_1))
(cos t_1))
0.0)
(*
0.011111111111111112
(* (* (fabs angle) (* t_0 (+ (fabs b) (fabs a)))) PI))
(* (* (* (fabs angle) (fabs b)) t_0) (* PI 0.011111111111111112))))))double code(double a, double b, double angle) {
double t_0 = fabs(b) - fabs(a);
double t_1 = ((double) M_PI) * (fabs(angle) / 180.0);
double tmp;
if ((((2.0 * (pow(fabs(b), 2.0) - pow(fabs(a), 2.0))) * sin(t_1)) * cos(t_1)) <= 0.0) {
tmp = 0.011111111111111112 * ((fabs(angle) * (t_0 * (fabs(b) + fabs(a)))) * ((double) M_PI));
} else {
tmp = ((fabs(angle) * fabs(b)) * t_0) * (((double) M_PI) * 0.011111111111111112);
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.abs(b) - Math.abs(a);
double t_1 = Math.PI * (Math.abs(angle) / 180.0);
double tmp;
if ((((2.0 * (Math.pow(Math.abs(b), 2.0) - Math.pow(Math.abs(a), 2.0))) * Math.sin(t_1)) * Math.cos(t_1)) <= 0.0) {
tmp = 0.011111111111111112 * ((Math.abs(angle) * (t_0 * (Math.abs(b) + Math.abs(a)))) * Math.PI);
} else {
tmp = ((Math.abs(angle) * Math.abs(b)) * t_0) * (Math.PI * 0.011111111111111112);
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = math.fabs(b) - math.fabs(a) t_1 = math.pi * (math.fabs(angle) / 180.0) tmp = 0 if (((2.0 * (math.pow(math.fabs(b), 2.0) - math.pow(math.fabs(a), 2.0))) * math.sin(t_1)) * math.cos(t_1)) <= 0.0: tmp = 0.011111111111111112 * ((math.fabs(angle) * (t_0 * (math.fabs(b) + math.fabs(a)))) * math.pi) else: tmp = ((math.fabs(angle) * math.fabs(b)) * t_0) * (math.pi * 0.011111111111111112) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = Float64(abs(b) - abs(a)) t_1 = Float64(pi * Float64(abs(angle) / 180.0)) tmp = 0.0 if (Float64(Float64(Float64(2.0 * Float64((abs(b) ^ 2.0) - (abs(a) ^ 2.0))) * sin(t_1)) * cos(t_1)) <= 0.0) tmp = Float64(0.011111111111111112 * Float64(Float64(abs(angle) * Float64(t_0 * Float64(abs(b) + abs(a)))) * pi)); else tmp = Float64(Float64(Float64(abs(angle) * abs(b)) * t_0) * Float64(pi * 0.011111111111111112)); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = abs(b) - abs(a); t_1 = pi * (abs(angle) / 180.0); tmp = 0.0; if ((((2.0 * ((abs(b) ^ 2.0) - (abs(a) ^ 2.0))) * sin(t_1)) * cos(t_1)) <= 0.0) tmp = 0.011111111111111112 * ((abs(angle) * (t_0 * (abs(b) + abs(a)))) * pi); else tmp = ((abs(angle) * abs(b)) * t_0) * (pi * 0.011111111111111112); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(Pi * N[(N[Abs[angle], $MachinePrecision] / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(N[(N[(2.0 * N[(N[Power[N[Abs[b], $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[Abs[a], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision], 0.0], N[(0.011111111111111112 * N[(N[(N[Abs[angle], $MachinePrecision] * N[(t$95$0 * N[(N[Abs[b], $MachinePrecision] + N[Abs[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[Abs[angle], $MachinePrecision] * N[Abs[b], $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision] * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
t_0 := \left|b\right| - \left|a\right|\\
t_1 := \pi \cdot \frac{\left|angle\right|}{180}\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left(\left(2 \cdot \left({\left(\left|b\right|\right)}^{2} - {\left(\left|a\right|\right)}^{2}\right)\right) \cdot \sin t\_1\right) \cdot \cos t\_1 \leq 0:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(\left|angle\right| \cdot \left(t\_0 \cdot \left(\left|b\right| + \left|a\right|\right)\right)\right) \cdot \pi\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left|angle\right| \cdot \left|b\right|\right) \cdot t\_0\right) \cdot \left(\pi \cdot 0.011111111111111112\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) < 0.0Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
if 0.0 < (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6440.4%
Applied rewrites40.4%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (- (fabs b) (fabs a))) (t_1 (* PI (/ (fabs angle) 180.0))))
(*
(copysign 1.0 angle)
(if (<=
(*
(* (* 2.0 (- (pow (fabs b) 2.0) (pow (fabs a) 2.0))) (sin t_1))
(cos t_1))
0.0)
(* 0.011111111111111112 (* (* (fabs angle) (* t_0 (fabs b))) PI))
(* (* (* (fabs angle) (fabs b)) t_0) (* PI 0.011111111111111112))))))double code(double a, double b, double angle) {
double t_0 = fabs(b) - fabs(a);
double t_1 = ((double) M_PI) * (fabs(angle) / 180.0);
double tmp;
if ((((2.0 * (pow(fabs(b), 2.0) - pow(fabs(a), 2.0))) * sin(t_1)) * cos(t_1)) <= 0.0) {
tmp = 0.011111111111111112 * ((fabs(angle) * (t_0 * fabs(b))) * ((double) M_PI));
} else {
tmp = ((fabs(angle) * fabs(b)) * t_0) * (((double) M_PI) * 0.011111111111111112);
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.abs(b) - Math.abs(a);
double t_1 = Math.PI * (Math.abs(angle) / 180.0);
double tmp;
if ((((2.0 * (Math.pow(Math.abs(b), 2.0) - Math.pow(Math.abs(a), 2.0))) * Math.sin(t_1)) * Math.cos(t_1)) <= 0.0) {
tmp = 0.011111111111111112 * ((Math.abs(angle) * (t_0 * Math.abs(b))) * Math.PI);
} else {
tmp = ((Math.abs(angle) * Math.abs(b)) * t_0) * (Math.PI * 0.011111111111111112);
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = math.fabs(b) - math.fabs(a) t_1 = math.pi * (math.fabs(angle) / 180.0) tmp = 0 if (((2.0 * (math.pow(math.fabs(b), 2.0) - math.pow(math.fabs(a), 2.0))) * math.sin(t_1)) * math.cos(t_1)) <= 0.0: tmp = 0.011111111111111112 * ((math.fabs(angle) * (t_0 * math.fabs(b))) * math.pi) else: tmp = ((math.fabs(angle) * math.fabs(b)) * t_0) * (math.pi * 0.011111111111111112) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = Float64(abs(b) - abs(a)) t_1 = Float64(pi * Float64(abs(angle) / 180.0)) tmp = 0.0 if (Float64(Float64(Float64(2.0 * Float64((abs(b) ^ 2.0) - (abs(a) ^ 2.0))) * sin(t_1)) * cos(t_1)) <= 0.0) tmp = Float64(0.011111111111111112 * Float64(Float64(abs(angle) * Float64(t_0 * abs(b))) * pi)); else tmp = Float64(Float64(Float64(abs(angle) * abs(b)) * t_0) * Float64(pi * 0.011111111111111112)); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = abs(b) - abs(a); t_1 = pi * (abs(angle) / 180.0); tmp = 0.0; if ((((2.0 * ((abs(b) ^ 2.0) - (abs(a) ^ 2.0))) * sin(t_1)) * cos(t_1)) <= 0.0) tmp = 0.011111111111111112 * ((abs(angle) * (t_0 * abs(b))) * pi); else tmp = ((abs(angle) * abs(b)) * t_0) * (pi * 0.011111111111111112); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(Pi * N[(N[Abs[angle], $MachinePrecision] / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(N[(N[(2.0 * N[(N[Power[N[Abs[b], $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[Abs[a], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision], 0.0], N[(0.011111111111111112 * N[(N[(N[Abs[angle], $MachinePrecision] * N[(t$95$0 * N[Abs[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[Abs[angle], $MachinePrecision] * N[Abs[b], $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision] * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
t_0 := \left|b\right| - \left|a\right|\\
t_1 := \pi \cdot \frac{\left|angle\right|}{180}\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left(\left(2 \cdot \left({\left(\left|b\right|\right)}^{2} - {\left(\left|a\right|\right)}^{2}\right)\right) \cdot \sin t\_1\right) \cdot \cos t\_1 \leq 0:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(\left|angle\right| \cdot \left(t\_0 \cdot \left|b\right|\right)\right) \cdot \pi\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left|angle\right| \cdot \left|b\right|\right) \cdot t\_0\right) \cdot \left(\pi \cdot 0.011111111111111112\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) < 0.0Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
if 0.0 < (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6440.4%
Applied rewrites40.4%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (- (fabs b) (fabs a))))
(if (<= (* 2.0 (- (pow (fabs b) 2.0) (pow (fabs a) 2.0))) 5e+135)
(* (* 0.011111111111111112 angle) (* (fabs b) (* t_0 PI)))
(* (* (* 0.011111111111111112 (* t_0 angle)) (fabs b)) PI))))double code(double a, double b, double angle) {
double t_0 = fabs(b) - fabs(a);
double tmp;
if ((2.0 * (pow(fabs(b), 2.0) - pow(fabs(a), 2.0))) <= 5e+135) {
tmp = (0.011111111111111112 * angle) * (fabs(b) * (t_0 * ((double) M_PI)));
} else {
tmp = ((0.011111111111111112 * (t_0 * angle)) * fabs(b)) * ((double) M_PI);
}
return tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.abs(b) - Math.abs(a);
double tmp;
if ((2.0 * (Math.pow(Math.abs(b), 2.0) - Math.pow(Math.abs(a), 2.0))) <= 5e+135) {
tmp = (0.011111111111111112 * angle) * (Math.abs(b) * (t_0 * Math.PI));
} else {
tmp = ((0.011111111111111112 * (t_0 * angle)) * Math.abs(b)) * Math.PI;
}
return tmp;
}
def code(a, b, angle): t_0 = math.fabs(b) - math.fabs(a) tmp = 0 if (2.0 * (math.pow(math.fabs(b), 2.0) - math.pow(math.fabs(a), 2.0))) <= 5e+135: tmp = (0.011111111111111112 * angle) * (math.fabs(b) * (t_0 * math.pi)) else: tmp = ((0.011111111111111112 * (t_0 * angle)) * math.fabs(b)) * math.pi return tmp
function code(a, b, angle) t_0 = Float64(abs(b) - abs(a)) tmp = 0.0 if (Float64(2.0 * Float64((abs(b) ^ 2.0) - (abs(a) ^ 2.0))) <= 5e+135) tmp = Float64(Float64(0.011111111111111112 * angle) * Float64(abs(b) * Float64(t_0 * pi))); else tmp = Float64(Float64(Float64(0.011111111111111112 * Float64(t_0 * angle)) * abs(b)) * pi); end return tmp end
function tmp_2 = code(a, b, angle) t_0 = abs(b) - abs(a); tmp = 0.0; if ((2.0 * ((abs(b) ^ 2.0) - (abs(a) ^ 2.0))) <= 5e+135) tmp = (0.011111111111111112 * angle) * (abs(b) * (t_0 * pi)); else tmp = ((0.011111111111111112 * (t_0 * angle)) * abs(b)) * pi; end tmp_2 = tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(2.0 * N[(N[Power[N[Abs[b], $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[Abs[a], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 5e+135], N[(N[(0.011111111111111112 * angle), $MachinePrecision] * N[(N[Abs[b], $MachinePrecision] * N[(t$95$0 * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(0.011111111111111112 * N[(t$95$0 * angle), $MachinePrecision]), $MachinePrecision] * N[Abs[b], $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]]]
\begin{array}{l}
t_0 := \left|b\right| - \left|a\right|\\
\mathbf{if}\;2 \cdot \left({\left(\left|b\right|\right)}^{2} - {\left(\left|a\right|\right)}^{2}\right) \leq 5 \cdot 10^{+135}:\\
\;\;\;\;\left(0.011111111111111112 \cdot angle\right) \cdot \left(\left|b\right| \cdot \left(t\_0 \cdot \pi\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(0.011111111111111112 \cdot \left(t\_0 \cdot angle\right)\right) \cdot \left|b\right|\right) \cdot \pi\\
\end{array}
if (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) < 5.00000000000000029e135Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6438.0%
Applied rewrites38.0%
if 5.00000000000000029e135 < (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6441.8%
Applied rewrites41.8%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (- (fabs b) (fabs a))) (t_1 (* PI (/ (fabs angle) 180.0))))
(*
(copysign 1.0 angle)
(if (<=
(*
(* (* 2.0 (- (pow (fabs b) 2.0) (pow (fabs a) 2.0))) (sin t_1))
(cos t_1))
2e-77)
(* (* 0.011111111111111112 (fabs angle)) (* (fabs b) (* t_0 PI)))
(* 0.011111111111111112 (* (* t_0 (* (fabs b) (fabs angle))) PI))))))double code(double a, double b, double angle) {
double t_0 = fabs(b) - fabs(a);
double t_1 = ((double) M_PI) * (fabs(angle) / 180.0);
double tmp;
if ((((2.0 * (pow(fabs(b), 2.0) - pow(fabs(a), 2.0))) * sin(t_1)) * cos(t_1)) <= 2e-77) {
tmp = (0.011111111111111112 * fabs(angle)) * (fabs(b) * (t_0 * ((double) M_PI)));
} else {
tmp = 0.011111111111111112 * ((t_0 * (fabs(b) * fabs(angle))) * ((double) M_PI));
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.abs(b) - Math.abs(a);
double t_1 = Math.PI * (Math.abs(angle) / 180.0);
double tmp;
if ((((2.0 * (Math.pow(Math.abs(b), 2.0) - Math.pow(Math.abs(a), 2.0))) * Math.sin(t_1)) * Math.cos(t_1)) <= 2e-77) {
tmp = (0.011111111111111112 * Math.abs(angle)) * (Math.abs(b) * (t_0 * Math.PI));
} else {
tmp = 0.011111111111111112 * ((t_0 * (Math.abs(b) * Math.abs(angle))) * Math.PI);
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = math.fabs(b) - math.fabs(a) t_1 = math.pi * (math.fabs(angle) / 180.0) tmp = 0 if (((2.0 * (math.pow(math.fabs(b), 2.0) - math.pow(math.fabs(a), 2.0))) * math.sin(t_1)) * math.cos(t_1)) <= 2e-77: tmp = (0.011111111111111112 * math.fabs(angle)) * (math.fabs(b) * (t_0 * math.pi)) else: tmp = 0.011111111111111112 * ((t_0 * (math.fabs(b) * math.fabs(angle))) * math.pi) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = Float64(abs(b) - abs(a)) t_1 = Float64(pi * Float64(abs(angle) / 180.0)) tmp = 0.0 if (Float64(Float64(Float64(2.0 * Float64((abs(b) ^ 2.0) - (abs(a) ^ 2.0))) * sin(t_1)) * cos(t_1)) <= 2e-77) tmp = Float64(Float64(0.011111111111111112 * abs(angle)) * Float64(abs(b) * Float64(t_0 * pi))); else tmp = Float64(0.011111111111111112 * Float64(Float64(t_0 * Float64(abs(b) * abs(angle))) * pi)); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = abs(b) - abs(a); t_1 = pi * (abs(angle) / 180.0); tmp = 0.0; if ((((2.0 * ((abs(b) ^ 2.0) - (abs(a) ^ 2.0))) * sin(t_1)) * cos(t_1)) <= 2e-77) tmp = (0.011111111111111112 * abs(angle)) * (abs(b) * (t_0 * pi)); else tmp = 0.011111111111111112 * ((t_0 * (abs(b) * abs(angle))) * pi); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(Pi * N[(N[Abs[angle], $MachinePrecision] / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(N[(N[(2.0 * N[(N[Power[N[Abs[b], $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[Abs[a], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision], 2e-77], N[(N[(0.011111111111111112 * N[Abs[angle], $MachinePrecision]), $MachinePrecision] * N[(N[Abs[b], $MachinePrecision] * N[(t$95$0 * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[(t$95$0 * N[(N[Abs[b], $MachinePrecision] * N[Abs[angle], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
t_0 := \left|b\right| - \left|a\right|\\
t_1 := \pi \cdot \frac{\left|angle\right|}{180}\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left(\left(2 \cdot \left({\left(\left|b\right|\right)}^{2} - {\left(\left|a\right|\right)}^{2}\right)\right) \cdot \sin t\_1\right) \cdot \cos t\_1 \leq 2 \cdot 10^{-77}:\\
\;\;\;\;\left(0.011111111111111112 \cdot \left|angle\right|\right) \cdot \left(\left|b\right| \cdot \left(t\_0 \cdot \pi\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(t\_0 \cdot \left(\left|b\right| \cdot \left|angle\right|\right)\right) \cdot \pi\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) < 1.9999999999999999e-77Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6438.0%
Applied rewrites38.0%
if 1.9999999999999999e-77 < (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6440.4%
Applied rewrites40.4%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (- (fabs b) (fabs a))) (t_1 (* PI (/ (fabs angle) 180.0))))
(*
(copysign 1.0 angle)
(if (<=
(*
(* (* 2.0 (- (pow (fabs b) 2.0) (pow (fabs a) 2.0))) (sin t_1))
(cos t_1))
1e-245)
(* (fabs angle) (* (* (fabs b) (* t_0 PI)) 0.011111111111111112))
(* 0.011111111111111112 (* (* t_0 (* (fabs b) (fabs angle))) PI))))))double code(double a, double b, double angle) {
double t_0 = fabs(b) - fabs(a);
double t_1 = ((double) M_PI) * (fabs(angle) / 180.0);
double tmp;
if ((((2.0 * (pow(fabs(b), 2.0) - pow(fabs(a), 2.0))) * sin(t_1)) * cos(t_1)) <= 1e-245) {
tmp = fabs(angle) * ((fabs(b) * (t_0 * ((double) M_PI))) * 0.011111111111111112);
} else {
tmp = 0.011111111111111112 * ((t_0 * (fabs(b) * fabs(angle))) * ((double) M_PI));
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.abs(b) - Math.abs(a);
double t_1 = Math.PI * (Math.abs(angle) / 180.0);
double tmp;
if ((((2.0 * (Math.pow(Math.abs(b), 2.0) - Math.pow(Math.abs(a), 2.0))) * Math.sin(t_1)) * Math.cos(t_1)) <= 1e-245) {
tmp = Math.abs(angle) * ((Math.abs(b) * (t_0 * Math.PI)) * 0.011111111111111112);
} else {
tmp = 0.011111111111111112 * ((t_0 * (Math.abs(b) * Math.abs(angle))) * Math.PI);
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = math.fabs(b) - math.fabs(a) t_1 = math.pi * (math.fabs(angle) / 180.0) tmp = 0 if (((2.0 * (math.pow(math.fabs(b), 2.0) - math.pow(math.fabs(a), 2.0))) * math.sin(t_1)) * math.cos(t_1)) <= 1e-245: tmp = math.fabs(angle) * ((math.fabs(b) * (t_0 * math.pi)) * 0.011111111111111112) else: tmp = 0.011111111111111112 * ((t_0 * (math.fabs(b) * math.fabs(angle))) * math.pi) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = Float64(abs(b) - abs(a)) t_1 = Float64(pi * Float64(abs(angle) / 180.0)) tmp = 0.0 if (Float64(Float64(Float64(2.0 * Float64((abs(b) ^ 2.0) - (abs(a) ^ 2.0))) * sin(t_1)) * cos(t_1)) <= 1e-245) tmp = Float64(abs(angle) * Float64(Float64(abs(b) * Float64(t_0 * pi)) * 0.011111111111111112)); else tmp = Float64(0.011111111111111112 * Float64(Float64(t_0 * Float64(abs(b) * abs(angle))) * pi)); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = abs(b) - abs(a); t_1 = pi * (abs(angle) / 180.0); tmp = 0.0; if ((((2.0 * ((abs(b) ^ 2.0) - (abs(a) ^ 2.0))) * sin(t_1)) * cos(t_1)) <= 1e-245) tmp = abs(angle) * ((abs(b) * (t_0 * pi)) * 0.011111111111111112); else tmp = 0.011111111111111112 * ((t_0 * (abs(b) * abs(angle))) * pi); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(Pi * N[(N[Abs[angle], $MachinePrecision] / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(N[(N[(2.0 * N[(N[Power[N[Abs[b], $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[Abs[a], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision], 1e-245], N[(N[Abs[angle], $MachinePrecision] * N[(N[(N[Abs[b], $MachinePrecision] * N[(t$95$0 * Pi), $MachinePrecision]), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[(t$95$0 * N[(N[Abs[b], $MachinePrecision] * N[Abs[angle], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
t_0 := \left|b\right| - \left|a\right|\\
t_1 := \pi \cdot \frac{\left|angle\right|}{180}\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left(\left(2 \cdot \left({\left(\left|b\right|\right)}^{2} - {\left(\left|a\right|\right)}^{2}\right)\right) \cdot \sin t\_1\right) \cdot \cos t\_1 \leq 10^{-245}:\\
\;\;\;\;\left|angle\right| \cdot \left(\left(\left|b\right| \cdot \left(t\_0 \cdot \pi\right)\right) \cdot 0.011111111111111112\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(t\_0 \cdot \left(\left|b\right| \cdot \left|angle\right|\right)\right) \cdot \pi\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) < 9.9999999999999993e-246Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6438.1%
Applied rewrites38.1%
if 9.9999999999999993e-246 < (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6440.4%
Applied rewrites40.4%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (- (fabs b) (fabs a))) (t_1 (* PI (/ (fabs angle) 180.0))))
(*
(copysign 1.0 angle)
(if (<=
(*
(* (* 2.0 (- (pow (fabs b) 2.0) (pow (fabs a) 2.0))) (sin t_1))
(cos t_1))
5e-252)
(* 0.011111111111111112 (* (* PI (fabs angle)) (* (fabs b) t_0)))
(* 0.011111111111111112 (* (* t_0 (* (fabs b) (fabs angle))) PI))))))double code(double a, double b, double angle) {
double t_0 = fabs(b) - fabs(a);
double t_1 = ((double) M_PI) * (fabs(angle) / 180.0);
double tmp;
if ((((2.0 * (pow(fabs(b), 2.0) - pow(fabs(a), 2.0))) * sin(t_1)) * cos(t_1)) <= 5e-252) {
tmp = 0.011111111111111112 * ((((double) M_PI) * fabs(angle)) * (fabs(b) * t_0));
} else {
tmp = 0.011111111111111112 * ((t_0 * (fabs(b) * fabs(angle))) * ((double) M_PI));
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.abs(b) - Math.abs(a);
double t_1 = Math.PI * (Math.abs(angle) / 180.0);
double tmp;
if ((((2.0 * (Math.pow(Math.abs(b), 2.0) - Math.pow(Math.abs(a), 2.0))) * Math.sin(t_1)) * Math.cos(t_1)) <= 5e-252) {
tmp = 0.011111111111111112 * ((Math.PI * Math.abs(angle)) * (Math.abs(b) * t_0));
} else {
tmp = 0.011111111111111112 * ((t_0 * (Math.abs(b) * Math.abs(angle))) * Math.PI);
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = math.fabs(b) - math.fabs(a) t_1 = math.pi * (math.fabs(angle) / 180.0) tmp = 0 if (((2.0 * (math.pow(math.fabs(b), 2.0) - math.pow(math.fabs(a), 2.0))) * math.sin(t_1)) * math.cos(t_1)) <= 5e-252: tmp = 0.011111111111111112 * ((math.pi * math.fabs(angle)) * (math.fabs(b) * t_0)) else: tmp = 0.011111111111111112 * ((t_0 * (math.fabs(b) * math.fabs(angle))) * math.pi) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = Float64(abs(b) - abs(a)) t_1 = Float64(pi * Float64(abs(angle) / 180.0)) tmp = 0.0 if (Float64(Float64(Float64(2.0 * Float64((abs(b) ^ 2.0) - (abs(a) ^ 2.0))) * sin(t_1)) * cos(t_1)) <= 5e-252) tmp = Float64(0.011111111111111112 * Float64(Float64(pi * abs(angle)) * Float64(abs(b) * t_0))); else tmp = Float64(0.011111111111111112 * Float64(Float64(t_0 * Float64(abs(b) * abs(angle))) * pi)); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = abs(b) - abs(a); t_1 = pi * (abs(angle) / 180.0); tmp = 0.0; if ((((2.0 * ((abs(b) ^ 2.0) - (abs(a) ^ 2.0))) * sin(t_1)) * cos(t_1)) <= 5e-252) tmp = 0.011111111111111112 * ((pi * abs(angle)) * (abs(b) * t_0)); else tmp = 0.011111111111111112 * ((t_0 * (abs(b) * abs(angle))) * pi); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(Pi * N[(N[Abs[angle], $MachinePrecision] / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(N[(N[(2.0 * N[(N[Power[N[Abs[b], $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[Abs[a], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision], 5e-252], N[(0.011111111111111112 * N[(N[(Pi * N[Abs[angle], $MachinePrecision]), $MachinePrecision] * N[(N[Abs[b], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[(t$95$0 * N[(N[Abs[b], $MachinePrecision] * N[Abs[angle], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
t_0 := \left|b\right| - \left|a\right|\\
t_1 := \pi \cdot \frac{\left|angle\right|}{180}\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left(\left(2 \cdot \left({\left(\left|b\right|\right)}^{2} - {\left(\left|a\right|\right)}^{2}\right)\right) \cdot \sin t\_1\right) \cdot \cos t\_1 \leq 5 \cdot 10^{-252}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(\pi \cdot \left|angle\right|\right) \cdot \left(\left|b\right| \cdot t\_0\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(t\_0 \cdot \left(\left|b\right| \cdot \left|angle\right|\right)\right) \cdot \pi\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) < 5.00000000000000008e-252Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
lower-*.f6438.0%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6438.0%
Applied rewrites38.0%
if 5.00000000000000008e-252 < (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6440.4%
Applied rewrites40.4%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (- (fabs b) (fabs a))) (t_1 (* PI (/ (fabs angle) 180.0))))
(*
(copysign 1.0 angle)
(if (<=
(*
(* (* 2.0 (- (pow (fabs b) 2.0) (pow (fabs a) 2.0))) (sin t_1))
(cos t_1))
0.0)
(* 0.011111111111111112 (* (* (fabs angle) (* t_0 (fabs b))) PI))
(* 0.011111111111111112 (* (* t_0 (fabs angle)) (* (fabs b) PI)))))))double code(double a, double b, double angle) {
double t_0 = fabs(b) - fabs(a);
double t_1 = ((double) M_PI) * (fabs(angle) / 180.0);
double tmp;
if ((((2.0 * (pow(fabs(b), 2.0) - pow(fabs(a), 2.0))) * sin(t_1)) * cos(t_1)) <= 0.0) {
tmp = 0.011111111111111112 * ((fabs(angle) * (t_0 * fabs(b))) * ((double) M_PI));
} else {
tmp = 0.011111111111111112 * ((t_0 * fabs(angle)) * (fabs(b) * ((double) M_PI)));
}
return copysign(1.0, angle) * tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = Math.abs(b) - Math.abs(a);
double t_1 = Math.PI * (Math.abs(angle) / 180.0);
double tmp;
if ((((2.0 * (Math.pow(Math.abs(b), 2.0) - Math.pow(Math.abs(a), 2.0))) * Math.sin(t_1)) * Math.cos(t_1)) <= 0.0) {
tmp = 0.011111111111111112 * ((Math.abs(angle) * (t_0 * Math.abs(b))) * Math.PI);
} else {
tmp = 0.011111111111111112 * ((t_0 * Math.abs(angle)) * (Math.abs(b) * Math.PI));
}
return Math.copySign(1.0, angle) * tmp;
}
def code(a, b, angle): t_0 = math.fabs(b) - math.fabs(a) t_1 = math.pi * (math.fabs(angle) / 180.0) tmp = 0 if (((2.0 * (math.pow(math.fabs(b), 2.0) - math.pow(math.fabs(a), 2.0))) * math.sin(t_1)) * math.cos(t_1)) <= 0.0: tmp = 0.011111111111111112 * ((math.fabs(angle) * (t_0 * math.fabs(b))) * math.pi) else: tmp = 0.011111111111111112 * ((t_0 * math.fabs(angle)) * (math.fabs(b) * math.pi)) return math.copysign(1.0, angle) * tmp
function code(a, b, angle) t_0 = Float64(abs(b) - abs(a)) t_1 = Float64(pi * Float64(abs(angle) / 180.0)) tmp = 0.0 if (Float64(Float64(Float64(2.0 * Float64((abs(b) ^ 2.0) - (abs(a) ^ 2.0))) * sin(t_1)) * cos(t_1)) <= 0.0) tmp = Float64(0.011111111111111112 * Float64(Float64(abs(angle) * Float64(t_0 * abs(b))) * pi)); else tmp = Float64(0.011111111111111112 * Float64(Float64(t_0 * abs(angle)) * Float64(abs(b) * pi))); end return Float64(copysign(1.0, angle) * tmp) end
function tmp_2 = code(a, b, angle) t_0 = abs(b) - abs(a); t_1 = pi * (abs(angle) / 180.0); tmp = 0.0; if ((((2.0 * ((abs(b) ^ 2.0) - (abs(a) ^ 2.0))) * sin(t_1)) * cos(t_1)) <= 0.0) tmp = 0.011111111111111112 * ((abs(angle) * (t_0 * abs(b))) * pi); else tmp = 0.011111111111111112 * ((t_0 * abs(angle)) * (abs(b) * pi)); end tmp_2 = (sign(angle) * abs(1.0)) * tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(Pi * N[(N[Abs[angle], $MachinePrecision] / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[With[{TMP1 = Abs[1.0], TMP2 = Sign[angle]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision] * If[LessEqual[N[(N[(N[(2.0 * N[(N[Power[N[Abs[b], $MachinePrecision], 2.0], $MachinePrecision] - N[Power[N[Abs[a], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$1], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$1], $MachinePrecision]), $MachinePrecision], 0.0], N[(0.011111111111111112 * N[(N[(N[Abs[angle], $MachinePrecision] * N[(t$95$0 * N[Abs[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[(t$95$0 * N[Abs[angle], $MachinePrecision]), $MachinePrecision] * N[(N[Abs[b], $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]]
\begin{array}{l}
t_0 := \left|b\right| - \left|a\right|\\
t_1 := \pi \cdot \frac{\left|angle\right|}{180}\\
\mathsf{copysign}\left(1, angle\right) \cdot \begin{array}{l}
\mathbf{if}\;\left(\left(2 \cdot \left({\left(\left|b\right|\right)}^{2} - {\left(\left|a\right|\right)}^{2}\right)\right) \cdot \sin t\_1\right) \cdot \cos t\_1 \leq 0:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(\left|angle\right| \cdot \left(t\_0 \cdot \left|b\right|\right)\right) \cdot \pi\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(t\_0 \cdot \left|angle\right|\right) \cdot \left(\left|b\right| \cdot \pi\right)\right)\\
\end{array}
\end{array}
if (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) < 0.0Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
if 0.0 < (*.f64 (*.f64 (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) (sin.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) (cos.f64 (*.f64 (PI.f64) (/.f64 angle #s(literal 180 binary64))))) Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*l*N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-*.f6441.8%
Applied rewrites41.8%
(FPCore (a b angle) :precision binary64 (* 0.011111111111111112 (* (* PI angle) (* (fabs b) (- (fabs b) (fabs a))))))
double code(double a, double b, double angle) {
return 0.011111111111111112 * ((((double) M_PI) * angle) * (fabs(b) * (fabs(b) - fabs(a))));
}
public static double code(double a, double b, double angle) {
return 0.011111111111111112 * ((Math.PI * angle) * (Math.abs(b) * (Math.abs(b) - Math.abs(a))));
}
def code(a, b, angle): return 0.011111111111111112 * ((math.pi * angle) * (math.fabs(b) * (math.fabs(b) - math.fabs(a))))
function code(a, b, angle) return Float64(0.011111111111111112 * Float64(Float64(pi * angle) * Float64(abs(b) * Float64(abs(b) - abs(a))))) end
function tmp = code(a, b, angle) tmp = 0.011111111111111112 * ((pi * angle) * (abs(b) * (abs(b) - abs(a)))); end
code[a_, b_, angle_] := N[(0.011111111111111112 * N[(N[(Pi * angle), $MachinePrecision] * N[(N[Abs[b], $MachinePrecision] * N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
0.011111111111111112 \cdot \left(\left(\pi \cdot angle\right) \cdot \left(\left|b\right| \cdot \left(\left|b\right| - \left|a\right|\right)\right)\right)
Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lift-*.f64N/A
lower-*.f6438.0%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6438.0%
Applied rewrites38.0%
(FPCore (a b angle) :precision binary64 (* 0.011111111111111112 (* (* angle (* (- (fabs b) (fabs a)) (fabs b))) PI)))
double code(double a, double b, double angle) {
return 0.011111111111111112 * ((angle * ((fabs(b) - fabs(a)) * fabs(b))) * ((double) M_PI));
}
public static double code(double a, double b, double angle) {
return 0.011111111111111112 * ((angle * ((Math.abs(b) - Math.abs(a)) * Math.abs(b))) * Math.PI);
}
def code(a, b, angle): return 0.011111111111111112 * ((angle * ((math.fabs(b) - math.fabs(a)) * math.fabs(b))) * math.pi)
function code(a, b, angle) return Float64(0.011111111111111112 * Float64(Float64(angle * Float64(Float64(abs(b) - abs(a)) * abs(b))) * pi)) end
function tmp = code(a, b, angle) tmp = 0.011111111111111112 * ((angle * ((abs(b) - abs(a)) * abs(b))) * pi); end
code[a_, b_, angle_] := N[(0.011111111111111112 * N[(N[(angle * N[(N[(N[Abs[b], $MachinePrecision] - N[Abs[a], $MachinePrecision]), $MachinePrecision] * N[Abs[b], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]
0.011111111111111112 \cdot \left(\left(angle \cdot \left(\left(\left|b\right| - \left|a\right|\right) \cdot \left|b\right|\right)\right) \cdot \pi\right)
Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
(FPCore (a b angle) :precision binary64 (* 0.011111111111111112 (* (* angle (* b b)) PI)))
double code(double a, double b, double angle) {
return 0.011111111111111112 * ((angle * (b * b)) * ((double) M_PI));
}
public static double code(double a, double b, double angle) {
return 0.011111111111111112 * ((angle * (b * b)) * Math.PI);
}
def code(a, b, angle): return 0.011111111111111112 * ((angle * (b * b)) * math.pi)
function code(a, b, angle) return Float64(0.011111111111111112 * Float64(Float64(angle * Float64(b * b)) * pi)) end
function tmp = code(a, b, angle) tmp = 0.011111111111111112 * ((angle * (b * b)) * pi); end
code[a_, b_, angle_] := N[(0.011111111111111112 * N[(N[(angle * N[(b * b), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]
0.011111111111111112 \cdot \left(\left(angle \cdot \left(b \cdot b\right)\right) \cdot \pi\right)
Initial program 53.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f64N/A
lower-pow.f64N/A
lower-pow.f6450.6%
Applied rewrites50.6%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.6%
lift--.f64N/A
lift-pow.f64N/A
lift-pow.f64N/A
pow2N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.5%
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.5%
Applied rewrites54.5%
Taylor expanded in a around 0
Applied rewrites38.0%
Taylor expanded in a around 0
Applied rewrites35.3%
herbie shell --seed 2025183
(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)))))