
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* PI (/ angle 180.0)))) (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin t_0)) (cos t_0))))
double code(double a, double b, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
return ((2.0 * (pow(b, 2.0) - pow(a, 2.0))) * sin(t_0)) * cos(t_0);
}
public static double code(double a, double b, double angle) {
double t_0 = Math.PI * (angle / 180.0);
return ((2.0 * (Math.pow(b, 2.0) - Math.pow(a, 2.0))) * Math.sin(t_0)) * Math.cos(t_0);
}
def code(a, b, angle): t_0 = math.pi * (angle / 180.0) return ((2.0 * (math.pow(b, 2.0) - math.pow(a, 2.0))) * math.sin(t_0)) * math.cos(t_0)
function code(a, b, angle) t_0 = Float64(pi * Float64(angle / 180.0)) return Float64(Float64(Float64(2.0 * Float64((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0)) end
function tmp = code(a, b, angle) t_0 = pi * (angle / 180.0); tmp = ((2.0 * ((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
\left(\left(2 \cdot \left({b}^{2} - {a}^{2}\right)\right) \cdot \sin t\_0\right) \cdot \cos t\_0
\end{array}
\end{array}
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}
\\
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
\left(\left(2 \cdot \left({b}^{2} - {a}^{2}\right)\right) \cdot \sin t\_0\right) \cdot \cos t\_0
\end{array}
\end{array}
a_m = (fabs.f64 a)
(FPCore (a_m b angle)
:precision binary64
(let* ((t_0 (* (* angle 0.005555555555555556) PI)))
(if (<= a_m 2.85e+150)
(*
(*
(+ b a_m)
(* (- b a_m) (* 2.0 (sin (* 0.005555555555555556 (* PI angle))))))
(cos t_0))
(if (<= a_m 2.75e+259)
(* 0.011111111111111112 (* (* (- b a_m) (* (+ a_m b) angle)) PI))
(*
(* (* a_m a_m) (sin t_0))
(* (cos (* (* angle PI) -0.005555555555555556)) -2.0))))))a_m = fabs(a);
double code(double a_m, double b, double angle) {
double t_0 = (angle * 0.005555555555555556) * ((double) M_PI);
double tmp;
if (a_m <= 2.85e+150) {
tmp = ((b + a_m) * ((b - a_m) * (2.0 * sin((0.005555555555555556 * (((double) M_PI) * angle)))))) * cos(t_0);
} else if (a_m <= 2.75e+259) {
tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * ((double) M_PI));
} else {
tmp = ((a_m * a_m) * sin(t_0)) * (cos(((angle * ((double) M_PI)) * -0.005555555555555556)) * -2.0);
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double t_0 = (angle * 0.005555555555555556) * Math.PI;
double tmp;
if (a_m <= 2.85e+150) {
tmp = ((b + a_m) * ((b - a_m) * (2.0 * Math.sin((0.005555555555555556 * (Math.PI * angle)))))) * Math.cos(t_0);
} else if (a_m <= 2.75e+259) {
tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * Math.PI);
} else {
tmp = ((a_m * a_m) * Math.sin(t_0)) * (Math.cos(((angle * Math.PI) * -0.005555555555555556)) * -2.0);
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): t_0 = (angle * 0.005555555555555556) * math.pi tmp = 0 if a_m <= 2.85e+150: tmp = ((b + a_m) * ((b - a_m) * (2.0 * math.sin((0.005555555555555556 * (math.pi * angle)))))) * math.cos(t_0) elif a_m <= 2.75e+259: tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * math.pi) else: tmp = ((a_m * a_m) * math.sin(t_0)) * (math.cos(((angle * math.pi) * -0.005555555555555556)) * -2.0) return tmp
a_m = abs(a) function code(a_m, b, angle) t_0 = Float64(Float64(angle * 0.005555555555555556) * pi) tmp = 0.0 if (a_m <= 2.85e+150) tmp = Float64(Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * Float64(2.0 * sin(Float64(0.005555555555555556 * Float64(pi * angle)))))) * cos(t_0)); elseif (a_m <= 2.75e+259) tmp = Float64(0.011111111111111112 * Float64(Float64(Float64(b - a_m) * Float64(Float64(a_m + b) * angle)) * pi)); else tmp = Float64(Float64(Float64(a_m * a_m) * sin(t_0)) * Float64(cos(Float64(Float64(angle * pi) * -0.005555555555555556)) * -2.0)); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) t_0 = (angle * 0.005555555555555556) * pi; tmp = 0.0; if (a_m <= 2.85e+150) tmp = ((b + a_m) * ((b - a_m) * (2.0 * sin((0.005555555555555556 * (pi * angle)))))) * cos(t_0); elseif (a_m <= 2.75e+259) tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * pi); else tmp = ((a_m * a_m) * sin(t_0)) * (cos(((angle * pi) * -0.005555555555555556)) * -2.0); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision]
code[a$95$m_, b_, angle_] := Block[{t$95$0 = N[(N[(angle * 0.005555555555555556), $MachinePrecision] * Pi), $MachinePrecision]}, If[LessEqual[a$95$m, 2.85e+150], N[(N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(2.0 * N[Sin[N[(0.005555555555555556 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision], If[LessEqual[a$95$m, 2.75e+259], N[(0.011111111111111112 * N[(N[(N[(b - a$95$m), $MachinePrecision] * N[(N[(a$95$m + b), $MachinePrecision] * angle), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[(a$95$m * a$95$m), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[(N[Cos[N[(N[(angle * Pi), $MachinePrecision] * -0.005555555555555556), $MachinePrecision]], $MachinePrecision] * -2.0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
t_0 := \left(angle \cdot 0.005555555555555556\right) \cdot \pi\\
\mathbf{if}\;a\_m \leq 2.85 \cdot 10^{+150}:\\
\;\;\;\;\left(\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left(2 \cdot \sin \left(0.005555555555555556 \cdot \left(\pi \cdot angle\right)\right)\right)\right)\right) \cdot \cos t\_0\\
\mathbf{elif}\;a\_m \leq 2.75 \cdot 10^{+259}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(\left(b - a\_m\right) \cdot \left(\left(a\_m + b\right) \cdot angle\right)\right) \cdot \pi\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(a\_m \cdot a\_m\right) \cdot \sin t\_0\right) \cdot \left(\cos \left(\left(angle \cdot \pi\right) \cdot -0.005555555555555556\right) \cdot -2\right)\\
\end{array}
\end{array}
if a < 2.8500000000000001e150Initial program 53.7%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
lower--.f6457.6
Applied rewrites57.6%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.3
lift-sin.f64N/A
lift-*.f64N/A
lift-PI.f64N/A
lift-/.f64N/A
lift-PI.f64N/A
mult-flipN/A
metadata-evalN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
Applied rewrites67.3%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6467.3
lift-/.f64N/A
mult-flipN/A
metadata-evalN/A
lower-*.f6467.4
Applied rewrites67.4%
if 2.8500000000000001e150 < a < 2.75000000000000015e259Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6462.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6462.2
Applied rewrites62.2%
if 2.75000000000000015e259 < a Initial program 53.7%
lift-cos.f64N/A
cos-fabs-revN/A
cos-neg-revN/A
sin-+PI/2-revN/A
lower-sin.f64N/A
lower-+.f64N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
fabs-divN/A
metadata-evalN/A
distribute-neg-frac2N/A
lower-/.f64N/A
lower-fabs.f64N/A
*-commutativeN/A
lower-*.f64N/A
metadata-evalN/A
lift-PI.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval53.0
Applied rewrites53.0%
Taylor expanded in a around inf
lower-*.f64N/A
lower-*.f64N/A
lower-pow.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
Applied rewrites34.4%
Applied rewrites34.9%
a_m = (fabs.f64 a)
(FPCore (a_m b angle)
:precision binary64
(let* ((t_0 (* PI (/ angle 180.0))))
(if (<= angle 4.2e+125)
(*
(*
(+ b a_m)
(*
(- b a_m)
(-
(sin (* (* angle 0.005555555555555556) PI))
(sin (* (* angle PI) -0.005555555555555556)))))
(cos t_0))
(*
(* (* 2.0 (* (- b a_m) (+ b a_m))) (sin t_0))
(sin (+ (/ (fabs (* angle PI)) -180.0) (* 0.5 PI)))))))a_m = fabs(a);
double code(double a_m, double b, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
double tmp;
if (angle <= 4.2e+125) {
tmp = ((b + a_m) * ((b - a_m) * (sin(((angle * 0.005555555555555556) * ((double) M_PI))) - sin(((angle * ((double) M_PI)) * -0.005555555555555556))))) * cos(t_0);
} else {
tmp = ((2.0 * ((b - a_m) * (b + a_m))) * sin(t_0)) * sin(((fabs((angle * ((double) M_PI))) / -180.0) + (0.5 * ((double) M_PI))));
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double t_0 = Math.PI * (angle / 180.0);
double tmp;
if (angle <= 4.2e+125) {
tmp = ((b + a_m) * ((b - a_m) * (Math.sin(((angle * 0.005555555555555556) * Math.PI)) - Math.sin(((angle * Math.PI) * -0.005555555555555556))))) * Math.cos(t_0);
} else {
tmp = ((2.0 * ((b - a_m) * (b + a_m))) * Math.sin(t_0)) * Math.sin(((Math.abs((angle * Math.PI)) / -180.0) + (0.5 * Math.PI)));
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): t_0 = math.pi * (angle / 180.0) tmp = 0 if angle <= 4.2e+125: tmp = ((b + a_m) * ((b - a_m) * (math.sin(((angle * 0.005555555555555556) * math.pi)) - math.sin(((angle * math.pi) * -0.005555555555555556))))) * math.cos(t_0) else: tmp = ((2.0 * ((b - a_m) * (b + a_m))) * math.sin(t_0)) * math.sin(((math.fabs((angle * math.pi)) / -180.0) + (0.5 * math.pi))) return tmp
a_m = abs(a) function code(a_m, b, angle) t_0 = Float64(pi * Float64(angle / 180.0)) tmp = 0.0 if (angle <= 4.2e+125) tmp = Float64(Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * Float64(sin(Float64(Float64(angle * 0.005555555555555556) * pi)) - sin(Float64(Float64(angle * pi) * -0.005555555555555556))))) * cos(t_0)); else tmp = Float64(Float64(Float64(2.0 * Float64(Float64(b - a_m) * Float64(b + a_m))) * sin(t_0)) * sin(Float64(Float64(abs(Float64(angle * pi)) / -180.0) + Float64(0.5 * pi)))); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) t_0 = pi * (angle / 180.0); tmp = 0.0; if (angle <= 4.2e+125) tmp = ((b + a_m) * ((b - a_m) * (sin(((angle * 0.005555555555555556) * pi)) - sin(((angle * pi) * -0.005555555555555556))))) * cos(t_0); else tmp = ((2.0 * ((b - a_m) * (b + a_m))) * sin(t_0)) * sin(((abs((angle * pi)) / -180.0) + (0.5 * pi))); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision]
code[a$95$m_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[angle, 4.2e+125], N[(N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(N[Sin[N[(N[(angle * 0.005555555555555556), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] - N[Sin[N[(N[(angle * Pi), $MachinePrecision] * -0.005555555555555556), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision], N[(N[(N[(2.0 * N[(N[(b - a$95$m), $MachinePrecision] * N[(b + a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[(N[Abs[N[(angle * Pi), $MachinePrecision]], $MachinePrecision] / -180.0), $MachinePrecision] + N[(0.5 * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
\mathbf{if}\;angle \leq 4.2 \cdot 10^{+125}:\\
\;\;\;\;\left(\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left(\sin \left(\left(angle \cdot 0.005555555555555556\right) \cdot \pi\right) - \sin \left(\left(angle \cdot \pi\right) \cdot -0.005555555555555556\right)\right)\right)\right) \cdot \cos t\_0\\
\mathbf{else}:\\
\;\;\;\;\left(\left(2 \cdot \left(\left(b - a\_m\right) \cdot \left(b + a\_m\right)\right)\right) \cdot \sin t\_0\right) \cdot \sin \left(\frac{\left|angle \cdot \pi\right|}{-180} + 0.5 \cdot \pi\right)\\
\end{array}
\end{array}
if angle < 4.2000000000000001e125Initial program 53.7%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
lower--.f6457.6
Applied rewrites57.6%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.3
lift-sin.f64N/A
lift-*.f64N/A
lift-PI.f64N/A
lift-/.f64N/A
lift-PI.f64N/A
mult-flipN/A
metadata-evalN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
Applied rewrites67.3%
lift-*.f64N/A
count-2-revN/A
add-flipN/A
lift-sin.f64N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
*-commutativeN/A
metadata-evalN/A
mult-flip-revN/A
lift-*.f64N/A
*-commutativeN/A
associate-*r/N/A
lift-PI.f64N/A
lift-PI.f64N/A
lift-/.f64N/A
lift-*.f64N/A
cos-+PI/2-revN/A
Applied rewrites67.3%
if 4.2000000000000001e125 < angle Initial program 53.7%
lift-cos.f64N/A
cos-fabs-revN/A
cos-neg-revN/A
sin-+PI/2-revN/A
lower-sin.f64N/A
lower-+.f64N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
fabs-divN/A
metadata-evalN/A
distribute-neg-frac2N/A
lower-/.f64N/A
lower-fabs.f64N/A
*-commutativeN/A
lower-*.f64N/A
metadata-evalN/A
lift-PI.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval53.0
Applied rewrites53.0%
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6456.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6456.8
Applied rewrites56.8%
a_m = (fabs.f64 a)
(FPCore (a_m b angle)
:precision binary64
(let* ((t_0 (* PI (/ angle 180.0))))
(if (<= angle 4.2e+125)
(*
(*
(+ b a_m)
(* (- b a_m) (* 2.0 (sin (* 0.005555555555555556 (* PI angle))))))
(cos t_0))
(*
(* (* 2.0 (* (- b a_m) (+ b a_m))) (sin t_0))
(sin (+ (/ (fabs (* angle PI)) -180.0) (* 0.5 PI)))))))a_m = fabs(a);
double code(double a_m, double b, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
double tmp;
if (angle <= 4.2e+125) {
tmp = ((b + a_m) * ((b - a_m) * (2.0 * sin((0.005555555555555556 * (((double) M_PI) * angle)))))) * cos(t_0);
} else {
tmp = ((2.0 * ((b - a_m) * (b + a_m))) * sin(t_0)) * sin(((fabs((angle * ((double) M_PI))) / -180.0) + (0.5 * ((double) M_PI))));
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double t_0 = Math.PI * (angle / 180.0);
double tmp;
if (angle <= 4.2e+125) {
tmp = ((b + a_m) * ((b - a_m) * (2.0 * Math.sin((0.005555555555555556 * (Math.PI * angle)))))) * Math.cos(t_0);
} else {
tmp = ((2.0 * ((b - a_m) * (b + a_m))) * Math.sin(t_0)) * Math.sin(((Math.abs((angle * Math.PI)) / -180.0) + (0.5 * Math.PI)));
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): t_0 = math.pi * (angle / 180.0) tmp = 0 if angle <= 4.2e+125: tmp = ((b + a_m) * ((b - a_m) * (2.0 * math.sin((0.005555555555555556 * (math.pi * angle)))))) * math.cos(t_0) else: tmp = ((2.0 * ((b - a_m) * (b + a_m))) * math.sin(t_0)) * math.sin(((math.fabs((angle * math.pi)) / -180.0) + (0.5 * math.pi))) return tmp
a_m = abs(a) function code(a_m, b, angle) t_0 = Float64(pi * Float64(angle / 180.0)) tmp = 0.0 if (angle <= 4.2e+125) tmp = Float64(Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * Float64(2.0 * sin(Float64(0.005555555555555556 * Float64(pi * angle)))))) * cos(t_0)); else tmp = Float64(Float64(Float64(2.0 * Float64(Float64(b - a_m) * Float64(b + a_m))) * sin(t_0)) * sin(Float64(Float64(abs(Float64(angle * pi)) / -180.0) + Float64(0.5 * pi)))); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) t_0 = pi * (angle / 180.0); tmp = 0.0; if (angle <= 4.2e+125) tmp = ((b + a_m) * ((b - a_m) * (2.0 * sin((0.005555555555555556 * (pi * angle)))))) * cos(t_0); else tmp = ((2.0 * ((b - a_m) * (b + a_m))) * sin(t_0)) * sin(((abs((angle * pi)) / -180.0) + (0.5 * pi))); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision]
code[a$95$m_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[angle, 4.2e+125], N[(N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(2.0 * N[Sin[N[(0.005555555555555556 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision], N[(N[(N[(2.0 * N[(N[(b - a$95$m), $MachinePrecision] * N[(b + a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[(N[Abs[N[(angle * Pi), $MachinePrecision]], $MachinePrecision] / -180.0), $MachinePrecision] + N[(0.5 * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
\mathbf{if}\;angle \leq 4.2 \cdot 10^{+125}:\\
\;\;\;\;\left(\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left(2 \cdot \sin \left(0.005555555555555556 \cdot \left(\pi \cdot angle\right)\right)\right)\right)\right) \cdot \cos t\_0\\
\mathbf{else}:\\
\;\;\;\;\left(\left(2 \cdot \left(\left(b - a\_m\right) \cdot \left(b + a\_m\right)\right)\right) \cdot \sin t\_0\right) \cdot \sin \left(\frac{\left|angle \cdot \pi\right|}{-180} + 0.5 \cdot \pi\right)\\
\end{array}
\end{array}
if angle < 4.2000000000000001e125Initial program 53.7%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
lower--.f6457.6
Applied rewrites57.6%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.3
lift-sin.f64N/A
lift-*.f64N/A
lift-PI.f64N/A
lift-/.f64N/A
lift-PI.f64N/A
mult-flipN/A
metadata-evalN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
Applied rewrites67.3%
if 4.2000000000000001e125 < angle Initial program 53.7%
lift-cos.f64N/A
cos-fabs-revN/A
cos-neg-revN/A
sin-+PI/2-revN/A
lower-sin.f64N/A
lower-+.f64N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
fabs-divN/A
metadata-evalN/A
distribute-neg-frac2N/A
lower-/.f64N/A
lower-fabs.f64N/A
*-commutativeN/A
lower-*.f64N/A
metadata-evalN/A
lift-PI.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval53.0
Applied rewrites53.0%
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6456.8
lift-+.f64N/A
+-commutativeN/A
lower-+.f6456.8
Applied rewrites56.8%
a_m = (fabs.f64 a)
(FPCore (a_m b angle)
:precision binary64
(if (<= a_m 1.2e+229)
(*
(*
(+ a_m b)
(* (- b a_m) (* (sin (* (* 0.005555555555555556 angle) PI)) 2.0)))
(cos (* PI (/ angle 180.0))))
(*
(*
(+ b a_m)
(* (- b a_m) (* 2.0 (sin (* 0.005555555555555556 (* PI angle))))))
1.0)))a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (a_m <= 1.2e+229) {
tmp = ((a_m + b) * ((b - a_m) * (sin(((0.005555555555555556 * angle) * ((double) M_PI))) * 2.0))) * cos((((double) M_PI) * (angle / 180.0)));
} else {
tmp = ((b + a_m) * ((b - a_m) * (2.0 * sin((0.005555555555555556 * (((double) M_PI) * angle)))))) * 1.0;
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double tmp;
if (a_m <= 1.2e+229) {
tmp = ((a_m + b) * ((b - a_m) * (Math.sin(((0.005555555555555556 * angle) * Math.PI)) * 2.0))) * Math.cos((Math.PI * (angle / 180.0)));
} else {
tmp = ((b + a_m) * ((b - a_m) * (2.0 * Math.sin((0.005555555555555556 * (Math.PI * angle)))))) * 1.0;
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): tmp = 0 if a_m <= 1.2e+229: tmp = ((a_m + b) * ((b - a_m) * (math.sin(((0.005555555555555556 * angle) * math.pi)) * 2.0))) * math.cos((math.pi * (angle / 180.0))) else: tmp = ((b + a_m) * ((b - a_m) * (2.0 * math.sin((0.005555555555555556 * (math.pi * angle)))))) * 1.0 return tmp
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (a_m <= 1.2e+229) tmp = Float64(Float64(Float64(a_m + b) * Float64(Float64(b - a_m) * Float64(sin(Float64(Float64(0.005555555555555556 * angle) * pi)) * 2.0))) * cos(Float64(pi * Float64(angle / 180.0)))); else tmp = Float64(Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * Float64(2.0 * sin(Float64(0.005555555555555556 * Float64(pi * angle)))))) * 1.0); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) tmp = 0.0; if (a_m <= 1.2e+229) tmp = ((a_m + b) * ((b - a_m) * (sin(((0.005555555555555556 * angle) * pi)) * 2.0))) * cos((pi * (angle / 180.0))); else tmp = ((b + a_m) * ((b - a_m) * (2.0 * sin((0.005555555555555556 * (pi * angle)))))) * 1.0; end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[a$95$m, 1.2e+229], N[(N[(N[(a$95$m + b), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(N[Sin[N[(N[(0.005555555555555556 * angle), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(2.0 * N[Sin[N[(0.005555555555555556 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;a\_m \leq 1.2 \cdot 10^{+229}:\\
\;\;\;\;\left(\left(a\_m + b\right) \cdot \left(\left(b - a\_m\right) \cdot \left(\sin \left(\left(0.005555555555555556 \cdot angle\right) \cdot \pi\right) \cdot 2\right)\right)\right) \cdot \cos \left(\pi \cdot \frac{angle}{180}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left(2 \cdot \sin \left(0.005555555555555556 \cdot \left(\pi \cdot angle\right)\right)\right)\right)\right) \cdot 1\\
\end{array}
\end{array}
if a < 1.2e229Initial program 53.7%
lift-*.f64N/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
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-*.f6467.3
Applied rewrites67.3%
if 1.2e229 < a Initial program 53.7%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
lower--.f6457.6
Applied rewrites57.6%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.3
lift-sin.f64N/A
lift-*.f64N/A
lift-PI.f64N/A
lift-/.f64N/A
lift-PI.f64N/A
mult-flipN/A
metadata-evalN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
Applied rewrites67.3%
Taylor expanded in angle around 0
Applied rewrites65.1%
a_m = (fabs.f64 a)
(FPCore (a_m b angle)
:precision binary64
(if (<= a_m 1.16e+229)
(*
(+ a_m b)
(*
(- b a_m)
(sin
(*
(* (* angle (pow PI 0.6666666666666666)) (cbrt PI))
0.011111111111111112))))
(*
(*
(+ b a_m)
(* (- b a_m) (* 2.0 (sin (* 0.005555555555555556 (* PI angle))))))
1.0)))a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (a_m <= 1.16e+229) {
tmp = (a_m + b) * ((b - a_m) * sin((((angle * pow(((double) M_PI), 0.6666666666666666)) * cbrt(((double) M_PI))) * 0.011111111111111112)));
} else {
tmp = ((b + a_m) * ((b - a_m) * (2.0 * sin((0.005555555555555556 * (((double) M_PI) * angle)))))) * 1.0;
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double tmp;
if (a_m <= 1.16e+229) {
tmp = (a_m + b) * ((b - a_m) * Math.sin((((angle * Math.pow(Math.PI, 0.6666666666666666)) * Math.cbrt(Math.PI)) * 0.011111111111111112)));
} else {
tmp = ((b + a_m) * ((b - a_m) * (2.0 * Math.sin((0.005555555555555556 * (Math.PI * angle)))))) * 1.0;
}
return tmp;
}
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (a_m <= 1.16e+229) tmp = Float64(Float64(a_m + b) * Float64(Float64(b - a_m) * sin(Float64(Float64(Float64(angle * (pi ^ 0.6666666666666666)) * cbrt(pi)) * 0.011111111111111112)))); else tmp = Float64(Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * Float64(2.0 * sin(Float64(0.005555555555555556 * Float64(pi * angle)))))) * 1.0); end return tmp end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[a$95$m, 1.16e+229], N[(N[(a$95$m + b), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Sin[N[(N[(N[(angle * N[Power[Pi, 0.6666666666666666], $MachinePrecision]), $MachinePrecision] * N[Power[Pi, 1/3], $MachinePrecision]), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(2.0 * N[Sin[N[(0.005555555555555556 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;a\_m \leq 1.16 \cdot 10^{+229}:\\
\;\;\;\;\left(a\_m + b\right) \cdot \left(\left(b - a\_m\right) \cdot \sin \left(\left(\left(angle \cdot {\pi}^{0.6666666666666666}\right) \cdot \sqrt[3]{\pi}\right) \cdot 0.011111111111111112\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left(2 \cdot \sin \left(0.005555555555555556 \cdot \left(\pi \cdot angle\right)\right)\right)\right)\right) \cdot 1\\
\end{array}
\end{array}
if a < 1.16000000000000001e229Initial program 53.7%
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.0%
lift-*.f64N/A
lift-PI.f64N/A
add-cube-cbrtN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lift-PI.f64N/A
pow1/3N/A
lift-PI.f64N/A
pow1/3N/A
pow-prod-upN/A
lower-pow.f64N/A
metadata-evalN/A
lift-PI.f64N/A
lower-cbrt.f6467.1
Applied rewrites67.1%
if 1.16000000000000001e229 < a Initial program 53.7%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
lower--.f6457.6
Applied rewrites57.6%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.3
lift-sin.f64N/A
lift-*.f64N/A
lift-PI.f64N/A
lift-/.f64N/A
lift-PI.f64N/A
mult-flipN/A
metadata-evalN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
Applied rewrites67.3%
Taylor expanded in angle around 0
Applied rewrites65.1%
a_m = (fabs.f64 a)
(FPCore (a_m b angle)
:precision binary64
(if (<= a_m 5e+206)
(* (- b a_m) (* (sin (* (* 0.011111111111111112 angle) PI)) (+ b a_m)))
(*
(*
(+ b a_m)
(* (- b a_m) (* 2.0 (sin (* 0.005555555555555556 (* PI angle))))))
1.0)))a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (a_m <= 5e+206) {
tmp = (b - a_m) * (sin(((0.011111111111111112 * angle) * ((double) M_PI))) * (b + a_m));
} else {
tmp = ((b + a_m) * ((b - a_m) * (2.0 * sin((0.005555555555555556 * (((double) M_PI) * angle)))))) * 1.0;
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double tmp;
if (a_m <= 5e+206) {
tmp = (b - a_m) * (Math.sin(((0.011111111111111112 * angle) * Math.PI)) * (b + a_m));
} else {
tmp = ((b + a_m) * ((b - a_m) * (2.0 * Math.sin((0.005555555555555556 * (Math.PI * angle)))))) * 1.0;
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): tmp = 0 if a_m <= 5e+206: tmp = (b - a_m) * (math.sin(((0.011111111111111112 * angle) * math.pi)) * (b + a_m)) else: tmp = ((b + a_m) * ((b - a_m) * (2.0 * math.sin((0.005555555555555556 * (math.pi * angle)))))) * 1.0 return tmp
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (a_m <= 5e+206) tmp = Float64(Float64(b - a_m) * Float64(sin(Float64(Float64(0.011111111111111112 * angle) * pi)) * Float64(b + a_m))); else tmp = Float64(Float64(Float64(b + a_m) * Float64(Float64(b - a_m) * Float64(2.0 * sin(Float64(0.005555555555555556 * Float64(pi * angle)))))) * 1.0); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) tmp = 0.0; if (a_m <= 5e+206) tmp = (b - a_m) * (sin(((0.011111111111111112 * angle) * pi)) * (b + a_m)); else tmp = ((b + a_m) * ((b - a_m) * (2.0 * sin((0.005555555555555556 * (pi * angle)))))) * 1.0; end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[a$95$m, 5e+206], N[(N[(b - a$95$m), $MachinePrecision] * N[(N[Sin[N[(N[(0.011111111111111112 * angle), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * N[(b + a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b + a$95$m), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(2.0 * N[Sin[N[(0.005555555555555556 * N[(Pi * angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;a\_m \leq 5 \cdot 10^{+206}:\\
\;\;\;\;\left(b - a\_m\right) \cdot \left(\sin \left(\left(0.011111111111111112 \cdot angle\right) \cdot \pi\right) \cdot \left(b + a\_m\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b + a\_m\right) \cdot \left(\left(b - a\_m\right) \cdot \left(2 \cdot \sin \left(0.005555555555555556 \cdot \left(\pi \cdot angle\right)\right)\right)\right)\right) \cdot 1\\
\end{array}
\end{array}
if a < 5.0000000000000002e206Initial program 53.7%
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.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.0
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6467.6
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.6
Applied rewrites67.6%
if 5.0000000000000002e206 < a Initial program 53.7%
lift-*.f64N/A
*-commutativeN/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
associate-*l*N/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-*.f64N/A
lower--.f6457.6
Applied rewrites57.6%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lift-+.f64N/A
+-commutativeN/A
lower-+.f64N/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.3
lift-sin.f64N/A
lift-*.f64N/A
lift-PI.f64N/A
lift-/.f64N/A
lift-PI.f64N/A
mult-flipN/A
metadata-evalN/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
Applied rewrites67.3%
Taylor expanded in angle around 0
Applied rewrites65.1%
a_m = (fabs.f64 a)
(FPCore (a_m b angle)
:precision binary64
(if (<= angle 3.4e-43)
(* (+ a_m b) (* 0.011111111111111112 (* angle (* PI (- b a_m)))))
(if (<= angle 4.4e+139)
(* (* (- b a_m) (+ a_m b)) (sin (* (* angle PI) 0.011111111111111112)))
(* angle (* (* (- b a_m) (* (+ a_m b) PI)) 0.011111111111111112)))))a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 3.4e-43) {
tmp = (a_m + b) * (0.011111111111111112 * (angle * (((double) M_PI) * (b - a_m))));
} else if (angle <= 4.4e+139) {
tmp = ((b - a_m) * (a_m + b)) * sin(((angle * ((double) M_PI)) * 0.011111111111111112));
} else {
tmp = angle * (((b - a_m) * ((a_m + b) * ((double) M_PI))) * 0.011111111111111112);
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 3.4e-43) {
tmp = (a_m + b) * (0.011111111111111112 * (angle * (Math.PI * (b - a_m))));
} else if (angle <= 4.4e+139) {
tmp = ((b - a_m) * (a_m + b)) * Math.sin(((angle * Math.PI) * 0.011111111111111112));
} else {
tmp = angle * (((b - a_m) * ((a_m + b) * Math.PI)) * 0.011111111111111112);
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): tmp = 0 if angle <= 3.4e-43: tmp = (a_m + b) * (0.011111111111111112 * (angle * (math.pi * (b - a_m)))) elif angle <= 4.4e+139: tmp = ((b - a_m) * (a_m + b)) * math.sin(((angle * math.pi) * 0.011111111111111112)) else: tmp = angle * (((b - a_m) * ((a_m + b) * math.pi)) * 0.011111111111111112) return tmp
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (angle <= 3.4e-43) tmp = Float64(Float64(a_m + b) * Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(b - a_m))))); elseif (angle <= 4.4e+139) tmp = Float64(Float64(Float64(b - a_m) * Float64(a_m + b)) * sin(Float64(Float64(angle * pi) * 0.011111111111111112))); else tmp = Float64(angle * Float64(Float64(Float64(b - a_m) * Float64(Float64(a_m + b) * pi)) * 0.011111111111111112)); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) tmp = 0.0; if (angle <= 3.4e-43) tmp = (a_m + b) * (0.011111111111111112 * (angle * (pi * (b - a_m)))); elseif (angle <= 4.4e+139) tmp = ((b - a_m) * (a_m + b)) * sin(((angle * pi) * 0.011111111111111112)); else tmp = angle * (((b - a_m) * ((a_m + b) * pi)) * 0.011111111111111112); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[angle, 3.4e-43], N[(N[(a$95$m + b), $MachinePrecision] * N[(0.011111111111111112 * N[(angle * N[(Pi * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[angle, 4.4e+139], N[(N[(N[(b - a$95$m), $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[(angle * Pi), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(angle * N[(N[(N[(b - a$95$m), $MachinePrecision] * N[(N[(a$95$m + b), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;angle \leq 3.4 \cdot 10^{-43}:\\
\;\;\;\;\left(a\_m + b\right) \cdot \left(0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(b - a\_m\right)\right)\right)\right)\\
\mathbf{elif}\;angle \leq 4.4 \cdot 10^{+139}:\\
\;\;\;\;\left(\left(b - a\_m\right) \cdot \left(a\_m + b\right)\right) \cdot \sin \left(\left(angle \cdot \pi\right) \cdot 0.011111111111111112\right)\\
\mathbf{else}:\\
\;\;\;\;angle \cdot \left(\left(\left(b - a\_m\right) \cdot \left(\left(a\_m + b\right) \cdot \pi\right)\right) \cdot 0.011111111111111112\right)\\
\end{array}
\end{array}
if angle < 3.4000000000000001e-43Initial program 53.7%
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.0%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f6462.3
Applied rewrites62.3%
if 3.4000000000000001e-43 < angle < 4.3999999999999999e139Initial program 53.7%
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.3%
if 4.3999999999999999e139 < angle Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*l*N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
difference-of-squares-revN/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
lift--.f64N/A
lower-*.f64N/A
Applied rewrites54.2%
a_m = (fabs.f64 a) (FPCore (a_m b angle) :precision binary64 (if (<= angle 4.4e+139) (* (+ a_m b) (* (- b a_m) (sin (* (* angle PI) 0.011111111111111112)))) (* angle (* (* (- b a_m) (* (+ a_m b) PI)) 0.011111111111111112))))
a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 4.4e+139) {
tmp = (a_m + b) * ((b - a_m) * sin(((angle * ((double) M_PI)) * 0.011111111111111112)));
} else {
tmp = angle * (((b - a_m) * ((a_m + b) * ((double) M_PI))) * 0.011111111111111112);
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 4.4e+139) {
tmp = (a_m + b) * ((b - a_m) * Math.sin(((angle * Math.PI) * 0.011111111111111112)));
} else {
tmp = angle * (((b - a_m) * ((a_m + b) * Math.PI)) * 0.011111111111111112);
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): tmp = 0 if angle <= 4.4e+139: tmp = (a_m + b) * ((b - a_m) * math.sin(((angle * math.pi) * 0.011111111111111112))) else: tmp = angle * (((b - a_m) * ((a_m + b) * math.pi)) * 0.011111111111111112) return tmp
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (angle <= 4.4e+139) tmp = Float64(Float64(a_m + b) * Float64(Float64(b - a_m) * sin(Float64(Float64(angle * pi) * 0.011111111111111112)))); else tmp = Float64(angle * Float64(Float64(Float64(b - a_m) * Float64(Float64(a_m + b) * pi)) * 0.011111111111111112)); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) tmp = 0.0; if (angle <= 4.4e+139) tmp = (a_m + b) * ((b - a_m) * sin(((angle * pi) * 0.011111111111111112))); else tmp = angle * (((b - a_m) * ((a_m + b) * pi)) * 0.011111111111111112); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[angle, 4.4e+139], N[(N[(a$95$m + b), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Sin[N[(N[(angle * Pi), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(angle * N[(N[(N[(b - a$95$m), $MachinePrecision] * N[(N[(a$95$m + b), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;angle \leq 4.4 \cdot 10^{+139}:\\
\;\;\;\;\left(a\_m + b\right) \cdot \left(\left(b - a\_m\right) \cdot \sin \left(\left(angle \cdot \pi\right) \cdot 0.011111111111111112\right)\right)\\
\mathbf{else}:\\
\;\;\;\;angle \cdot \left(\left(\left(b - a\_m\right) \cdot \left(\left(a\_m + b\right) \cdot \pi\right)\right) \cdot 0.011111111111111112\right)\\
\end{array}
\end{array}
if angle < 4.3999999999999999e139Initial program 53.7%
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.0%
if 4.3999999999999999e139 < angle Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*l*N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
difference-of-squares-revN/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
lift--.f64N/A
lower-*.f64N/A
Applied rewrites54.2%
a_m = (fabs.f64 a) (FPCore (a_m b angle) :precision binary64 (if (<= b 1.06e+110) (* (+ a_m b) (* (- b a_m) (sin (* (* 0.011111111111111112 PI) angle)))) (* (+ a_m b) (* 0.011111111111111112 (* angle (* PI (- b a_m)))))))
a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (b <= 1.06e+110) {
tmp = (a_m + b) * ((b - a_m) * sin(((0.011111111111111112 * ((double) M_PI)) * angle)));
} else {
tmp = (a_m + b) * (0.011111111111111112 * (angle * (((double) M_PI) * (b - a_m))));
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double tmp;
if (b <= 1.06e+110) {
tmp = (a_m + b) * ((b - a_m) * Math.sin(((0.011111111111111112 * Math.PI) * angle)));
} else {
tmp = (a_m + b) * (0.011111111111111112 * (angle * (Math.PI * (b - a_m))));
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): tmp = 0 if b <= 1.06e+110: tmp = (a_m + b) * ((b - a_m) * math.sin(((0.011111111111111112 * math.pi) * angle))) else: tmp = (a_m + b) * (0.011111111111111112 * (angle * (math.pi * (b - a_m)))) return tmp
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (b <= 1.06e+110) tmp = Float64(Float64(a_m + b) * Float64(Float64(b - a_m) * sin(Float64(Float64(0.011111111111111112 * pi) * angle)))); else tmp = Float64(Float64(a_m + b) * Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(b - a_m))))); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) tmp = 0.0; if (b <= 1.06e+110) tmp = (a_m + b) * ((b - a_m) * sin(((0.011111111111111112 * pi) * angle))); else tmp = (a_m + b) * (0.011111111111111112 * (angle * (pi * (b - a_m)))); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[b, 1.06e+110], N[(N[(a$95$m + b), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[Sin[N[(N[(0.011111111111111112 * Pi), $MachinePrecision] * angle), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(a$95$m + b), $MachinePrecision] * N[(0.011111111111111112 * N[(angle * N[(Pi * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;b \leq 1.06 \cdot 10^{+110}:\\
\;\;\;\;\left(a\_m + b\right) \cdot \left(\left(b - a\_m\right) \cdot \sin \left(\left(0.011111111111111112 \cdot \pi\right) \cdot angle\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(a\_m + b\right) \cdot \left(0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(b - a\_m\right)\right)\right)\right)\\
\end{array}
\end{array}
if b < 1.06000000000000005e110Initial program 53.7%
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.0%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6467.2
Applied rewrites67.2%
if 1.06000000000000005e110 < b Initial program 53.7%
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.0%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f6462.3
Applied rewrites62.3%
a_m = (fabs.f64 a) (FPCore (a_m b angle) :precision binary64 (if (<= a_m 5.8e+200) (* (- b a_m) (* (sin (* (* 0.011111111111111112 angle) PI)) (+ b a_m))) (* 0.011111111111111112 (* (* (- b a_m) (* (+ a_m b) angle)) PI))))
a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (a_m <= 5.8e+200) {
tmp = (b - a_m) * (sin(((0.011111111111111112 * angle) * ((double) M_PI))) * (b + a_m));
} else {
tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * ((double) M_PI));
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double tmp;
if (a_m <= 5.8e+200) {
tmp = (b - a_m) * (Math.sin(((0.011111111111111112 * angle) * Math.PI)) * (b + a_m));
} else {
tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * Math.PI);
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): tmp = 0 if a_m <= 5.8e+200: tmp = (b - a_m) * (math.sin(((0.011111111111111112 * angle) * math.pi)) * (b + a_m)) else: tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * math.pi) return tmp
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (a_m <= 5.8e+200) tmp = Float64(Float64(b - a_m) * Float64(sin(Float64(Float64(0.011111111111111112 * angle) * pi)) * Float64(b + a_m))); else tmp = Float64(0.011111111111111112 * Float64(Float64(Float64(b - a_m) * Float64(Float64(a_m + b) * angle)) * pi)); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) tmp = 0.0; if (a_m <= 5.8e+200) tmp = (b - a_m) * (sin(((0.011111111111111112 * angle) * pi)) * (b + a_m)); else tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * pi); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[a$95$m, 5.8e+200], N[(N[(b - a$95$m), $MachinePrecision] * N[(N[Sin[N[(N[(0.011111111111111112 * angle), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * N[(b + a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[(N[(b - a$95$m), $MachinePrecision] * N[(N[(a$95$m + b), $MachinePrecision] * angle), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;a\_m \leq 5.8 \cdot 10^{+200}:\\
\;\;\;\;\left(b - a\_m\right) \cdot \left(\sin \left(\left(0.011111111111111112 \cdot angle\right) \cdot \pi\right) \cdot \left(b + a\_m\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(\left(b - a\_m\right) \cdot \left(\left(a\_m + b\right) \cdot angle\right)\right) \cdot \pi\right)\\
\end{array}
\end{array}
if a < 5.7999999999999998e200Initial program 53.7%
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.0%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6467.0
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6467.6
lift-+.f64N/A
+-commutativeN/A
lower-+.f6467.6
Applied rewrites67.6%
if 5.7999999999999998e200 < a Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6462.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6462.2
Applied rewrites62.2%
a_m = (fabs.f64 a)
(FPCore (a_m b angle)
:precision binary64
(if (<= angle 2.4e+51)
(* (+ a_m b) (* 0.011111111111111112 (* angle (* PI (- b a_m)))))
(if (<= angle 9.2e+118)
(* b (* b (sin (* 0.011111111111111112 (* angle PI)))))
(* angle (* (* (- b a_m) (* (+ a_m b) PI)) 0.011111111111111112)))))a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 2.4e+51) {
tmp = (a_m + b) * (0.011111111111111112 * (angle * (((double) M_PI) * (b - a_m))));
} else if (angle <= 9.2e+118) {
tmp = b * (b * sin((0.011111111111111112 * (angle * ((double) M_PI)))));
} else {
tmp = angle * (((b - a_m) * ((a_m + b) * ((double) M_PI))) * 0.011111111111111112);
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 2.4e+51) {
tmp = (a_m + b) * (0.011111111111111112 * (angle * (Math.PI * (b - a_m))));
} else if (angle <= 9.2e+118) {
tmp = b * (b * Math.sin((0.011111111111111112 * (angle * Math.PI))));
} else {
tmp = angle * (((b - a_m) * ((a_m + b) * Math.PI)) * 0.011111111111111112);
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): tmp = 0 if angle <= 2.4e+51: tmp = (a_m + b) * (0.011111111111111112 * (angle * (math.pi * (b - a_m)))) elif angle <= 9.2e+118: tmp = b * (b * math.sin((0.011111111111111112 * (angle * math.pi)))) else: tmp = angle * (((b - a_m) * ((a_m + b) * math.pi)) * 0.011111111111111112) return tmp
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (angle <= 2.4e+51) tmp = Float64(Float64(a_m + b) * Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(b - a_m))))); elseif (angle <= 9.2e+118) tmp = Float64(b * Float64(b * sin(Float64(0.011111111111111112 * Float64(angle * pi))))); else tmp = Float64(angle * Float64(Float64(Float64(b - a_m) * Float64(Float64(a_m + b) * pi)) * 0.011111111111111112)); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) tmp = 0.0; if (angle <= 2.4e+51) tmp = (a_m + b) * (0.011111111111111112 * (angle * (pi * (b - a_m)))); elseif (angle <= 9.2e+118) tmp = b * (b * sin((0.011111111111111112 * (angle * pi)))); else tmp = angle * (((b - a_m) * ((a_m + b) * pi)) * 0.011111111111111112); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[angle, 2.4e+51], N[(N[(a$95$m + b), $MachinePrecision] * N[(0.011111111111111112 * N[(angle * N[(Pi * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[angle, 9.2e+118], N[(b * N[(b * N[Sin[N[(0.011111111111111112 * N[(angle * Pi), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(angle * N[(N[(N[(b - a$95$m), $MachinePrecision] * N[(N[(a$95$m + b), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;angle \leq 2.4 \cdot 10^{+51}:\\
\;\;\;\;\left(a\_m + b\right) \cdot \left(0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(b - a\_m\right)\right)\right)\right)\\
\mathbf{elif}\;angle \leq 9.2 \cdot 10^{+118}:\\
\;\;\;\;b \cdot \left(b \cdot \sin \left(0.011111111111111112 \cdot \left(angle \cdot \pi\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;angle \cdot \left(\left(\left(b - a\_m\right) \cdot \left(\left(a\_m + b\right) \cdot \pi\right)\right) \cdot 0.011111111111111112\right)\\
\end{array}
\end{array}
if angle < 2.3999999999999999e51Initial program 53.7%
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.0%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f6462.3
Applied rewrites62.3%
if 2.3999999999999999e51 < angle < 9.20000000000000063e118Initial program 53.7%
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.0%
Taylor expanded in a around 0
Applied rewrites42.3%
Taylor expanded in a around 0
lower-*.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6441.0
Applied rewrites41.0%
if 9.20000000000000063e118 < angle Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
associate-*l*N/A
lower-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
difference-of-squares-revN/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
lift--.f64N/A
lower-*.f64N/A
Applied rewrites54.2%
a_m = (fabs.f64 a) (FPCore (a_m b angle) :precision binary64 (if (<= a_m 4.5e-84) (* (* (sin (* (* 0.011111111111111112 angle) PI)) (- b a_m)) b) (* (* (* 0.011111111111111112 (* angle (- b a_m))) (+ a_m b)) PI)))
a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (a_m <= 4.5e-84) {
tmp = (sin(((0.011111111111111112 * angle) * ((double) M_PI))) * (b - a_m)) * b;
} else {
tmp = ((0.011111111111111112 * (angle * (b - a_m))) * (a_m + b)) * ((double) M_PI);
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double tmp;
if (a_m <= 4.5e-84) {
tmp = (Math.sin(((0.011111111111111112 * angle) * Math.PI)) * (b - a_m)) * b;
} else {
tmp = ((0.011111111111111112 * (angle * (b - a_m))) * (a_m + b)) * Math.PI;
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): tmp = 0 if a_m <= 4.5e-84: tmp = (math.sin(((0.011111111111111112 * angle) * math.pi)) * (b - a_m)) * b else: tmp = ((0.011111111111111112 * (angle * (b - a_m))) * (a_m + b)) * math.pi return tmp
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (a_m <= 4.5e-84) tmp = Float64(Float64(sin(Float64(Float64(0.011111111111111112 * angle) * pi)) * Float64(b - a_m)) * b); else tmp = Float64(Float64(Float64(0.011111111111111112 * Float64(angle * Float64(b - a_m))) * Float64(a_m + b)) * pi); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) tmp = 0.0; if (a_m <= 4.5e-84) tmp = (sin(((0.011111111111111112 * angle) * pi)) * (b - a_m)) * b; else tmp = ((0.011111111111111112 * (angle * (b - a_m))) * (a_m + b)) * pi; end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[a$95$m, 4.5e-84], N[(N[(N[Sin[N[(N[(0.011111111111111112 * angle), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision], N[(N[(N[(0.011111111111111112 * N[(angle * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;a\_m \leq 4.5 \cdot 10^{-84}:\\
\;\;\;\;\left(\sin \left(\left(0.011111111111111112 \cdot angle\right) \cdot \pi\right) \cdot \left(b - a\_m\right)\right) \cdot b\\
\mathbf{else}:\\
\;\;\;\;\left(\left(0.011111111111111112 \cdot \left(angle \cdot \left(b - a\_m\right)\right)\right) \cdot \left(a\_m + b\right)\right) \cdot \pi\\
\end{array}
\end{array}
if a < 4.50000000000000016e-84Initial program 53.7%
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.0%
Taylor expanded in a around 0
Applied rewrites42.3%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6442.7
Applied rewrites42.7%
lift-*.f64N/A
*-commutativeN/A
lower-*.f6442.7
lift-*.f64N/A
*-commutativeN/A
lower-*.f6442.7
+-commutative42.7
Applied rewrites42.7%
if 4.50000000000000016e-84 < a Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
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
lower-*.f6462.3
lift-+.f64N/A
+-commutativeN/A
lower-+.f6462.3
Applied rewrites62.3%
a_m = (fabs.f64 a) (FPCore (a_m b angle) :precision binary64 (if (<= angle 3.1e-47) (* (+ a_m b) (* 0.011111111111111112 (* angle (* PI (- b a_m))))) (* 0.011111111111111112 (* (* angle (fma (- a_m) a_m (* b b))) PI))))
a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 3.1e-47) {
tmp = (a_m + b) * (0.011111111111111112 * (angle * (((double) M_PI) * (b - a_m))));
} else {
tmp = 0.011111111111111112 * ((angle * fma(-a_m, a_m, (b * b))) * ((double) M_PI));
}
return tmp;
}
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (angle <= 3.1e-47) tmp = Float64(Float64(a_m + b) * Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(b - a_m))))); else tmp = Float64(0.011111111111111112 * Float64(Float64(angle * fma(Float64(-a_m), a_m, Float64(b * b))) * pi)); end return tmp end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[angle, 3.1e-47], N[(N[(a$95$m + b), $MachinePrecision] * N[(0.011111111111111112 * N[(angle * N[(Pi * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[(angle * N[((-a$95$m) * a$95$m + N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;angle \leq 3.1 \cdot 10^{-47}:\\
\;\;\;\;\left(a\_m + b\right) \cdot \left(0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(b - a\_m\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(angle \cdot \mathsf{fma}\left(-a\_m, a\_m, b \cdot b\right)\right) \cdot \pi\right)\\
\end{array}
\end{array}
if angle < 3.0999999999999998e-47Initial program 53.7%
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.0%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f6462.3
Applied rewrites62.3%
if 3.0999999999999998e-47 < angle Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
lift-*.f64N/A
*-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
difference-of-squares-revN/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
sub-flipN/A
+-commutativeN/A
lift-pow.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
lower-fma.f64N/A
lower-neg.f6453.1
lift-pow.f64N/A
unpow2N/A
lower-*.f6453.1
Applied rewrites53.1%
a_m = (fabs.f64 a) (FPCore (a_m b angle) :precision binary64 (if (<= angle 6.3e-52) (* (+ a_m b) (* 0.011111111111111112 (* angle (* PI (- b a_m))))) (* 0.011111111111111112 (* angle (* PI (fma (- a_m) a_m (* b b)))))))
a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 6.3e-52) {
tmp = (a_m + b) * (0.011111111111111112 * (angle * (((double) M_PI) * (b - a_m))));
} else {
tmp = 0.011111111111111112 * (angle * (((double) M_PI) * fma(-a_m, a_m, (b * b))));
}
return tmp;
}
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (angle <= 6.3e-52) tmp = Float64(Float64(a_m + b) * Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(b - a_m))))); else tmp = Float64(0.011111111111111112 * Float64(angle * Float64(pi * fma(Float64(-a_m), a_m, Float64(b * b))))); end return tmp end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[angle, 6.3e-52], N[(N[(a$95$m + b), $MachinePrecision] * N[(0.011111111111111112 * N[(angle * N[(Pi * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(angle * N[(Pi * N[((-a$95$m) * a$95$m + N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;angle \leq 6.3 \cdot 10^{-52}:\\
\;\;\;\;\left(a\_m + b\right) \cdot \left(0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(b - a\_m\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \mathsf{fma}\left(-a\_m, a\_m, b \cdot b\right)\right)\right)\\
\end{array}
\end{array}
if angle < 6.3000000000000003e-52Initial program 53.7%
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.0%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f6462.3
Applied rewrites62.3%
if 6.3000000000000003e-52 < angle Initial program 53.7%
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.3
Applied rewrites50.3%
lift--.f64N/A
sub-negate-revN/A
sub-flipN/A
distribute-neg-inN/A
lift-pow.f64N/A
unpow2N/A
distribute-lft-neg-inN/A
lift-pow.f64N/A
unpow2N/A
distribute-rgt-neg-inN/A
distribute-lft-neg-outN/A
sqr-neg-revN/A
unpow2N/A
lift-pow.f64N/A
lower-fma.f64N/A
lower-neg.f6453.1
lift-pow.f64N/A
unpow2N/A
lower-*.f6453.1
Applied rewrites53.1%
a_m = (fabs.f64 a) (FPCore (a_m b angle) :precision binary64 (if (<= angle 3.4e-43) (* (+ a_m b) (* 0.011111111111111112 (* angle (* PI (- b a_m))))) (* (* (* 0.011111111111111112 angle) PI) (* (- b a_m) (+ b a_m)))))
a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 3.4e-43) {
tmp = (a_m + b) * (0.011111111111111112 * (angle * (((double) M_PI) * (b - a_m))));
} else {
tmp = ((0.011111111111111112 * angle) * ((double) M_PI)) * ((b - a_m) * (b + a_m));
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 3.4e-43) {
tmp = (a_m + b) * (0.011111111111111112 * (angle * (Math.PI * (b - a_m))));
} else {
tmp = ((0.011111111111111112 * angle) * Math.PI) * ((b - a_m) * (b + a_m));
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): tmp = 0 if angle <= 3.4e-43: tmp = (a_m + b) * (0.011111111111111112 * (angle * (math.pi * (b - a_m)))) else: tmp = ((0.011111111111111112 * angle) * math.pi) * ((b - a_m) * (b + a_m)) return tmp
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (angle <= 3.4e-43) tmp = Float64(Float64(a_m + b) * Float64(0.011111111111111112 * Float64(angle * Float64(pi * Float64(b - a_m))))); else tmp = Float64(Float64(Float64(0.011111111111111112 * angle) * pi) * Float64(Float64(b - a_m) * Float64(b + a_m))); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) tmp = 0.0; if (angle <= 3.4e-43) tmp = (a_m + b) * (0.011111111111111112 * (angle * (pi * (b - a_m)))); else tmp = ((0.011111111111111112 * angle) * pi) * ((b - a_m) * (b + a_m)); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[angle, 3.4e-43], N[(N[(a$95$m + b), $MachinePrecision] * N[(0.011111111111111112 * N[(angle * N[(Pi * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(0.011111111111111112 * angle), $MachinePrecision] * Pi), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(b + a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;angle \leq 3.4 \cdot 10^{-43}:\\
\;\;\;\;\left(a\_m + b\right) \cdot \left(0.011111111111111112 \cdot \left(angle \cdot \left(\pi \cdot \left(b - a\_m\right)\right)\right)\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(0.011111111111111112 \cdot angle\right) \cdot \pi\right) \cdot \left(\left(b - a\_m\right) \cdot \left(b + a\_m\right)\right)\\
\end{array}
\end{array}
if angle < 3.4000000000000001e-43Initial program 53.7%
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.0%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
lower--.f6462.3
Applied rewrites62.3%
if 3.4000000000000001e-43 < angle Initial program 53.7%
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.3
Applied rewrites50.3%
Applied rewrites54.2%
a_m = (fabs.f64 a) (FPCore (a_m b angle) :precision binary64 (if (<= angle 2e-64) (* (* (* 0.011111111111111112 (* angle (- b a_m))) (+ a_m b)) PI) (* (* (* 0.011111111111111112 angle) PI) (* (- b a_m) (+ b a_m)))))
a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 2e-64) {
tmp = ((0.011111111111111112 * (angle * (b - a_m))) * (a_m + b)) * ((double) M_PI);
} else {
tmp = ((0.011111111111111112 * angle) * ((double) M_PI)) * ((b - a_m) * (b + a_m));
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 2e-64) {
tmp = ((0.011111111111111112 * (angle * (b - a_m))) * (a_m + b)) * Math.PI;
} else {
tmp = ((0.011111111111111112 * angle) * Math.PI) * ((b - a_m) * (b + a_m));
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): tmp = 0 if angle <= 2e-64: tmp = ((0.011111111111111112 * (angle * (b - a_m))) * (a_m + b)) * math.pi else: tmp = ((0.011111111111111112 * angle) * math.pi) * ((b - a_m) * (b + a_m)) return tmp
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (angle <= 2e-64) tmp = Float64(Float64(Float64(0.011111111111111112 * Float64(angle * Float64(b - a_m))) * Float64(a_m + b)) * pi); else tmp = Float64(Float64(Float64(0.011111111111111112 * angle) * pi) * Float64(Float64(b - a_m) * Float64(b + a_m))); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) tmp = 0.0; if (angle <= 2e-64) tmp = ((0.011111111111111112 * (angle * (b - a_m))) * (a_m + b)) * pi; else tmp = ((0.011111111111111112 * angle) * pi) * ((b - a_m) * (b + a_m)); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[angle, 2e-64], N[(N[(N[(0.011111111111111112 * N[(angle * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(a$95$m + b), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision], N[(N[(N[(0.011111111111111112 * angle), $MachinePrecision] * Pi), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(b + a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;angle \leq 2 \cdot 10^{-64}:\\
\;\;\;\;\left(\left(0.011111111111111112 \cdot \left(angle \cdot \left(b - a\_m\right)\right)\right) \cdot \left(a\_m + b\right)\right) \cdot \pi\\
\mathbf{else}:\\
\;\;\;\;\left(\left(0.011111111111111112 \cdot angle\right) \cdot \pi\right) \cdot \left(\left(b - a\_m\right) \cdot \left(b + a\_m\right)\right)\\
\end{array}
\end{array}
if angle < 1.99999999999999993e-64Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
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
lower-*.f6462.3
lift-+.f64N/A
+-commutativeN/A
lower-+.f6462.3
Applied rewrites62.3%
if 1.99999999999999993e-64 < angle Initial program 53.7%
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.3
Applied rewrites50.3%
Applied rewrites54.2%
a_m = (fabs.f64 a) (FPCore (a_m b angle) :precision binary64 (if (<= angle 3.4e-43) (* 0.011111111111111112 (* (* (- b a_m) (* (+ a_m b) angle)) PI)) (* (* (* 0.011111111111111112 angle) PI) (* (- b a_m) (+ b a_m)))))
a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 3.4e-43) {
tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * ((double) M_PI));
} else {
tmp = ((0.011111111111111112 * angle) * ((double) M_PI)) * ((b - a_m) * (b + a_m));
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 3.4e-43) {
tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * Math.PI);
} else {
tmp = ((0.011111111111111112 * angle) * Math.PI) * ((b - a_m) * (b + a_m));
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): tmp = 0 if angle <= 3.4e-43: tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * math.pi) else: tmp = ((0.011111111111111112 * angle) * math.pi) * ((b - a_m) * (b + a_m)) return tmp
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (angle <= 3.4e-43) tmp = Float64(0.011111111111111112 * Float64(Float64(Float64(b - a_m) * Float64(Float64(a_m + b) * angle)) * pi)); else tmp = Float64(Float64(Float64(0.011111111111111112 * angle) * pi) * Float64(Float64(b - a_m) * Float64(b + a_m))); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) tmp = 0.0; if (angle <= 3.4e-43) tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * pi); else tmp = ((0.011111111111111112 * angle) * pi) * ((b - a_m) * (b + a_m)); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[angle, 3.4e-43], N[(0.011111111111111112 * N[(N[(N[(b - a$95$m), $MachinePrecision] * N[(N[(a$95$m + b), $MachinePrecision] * angle), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[(0.011111111111111112 * angle), $MachinePrecision] * Pi), $MachinePrecision] * N[(N[(b - a$95$m), $MachinePrecision] * N[(b + a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;angle \leq 3.4 \cdot 10^{-43}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(\left(b - a\_m\right) \cdot \left(\left(a\_m + b\right) \cdot angle\right)\right) \cdot \pi\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(0.011111111111111112 \cdot angle\right) \cdot \pi\right) \cdot \left(\left(b - a\_m\right) \cdot \left(b + a\_m\right)\right)\\
\end{array}
\end{array}
if angle < 3.4000000000000001e-43Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6462.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6462.2
Applied rewrites62.2%
if 3.4000000000000001e-43 < angle Initial program 53.7%
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.3
Applied rewrites50.3%
Applied rewrites54.2%
a_m = (fabs.f64 a) (FPCore (a_m b angle) :precision binary64 (if (<= angle 3e-47) (* 0.011111111111111112 (* (* (- b a_m) (* (+ a_m b) angle)) PI)) (* 0.011111111111111112 (* (* angle (* (- b a_m) (+ b a_m))) PI))))
a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 3e-47) {
tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * ((double) M_PI));
} else {
tmp = 0.011111111111111112 * ((angle * ((b - a_m) * (b + a_m))) * ((double) M_PI));
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double tmp;
if (angle <= 3e-47) {
tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * Math.PI);
} else {
tmp = 0.011111111111111112 * ((angle * ((b - a_m) * (b + a_m))) * Math.PI);
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): tmp = 0 if angle <= 3e-47: tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * math.pi) else: tmp = 0.011111111111111112 * ((angle * ((b - a_m) * (b + a_m))) * math.pi) return tmp
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (angle <= 3e-47) tmp = Float64(0.011111111111111112 * Float64(Float64(Float64(b - a_m) * Float64(Float64(a_m + b) * angle)) * pi)); else tmp = Float64(0.011111111111111112 * Float64(Float64(angle * Float64(Float64(b - a_m) * Float64(b + a_m))) * pi)); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) tmp = 0.0; if (angle <= 3e-47) tmp = 0.011111111111111112 * (((b - a_m) * ((a_m + b) * angle)) * pi); else tmp = 0.011111111111111112 * ((angle * ((b - a_m) * (b + a_m))) * pi); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[angle, 3e-47], N[(0.011111111111111112 * N[(N[(N[(b - a$95$m), $MachinePrecision] * N[(N[(a$95$m + b), $MachinePrecision] * angle), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision], N[(0.011111111111111112 * N[(N[(angle * N[(N[(b - a$95$m), $MachinePrecision] * N[(b + a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;angle \leq 3 \cdot 10^{-47}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(\left(b - a\_m\right) \cdot \left(\left(a\_m + b\right) \cdot angle\right)\right) \cdot \pi\right)\\
\mathbf{else}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(angle \cdot \left(\left(b - a\_m\right) \cdot \left(b + a\_m\right)\right)\right) \cdot \pi\right)\\
\end{array}
\end{array}
if angle < 3.00000000000000017e-47Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f6462.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6462.2
Applied rewrites62.2%
if 3.00000000000000017e-47 < angle Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
a_m = (fabs.f64 a)
(FPCore (a_m b angle)
:precision binary64
(let* ((t_0 (* 2.0 (- (pow b 2.0) (pow a_m 2.0)))))
(if (<= t_0 -2e+162)
(* -2.0 (* (* 0.005555555555555556 (* a_m (* angle PI))) a_m))
(if (<= t_0 5e+118)
(* 0.011111111111111112 (* (* angle (* (- b a_m) (+ b a_m))) PI))
(* (* (* 0.011111111111111112 (* angle (- b a_m))) b) PI)))))a_m = fabs(a);
double code(double a_m, double b, double angle) {
double t_0 = 2.0 * (pow(b, 2.0) - pow(a_m, 2.0));
double tmp;
if (t_0 <= -2e+162) {
tmp = -2.0 * ((0.005555555555555556 * (a_m * (angle * ((double) M_PI)))) * a_m);
} else if (t_0 <= 5e+118) {
tmp = 0.011111111111111112 * ((angle * ((b - a_m) * (b + a_m))) * ((double) M_PI));
} else {
tmp = ((0.011111111111111112 * (angle * (b - a_m))) * b) * ((double) M_PI);
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double t_0 = 2.0 * (Math.pow(b, 2.0) - Math.pow(a_m, 2.0));
double tmp;
if (t_0 <= -2e+162) {
tmp = -2.0 * ((0.005555555555555556 * (a_m * (angle * Math.PI))) * a_m);
} else if (t_0 <= 5e+118) {
tmp = 0.011111111111111112 * ((angle * ((b - a_m) * (b + a_m))) * Math.PI);
} else {
tmp = ((0.011111111111111112 * (angle * (b - a_m))) * b) * Math.PI;
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): t_0 = 2.0 * (math.pow(b, 2.0) - math.pow(a_m, 2.0)) tmp = 0 if t_0 <= -2e+162: tmp = -2.0 * ((0.005555555555555556 * (a_m * (angle * math.pi))) * a_m) elif t_0 <= 5e+118: tmp = 0.011111111111111112 * ((angle * ((b - a_m) * (b + a_m))) * math.pi) else: tmp = ((0.011111111111111112 * (angle * (b - a_m))) * b) * math.pi return tmp
a_m = abs(a) function code(a_m, b, angle) t_0 = Float64(2.0 * Float64((b ^ 2.0) - (a_m ^ 2.0))) tmp = 0.0 if (t_0 <= -2e+162) tmp = Float64(-2.0 * Float64(Float64(0.005555555555555556 * Float64(a_m * Float64(angle * pi))) * a_m)); elseif (t_0 <= 5e+118) tmp = Float64(0.011111111111111112 * Float64(Float64(angle * Float64(Float64(b - a_m) * Float64(b + a_m))) * pi)); else tmp = Float64(Float64(Float64(0.011111111111111112 * Float64(angle * Float64(b - a_m))) * b) * pi); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) t_0 = 2.0 * ((b ^ 2.0) - (a_m ^ 2.0)); tmp = 0.0; if (t_0 <= -2e+162) tmp = -2.0 * ((0.005555555555555556 * (a_m * (angle * pi))) * a_m); elseif (t_0 <= 5e+118) tmp = 0.011111111111111112 * ((angle * ((b - a_m) * (b + a_m))) * pi); else tmp = ((0.011111111111111112 * (angle * (b - a_m))) * b) * pi; end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision]
code[a$95$m_, b_, angle_] := Block[{t$95$0 = N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -2e+162], N[(-2.0 * N[(N[(0.005555555555555556 * N[(a$95$m * N[(angle * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * a$95$m), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$0, 5e+118], N[(0.011111111111111112 * N[(N[(angle * N[(N[(b - a$95$m), $MachinePrecision] * N[(b + a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[(0.011111111111111112 * N[(angle * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] * Pi), $MachinePrecision]]]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
t_0 := 2 \cdot \left({b}^{2} - {a\_m}^{2}\right)\\
\mathbf{if}\;t\_0 \leq -2 \cdot 10^{+162}:\\
\;\;\;\;-2 \cdot \left(\left(0.005555555555555556 \cdot \left(a\_m \cdot \left(angle \cdot \pi\right)\right)\right) \cdot a\_m\right)\\
\mathbf{elif}\;t\_0 \leq 5 \cdot 10^{+118}:\\
\;\;\;\;0.011111111111111112 \cdot \left(\left(angle \cdot \left(\left(b - a\_m\right) \cdot \left(b + a\_m\right)\right)\right) \cdot \pi\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(0.011111111111111112 \cdot \left(angle \cdot \left(b - a\_m\right)\right)\right) \cdot b\right) \cdot \pi\\
\end{array}
\end{array}
if (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) < -1.9999999999999999e162Initial program 53.7%
lift-cos.f64N/A
cos-fabs-revN/A
cos-neg-revN/A
sin-+PI/2-revN/A
lower-sin.f64N/A
lower-+.f64N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
fabs-divN/A
metadata-evalN/A
distribute-neg-frac2N/A
lower-/.f64N/A
lower-fabs.f64N/A
*-commutativeN/A
lower-*.f64N/A
metadata-evalN/A
lift-PI.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval53.0
Applied rewrites53.0%
Taylor expanded in a around inf
lower-*.f64N/A
lower-*.f64N/A
lower-pow.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
Applied rewrites34.4%
Applied rewrites39.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6437.2
Applied rewrites37.2%
if -1.9999999999999999e162 < (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) < 4.99999999999999972e118Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
if 4.99999999999999972e118 < (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
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
+-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6441.8
+-commutative41.8
Applied rewrites41.8%
a_m = (fabs.f64 a) (FPCore (a_m b angle) :precision binary64 (if (<= (* 2.0 (- (pow b 2.0) (pow a_m 2.0))) 1e-288) (* -2.0 (* (* 0.005555555555555556 (* a_m (* angle PI))) a_m)) (* (* (* angle b) (- b a_m)) (* PI 0.011111111111111112))))
a_m = fabs(a);
double code(double a_m, double b, double angle) {
double tmp;
if ((2.0 * (pow(b, 2.0) - pow(a_m, 2.0))) <= 1e-288) {
tmp = -2.0 * ((0.005555555555555556 * (a_m * (angle * ((double) M_PI)))) * a_m);
} else {
tmp = ((angle * b) * (b - a_m)) * (((double) M_PI) * 0.011111111111111112);
}
return tmp;
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
double tmp;
if ((2.0 * (Math.pow(b, 2.0) - Math.pow(a_m, 2.0))) <= 1e-288) {
tmp = -2.0 * ((0.005555555555555556 * (a_m * (angle * Math.PI))) * a_m);
} else {
tmp = ((angle * b) * (b - a_m)) * (Math.PI * 0.011111111111111112);
}
return tmp;
}
a_m = math.fabs(a) def code(a_m, b, angle): tmp = 0 if (2.0 * (math.pow(b, 2.0) - math.pow(a_m, 2.0))) <= 1e-288: tmp = -2.0 * ((0.005555555555555556 * (a_m * (angle * math.pi))) * a_m) else: tmp = ((angle * b) * (b - a_m)) * (math.pi * 0.011111111111111112) return tmp
a_m = abs(a) function code(a_m, b, angle) tmp = 0.0 if (Float64(2.0 * Float64((b ^ 2.0) - (a_m ^ 2.0))) <= 1e-288) tmp = Float64(-2.0 * Float64(Float64(0.005555555555555556 * Float64(a_m * Float64(angle * pi))) * a_m)); else tmp = Float64(Float64(Float64(angle * b) * Float64(b - a_m)) * Float64(pi * 0.011111111111111112)); end return tmp end
a_m = abs(a); function tmp_2 = code(a_m, b, angle) tmp = 0.0; if ((2.0 * ((b ^ 2.0) - (a_m ^ 2.0))) <= 1e-288) tmp = -2.0 * ((0.005555555555555556 * (a_m * (angle * pi))) * a_m); else tmp = ((angle * b) * (b - a_m)) * (pi * 0.011111111111111112); end tmp_2 = tmp; end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := If[LessEqual[N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1e-288], N[(-2.0 * N[(N[(0.005555555555555556 * N[(a$95$m * N[(angle * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * a$95$m), $MachinePrecision]), $MachinePrecision], N[(N[(N[(angle * b), $MachinePrecision] * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(Pi * 0.011111111111111112), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
a_m = \left|a\right|
\\
\begin{array}{l}
\mathbf{if}\;2 \cdot \left({b}^{2} - {a\_m}^{2}\right) \leq 10^{-288}:\\
\;\;\;\;-2 \cdot \left(\left(0.005555555555555556 \cdot \left(a\_m \cdot \left(angle \cdot \pi\right)\right)\right) \cdot a\_m\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(angle \cdot b\right) \cdot \left(b - a\_m\right)\right) \cdot \left(\pi \cdot 0.011111111111111112\right)\\
\end{array}
\end{array}
if (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) < 1.00000000000000006e-288Initial program 53.7%
lift-cos.f64N/A
cos-fabs-revN/A
cos-neg-revN/A
sin-+PI/2-revN/A
lower-sin.f64N/A
lower-+.f64N/A
lift-*.f64N/A
lift-/.f64N/A
associate-*r/N/A
fabs-divN/A
metadata-evalN/A
distribute-neg-frac2N/A
lower-/.f64N/A
lower-fabs.f64N/A
*-commutativeN/A
lower-*.f64N/A
metadata-evalN/A
lift-PI.f64N/A
mult-flipN/A
*-commutativeN/A
lower-*.f64N/A
metadata-eval53.0
Applied rewrites53.0%
Taylor expanded in a around inf
lower-*.f64N/A
lower-*.f64N/A
lower-pow.f64N/A
lower-*.f64N/A
lower-sin.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
Applied rewrites34.4%
Applied rewrites39.8%
Taylor expanded in angle around 0
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f6437.2
Applied rewrites37.2%
if 1.00000000000000006e-288 < (*.f64 #s(literal 2 binary64) (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64)))) Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
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
+-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
+-commutativeN/A
+-commutativeN/A
Applied rewrites40.6%
a_m = (fabs.f64 a) (FPCore (a_m b angle) :precision binary64 (* (* (* 0.011111111111111112 (* angle (- b a_m))) b) PI))
a_m = fabs(a);
double code(double a_m, double b, double angle) {
return ((0.011111111111111112 * (angle * (b - a_m))) * b) * ((double) M_PI);
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
return ((0.011111111111111112 * (angle * (b - a_m))) * b) * Math.PI;
}
a_m = math.fabs(a) def code(a_m, b, angle): return ((0.011111111111111112 * (angle * (b - a_m))) * b) * math.pi
a_m = abs(a) function code(a_m, b, angle) return Float64(Float64(Float64(0.011111111111111112 * Float64(angle * Float64(b - a_m))) * b) * pi) end
a_m = abs(a); function tmp = code(a_m, b, angle) tmp = ((0.011111111111111112 * (angle * (b - a_m))) * b) * pi; end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := N[(N[(N[(0.011111111111111112 * N[(angle * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * b), $MachinePrecision] * Pi), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
\left(\left(0.011111111111111112 \cdot \left(angle \cdot \left(b - a\_m\right)\right)\right) \cdot b\right) \cdot \pi
\end{array}
Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
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
+-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6441.8
+-commutative41.8
Applied rewrites41.8%
a_m = (fabs.f64 a) (FPCore (a_m b angle) :precision binary64 (* 0.011111111111111112 (* (* angle (- b a_m)) (* b PI))))
a_m = fabs(a);
double code(double a_m, double b, double angle) {
return 0.011111111111111112 * ((angle * (b - a_m)) * (b * ((double) M_PI)));
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
return 0.011111111111111112 * ((angle * (b - a_m)) * (b * Math.PI));
}
a_m = math.fabs(a) def code(a_m, b, angle): return 0.011111111111111112 * ((angle * (b - a_m)) * (b * math.pi))
a_m = abs(a) function code(a_m, b, angle) return Float64(0.011111111111111112 * Float64(Float64(angle * Float64(b - a_m)) * Float64(b * pi))) end
a_m = abs(a); function tmp = code(a_m, b, angle) tmp = 0.011111111111111112 * ((angle * (b - a_m)) * (b * pi)); end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := N[(0.011111111111111112 * N[(N[(angle * N[(b - a$95$m), $MachinePrecision]), $MachinePrecision] * N[(b * Pi), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
0.011111111111111112 \cdot \left(\left(angle \cdot \left(b - a\_m\right)\right) \cdot \left(b \cdot \pi\right)\right)
\end{array}
Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
Taylor expanded in a around 0
Applied rewrites38.0%
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
+-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6441.8
+-commutative41.8
Applied rewrites41.8%
a_m = (fabs.f64 a) (FPCore (a_m b angle) :precision binary64 (* 0.011111111111111112 (* (* angle (* (- b a_m) b)) PI)))
a_m = fabs(a);
double code(double a_m, double b, double angle) {
return 0.011111111111111112 * ((angle * ((b - a_m) * b)) * ((double) M_PI));
}
a_m = Math.abs(a);
public static double code(double a_m, double b, double angle) {
return 0.011111111111111112 * ((angle * ((b - a_m) * b)) * Math.PI);
}
a_m = math.fabs(a) def code(a_m, b, angle): return 0.011111111111111112 * ((angle * ((b - a_m) * b)) * math.pi)
a_m = abs(a) function code(a_m, b, angle) return Float64(0.011111111111111112 * Float64(Float64(angle * Float64(Float64(b - a_m) * b)) * pi)) end
a_m = abs(a); function tmp = code(a_m, b, angle) tmp = 0.011111111111111112 * ((angle * ((b - a_m) * b)) * pi); end
a_m = N[Abs[a], $MachinePrecision] code[a$95$m_, b_, angle_] := N[(0.011111111111111112 * N[(N[(angle * N[(N[(b - a$95$m), $MachinePrecision] * b), $MachinePrecision]), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
a_m = \left|a\right|
\\
0.011111111111111112 \cdot \left(\left(angle \cdot \left(\left(b - a\_m\right) \cdot b\right)\right) \cdot \pi\right)
\end{array}
Initial program 53.7%
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.3
Applied rewrites50.3%
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6450.3
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squares-revN/A
+-commutativeN/A
lift-+.f64N/A
lift--.f64N/A
*-commutativeN/A
lower-*.f6454.2
lift-+.f64N/A
+-commutativeN/A
lower-+.f6454.2
Applied rewrites54.2%
Taylor expanded in a around 0
Applied rewrites38.0%
herbie shell --seed 2025156
(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)))))