
(FPCore (a b angle) :precision binary64 (let* ((t_0 (* PI (/ angle 180.0)))) (* (* (* 2.0 (- (pow b 2.0) (pow a 2.0))) (sin t_0)) (cos t_0))))
double code(double a, double b, double angle) {
double t_0 = ((double) M_PI) * (angle / 180.0);
return ((2.0 * (pow(b, 2.0) - pow(a, 2.0))) * sin(t_0)) * cos(t_0);
}
public static double code(double a, double b, double angle) {
double t_0 = Math.PI * (angle / 180.0);
return ((2.0 * (Math.pow(b, 2.0) - Math.pow(a, 2.0))) * Math.sin(t_0)) * Math.cos(t_0);
}
def code(a, b, angle): t_0 = math.pi * (angle / 180.0) return ((2.0 * (math.pow(b, 2.0) - math.pow(a, 2.0))) * math.sin(t_0)) * math.cos(t_0)
function code(a, b, angle) t_0 = Float64(pi * Float64(angle / 180.0)) return Float64(Float64(Float64(2.0 * Float64((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0)) end
function tmp = code(a, b, angle) t_0 = pi * (angle / 180.0); tmp = ((2.0 * ((b ^ 2.0) - (a ^ 2.0))) * sin(t_0)) * cos(t_0); end
code[a_, b_, angle_] := Block[{t$95$0 = N[(Pi * N[(angle / 180.0), $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(2.0 * N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sin[t$95$0], $MachinePrecision]), $MachinePrecision] * N[Cos[t$95$0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \pi \cdot \frac{angle}{180}\\
\left(\left(2 \cdot \left({b}^{2} - {a}^{2}\right)\right) \cdot \sin t\_0\right) \cdot \cos t\_0
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 19 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}
(FPCore (a b angle)
:precision binary64
(let* ((t_0
(*
(* (* (sin (* PI (* angle 0.005555555555555556))) 2.0) (- b a))
(+ a b))))
(if (<= (pow b 2.0) 1e+103)
(* (cos (/ PI (/ 180.0 angle))) t_0)
(* 1.0 t_0))))
double code(double a, double b, double angle) {
double t_0 = ((sin((((double) M_PI) * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b);
double tmp;
if (pow(b, 2.0) <= 1e+103) {
tmp = cos((((double) M_PI) / (180.0 / angle))) * t_0;
} else {
tmp = 1.0 * t_0;
}
return tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = ((Math.sin((Math.PI * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b);
double tmp;
if (Math.pow(b, 2.0) <= 1e+103) {
tmp = Math.cos((Math.PI / (180.0 / angle))) * t_0;
} else {
tmp = 1.0 * t_0;
}
return tmp;
}
def code(a, b, angle): t_0 = ((math.sin((math.pi * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b) tmp = 0 if math.pow(b, 2.0) <= 1e+103: tmp = math.cos((math.pi / (180.0 / angle))) * t_0 else: tmp = 1.0 * t_0 return tmp
function code(a, b, angle) t_0 = Float64(Float64(Float64(sin(Float64(pi * Float64(angle * 0.005555555555555556))) * 2.0) * Float64(b - a)) * Float64(a + b)) tmp = 0.0 if ((b ^ 2.0) <= 1e+103) tmp = Float64(cos(Float64(pi / Float64(180.0 / angle))) * t_0); else tmp = Float64(1.0 * t_0); end return tmp end
function tmp_2 = code(a, b, angle) t_0 = ((sin((pi * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b); tmp = 0.0; if ((b ^ 2.0) <= 1e+103) tmp = cos((pi / (180.0 / angle))) * t_0; else tmp = 1.0 * t_0; end tmp_2 = tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[(N[(N[Sin[N[(Pi * N[(angle * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Power[b, 2.0], $MachinePrecision], 1e+103], N[(N[Cos[N[(Pi / N[(180.0 / angle), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * t$95$0), $MachinePrecision], N[(1.0 * t$95$0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\left(\sin \left(\pi \cdot \left(angle \cdot 0.005555555555555556\right)\right) \cdot 2\right) \cdot \left(b - a\right)\right) \cdot \left(a + b\right)\\
\mathbf{if}\;{b}^{2} \leq 10^{+103}:\\
\;\;\;\;\cos \left(\frac{\pi}{\frac{180}{angle}}\right) \cdot t\_0\\
\mathbf{else}:\\
\;\;\;\;1 \cdot t\_0\\
\end{array}
\end{array}
if (pow.f64 b #s(literal 2 binary64)) < 1e103Initial program 60.3%
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-*.f6466.1
Applied rewrites66.1%
lift-*.f64N/A
lift-/.f64N/A
clear-numN/A
un-div-invN/A
lower-/.f64N/A
lower-/.f6467.8
Applied rewrites67.8%
if 1e103 < (pow.f64 b #s(literal 2 binary64)) Initial program 45.1%
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-*.f6469.3
Applied rewrites68.4%
Taylor expanded in angle around 0
Applied rewrites80.2%
Final simplification73.2%
(FPCore (a b angle)
:precision binary64
(let* ((t_0
(*
(* (* (sin (* PI (* angle 0.005555555555555556))) 2.0) (- b a))
(+ a b))))
(if (<= (pow b 2.0) 1e+197)
(* (cos (* (* PI 0.005555555555555556) angle)) t_0)
(* 1.0 t_0))))
double code(double a, double b, double angle) {
double t_0 = ((sin((((double) M_PI) * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b);
double tmp;
if (pow(b, 2.0) <= 1e+197) {
tmp = cos(((((double) M_PI) * 0.005555555555555556) * angle)) * t_0;
} else {
tmp = 1.0 * t_0;
}
return tmp;
}
public static double code(double a, double b, double angle) {
double t_0 = ((Math.sin((Math.PI * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b);
double tmp;
if (Math.pow(b, 2.0) <= 1e+197) {
tmp = Math.cos(((Math.PI * 0.005555555555555556) * angle)) * t_0;
} else {
tmp = 1.0 * t_0;
}
return tmp;
}
def code(a, b, angle): t_0 = ((math.sin((math.pi * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b) tmp = 0 if math.pow(b, 2.0) <= 1e+197: tmp = math.cos(((math.pi * 0.005555555555555556) * angle)) * t_0 else: tmp = 1.0 * t_0 return tmp
function code(a, b, angle) t_0 = Float64(Float64(Float64(sin(Float64(pi * Float64(angle * 0.005555555555555556))) * 2.0) * Float64(b - a)) * Float64(a + b)) tmp = 0.0 if ((b ^ 2.0) <= 1e+197) tmp = Float64(cos(Float64(Float64(pi * 0.005555555555555556) * angle)) * t_0); else tmp = Float64(1.0 * t_0); end return tmp end
function tmp_2 = code(a, b, angle) t_0 = ((sin((pi * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b); tmp = 0.0; if ((b ^ 2.0) <= 1e+197) tmp = cos(((pi * 0.005555555555555556) * angle)) * t_0; else tmp = 1.0 * t_0; end tmp_2 = tmp; end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[(N[(N[Sin[N[(Pi * N[(angle * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Power[b, 2.0], $MachinePrecision], 1e+197], N[(N[Cos[N[(N[(Pi * 0.005555555555555556), $MachinePrecision] * angle), $MachinePrecision]], $MachinePrecision] * t$95$0), $MachinePrecision], N[(1.0 * t$95$0), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\left(\sin \left(\pi \cdot \left(angle \cdot 0.005555555555555556\right)\right) \cdot 2\right) \cdot \left(b - a\right)\right) \cdot \left(a + b\right)\\
\mathbf{if}\;{b}^{2} \leq 10^{+197}:\\
\;\;\;\;\cos \left(\left(\pi \cdot 0.005555555555555556\right) \cdot angle\right) \cdot t\_0\\
\mathbf{else}:\\
\;\;\;\;1 \cdot t\_0\\
\end{array}
\end{array}
if (pow.f64 b #s(literal 2 binary64)) < 9.9999999999999995e196Initial program 60.4%
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-*.f6465.5
Applied rewrites65.4%
lift-*.f64N/A
lift-/.f64N/A
div-invN/A
metadata-evalN/A
*-commutativeN/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6467.4
Applied rewrites67.4%
if 9.9999999999999995e196 < (pow.f64 b #s(literal 2 binary64)) Initial program 41.9%
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-*.f6471.1
Applied rewrites70.0%
Taylor expanded in angle around 0
Applied rewrites83.4%
Final simplification73.2%
(FPCore (a b angle)
:precision binary64
(if (<= (pow b 2.0) 1e-127)
(*
(* (* 0.5 (sin (* (* 0.011111111111111112 angle) PI))) (* (- b a) 2.0))
(+ a b))
(*
1.0
(*
(* (* (sin (* PI (* angle 0.005555555555555556))) 2.0) (- b a))
(+ a b)))))
double code(double a, double b, double angle) {
double tmp;
if (pow(b, 2.0) <= 1e-127) {
tmp = ((0.5 * sin(((0.011111111111111112 * angle) * ((double) M_PI)))) * ((b - a) * 2.0)) * (a + b);
} else {
tmp = 1.0 * (((sin((((double) M_PI) * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b));
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (Math.pow(b, 2.0) <= 1e-127) {
tmp = ((0.5 * Math.sin(((0.011111111111111112 * angle) * Math.PI))) * ((b - a) * 2.0)) * (a + b);
} else {
tmp = 1.0 * (((Math.sin((Math.PI * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b));
}
return tmp;
}
def code(a, b, angle): tmp = 0 if math.pow(b, 2.0) <= 1e-127: tmp = ((0.5 * math.sin(((0.011111111111111112 * angle) * math.pi))) * ((b - a) * 2.0)) * (a + b) else: tmp = 1.0 * (((math.sin((math.pi * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b)) return tmp
function code(a, b, angle) tmp = 0.0 if ((b ^ 2.0) <= 1e-127) tmp = Float64(Float64(Float64(0.5 * sin(Float64(Float64(0.011111111111111112 * angle) * pi))) * Float64(Float64(b - a) * 2.0)) * Float64(a + b)); else tmp = Float64(1.0 * Float64(Float64(Float64(sin(Float64(pi * Float64(angle * 0.005555555555555556))) * 2.0) * Float64(b - a)) * Float64(a + b))); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if ((b ^ 2.0) <= 1e-127) tmp = ((0.5 * sin(((0.011111111111111112 * angle) * pi))) * ((b - a) * 2.0)) * (a + b); else tmp = 1.0 * (((sin((pi * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b)); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[N[Power[b, 2.0], $MachinePrecision], 1e-127], N[(N[(N[(0.5 * N[Sin[N[(N[(0.011111111111111112 * angle), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(b - a), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision], N[(1.0 * N[(N[(N[(N[Sin[N[(Pi * N[(angle * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;{b}^{2} \leq 10^{-127}:\\
\;\;\;\;\left(\left(0.5 \cdot \sin \left(\left(0.011111111111111112 \cdot angle\right) \cdot \pi\right)\right) \cdot \left(\left(b - a\right) \cdot 2\right)\right) \cdot \left(a + b\right)\\
\mathbf{else}:\\
\;\;\;\;1 \cdot \left(\left(\left(\sin \left(\pi \cdot \left(angle \cdot 0.005555555555555556\right)\right) \cdot 2\right) \cdot \left(b - a\right)\right) \cdot \left(a + b\right)\right)\\
\end{array}
\end{array}
if (pow.f64 b #s(literal 2 binary64)) < 1e-127Initial program 60.0%
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.0%
Applied rewrites20.5%
Applied rewrites67.0%
if 1e-127 < (pow.f64 b #s(literal 2 binary64)) Initial program 49.6%
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.7
Applied rewrites67.1%
Taylor expanded in angle around 0
Applied rewrites75.8%
Final simplification72.3%
(FPCore (a b angle)
:precision binary64
(if (<= (pow b 2.0) 2e-150)
(* (* (sin (* (* PI angle) 0.011111111111111112)) (- b a)) (+ a b))
(*
1.0
(*
(* (* (sin (* PI (* angle 0.005555555555555556))) 2.0) (- b a))
(+ a b)))))
double code(double a, double b, double angle) {
double tmp;
if (pow(b, 2.0) <= 2e-150) {
tmp = (sin(((((double) M_PI) * angle) * 0.011111111111111112)) * (b - a)) * (a + b);
} else {
tmp = 1.0 * (((sin((((double) M_PI) * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b));
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (Math.pow(b, 2.0) <= 2e-150) {
tmp = (Math.sin(((Math.PI * angle) * 0.011111111111111112)) * (b - a)) * (a + b);
} else {
tmp = 1.0 * (((Math.sin((Math.PI * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b));
}
return tmp;
}
def code(a, b, angle): tmp = 0 if math.pow(b, 2.0) <= 2e-150: tmp = (math.sin(((math.pi * angle) * 0.011111111111111112)) * (b - a)) * (a + b) else: tmp = 1.0 * (((math.sin((math.pi * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b)) return tmp
function code(a, b, angle) tmp = 0.0 if ((b ^ 2.0) <= 2e-150) tmp = Float64(Float64(sin(Float64(Float64(pi * angle) * 0.011111111111111112)) * Float64(b - a)) * Float64(a + b)); else tmp = Float64(1.0 * Float64(Float64(Float64(sin(Float64(pi * Float64(angle * 0.005555555555555556))) * 2.0) * Float64(b - a)) * Float64(a + b))); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if ((b ^ 2.0) <= 2e-150) tmp = (sin(((pi * angle) * 0.011111111111111112)) * (b - a)) * (a + b); else tmp = 1.0 * (((sin((pi * (angle * 0.005555555555555556))) * 2.0) * (b - a)) * (a + b)); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[N[Power[b, 2.0], $MachinePrecision], 2e-150], N[(N[(N[Sin[N[(N[(Pi * angle), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision], N[(1.0 * N[(N[(N[(N[Sin[N[(Pi * N[(angle * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;{b}^{2} \leq 2 \cdot 10^{-150}:\\
\;\;\;\;\left(\sin \left(\left(\pi \cdot angle\right) \cdot 0.011111111111111112\right) \cdot \left(b - a\right)\right) \cdot \left(a + b\right)\\
\mathbf{else}:\\
\;\;\;\;1 \cdot \left(\left(\left(\sin \left(\pi \cdot \left(angle \cdot 0.005555555555555556\right)\right) \cdot 2\right) \cdot \left(b - a\right)\right) \cdot \left(a + b\right)\right)\\
\end{array}
\end{array}
if (pow.f64 b #s(literal 2 binary64)) < 2.00000000000000001e-150Initial program 61.1%
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
associate-*l*N/A
lower-*.f64N/A
Applied rewrites66.0%
if 2.00000000000000001e-150 < (pow.f64 b #s(literal 2 binary64)) Initial program 49.3%
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-*.f6466.8
Applied rewrites66.2%
Taylor expanded in angle around 0
Applied rewrites74.5%
Final simplification71.3%
(FPCore (a b angle) :precision binary64 (if (<= (- (pow b 2.0) (pow a 2.0)) -5e-254) (* (* (* -0.011111111111111112 a) angle) (* PI a)) (* (* (* (* b b) PI) angle) 0.011111111111111112)))
double code(double a, double b, double angle) {
double tmp;
if ((pow(b, 2.0) - pow(a, 2.0)) <= -5e-254) {
tmp = ((-0.011111111111111112 * a) * angle) * (((double) M_PI) * a);
} else {
tmp = (((b * b) * ((double) M_PI)) * angle) * 0.011111111111111112;
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if ((Math.pow(b, 2.0) - Math.pow(a, 2.0)) <= -5e-254) {
tmp = ((-0.011111111111111112 * a) * angle) * (Math.PI * a);
} else {
tmp = (((b * b) * Math.PI) * angle) * 0.011111111111111112;
}
return tmp;
}
def code(a, b, angle): tmp = 0 if (math.pow(b, 2.0) - math.pow(a, 2.0)) <= -5e-254: tmp = ((-0.011111111111111112 * a) * angle) * (math.pi * a) else: tmp = (((b * b) * math.pi) * angle) * 0.011111111111111112 return tmp
function code(a, b, angle) tmp = 0.0 if (Float64((b ^ 2.0) - (a ^ 2.0)) <= -5e-254) tmp = Float64(Float64(Float64(-0.011111111111111112 * a) * angle) * Float64(pi * a)); else tmp = Float64(Float64(Float64(Float64(b * b) * pi) * angle) * 0.011111111111111112); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if (((b ^ 2.0) - (a ^ 2.0)) <= -5e-254) tmp = ((-0.011111111111111112 * a) * angle) * (pi * a); else tmp = (((b * b) * pi) * angle) * 0.011111111111111112; end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[N[(N[Power[b, 2.0], $MachinePrecision] - N[Power[a, 2.0], $MachinePrecision]), $MachinePrecision], -5e-254], N[(N[(N[(-0.011111111111111112 * a), $MachinePrecision] * angle), $MachinePrecision] * N[(Pi * a), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(b * b), $MachinePrecision] * Pi), $MachinePrecision] * angle), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;{b}^{2} - {a}^{2} \leq -5 \cdot 10^{-254}:\\
\;\;\;\;\left(\left(-0.011111111111111112 \cdot a\right) \cdot angle\right) \cdot \left(\pi \cdot a\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(b \cdot b\right) \cdot \pi\right) \cdot angle\right) \cdot 0.011111111111111112\\
\end{array}
\end{array}
if (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64))) < -5.0000000000000003e-254Initial program 61.6%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6457.4
Applied rewrites57.4%
Taylor expanded in b around 0
Applied rewrites57.3%
Applied rewrites66.9%
Applied rewrites67.0%
if -5.0000000000000003e-254 < (-.f64 (pow.f64 b #s(literal 2 binary64)) (pow.f64 a #s(literal 2 binary64))) Initial program 48.0%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6453.1
Applied rewrites53.1%
Taylor expanded in b around inf
Applied rewrites50.2%
Final simplification57.2%
(FPCore (a b angle)
:precision binary64
(if (<= (pow b 2.0) 2e+69)
(fma
(fma
(* (* PI angle) a)
-0.011111111111111112
(* (* (* 0.0 PI) angle) 0.011111111111111112))
a
(* (* (* (* b b) PI) angle) 0.011111111111111112))
(*
(*
(*
(*
(*
(fma
(* -2.8577960676726107e-8 (* angle angle))
(* (* PI PI) PI)
(* PI 0.005555555555555556))
angle)
2.0)
(- b a))
(+ a b))
1.0)))
double code(double a, double b, double angle) {
double tmp;
if (pow(b, 2.0) <= 2e+69) {
tmp = fma(fma(((((double) M_PI) * angle) * a), -0.011111111111111112, (((0.0 * ((double) M_PI)) * angle) * 0.011111111111111112)), a, ((((b * b) * ((double) M_PI)) * angle) * 0.011111111111111112));
} else {
tmp = ((((fma((-2.8577960676726107e-8 * (angle * angle)), ((((double) M_PI) * ((double) M_PI)) * ((double) M_PI)), (((double) M_PI) * 0.005555555555555556)) * angle) * 2.0) * (b - a)) * (a + b)) * 1.0;
}
return tmp;
}
function code(a, b, angle) tmp = 0.0 if ((b ^ 2.0) <= 2e+69) tmp = fma(fma(Float64(Float64(pi * angle) * a), -0.011111111111111112, Float64(Float64(Float64(0.0 * pi) * angle) * 0.011111111111111112)), a, Float64(Float64(Float64(Float64(b * b) * pi) * angle) * 0.011111111111111112)); else tmp = Float64(Float64(Float64(Float64(Float64(fma(Float64(-2.8577960676726107e-8 * Float64(angle * angle)), Float64(Float64(pi * pi) * pi), Float64(pi * 0.005555555555555556)) * angle) * 2.0) * Float64(b - a)) * Float64(a + b)) * 1.0); end return tmp end
code[a_, b_, angle_] := If[LessEqual[N[Power[b, 2.0], $MachinePrecision], 2e+69], N[(N[(N[(N[(Pi * angle), $MachinePrecision] * a), $MachinePrecision] * -0.011111111111111112 + N[(N[(N[(0.0 * Pi), $MachinePrecision] * angle), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]), $MachinePrecision] * a + N[(N[(N[(N[(b * b), $MachinePrecision] * Pi), $MachinePrecision] * angle), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(N[(N[(N[(-2.8577960676726107e-8 * N[(angle * angle), $MachinePrecision]), $MachinePrecision] * N[(N[(Pi * Pi), $MachinePrecision] * Pi), $MachinePrecision] + N[(Pi * 0.005555555555555556), $MachinePrecision]), $MachinePrecision] * angle), $MachinePrecision] * 2.0), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;{b}^{2} \leq 2 \cdot 10^{+69}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(\left(\pi \cdot angle\right) \cdot a, -0.011111111111111112, \left(\left(0 \cdot \pi\right) \cdot angle\right) \cdot 0.011111111111111112\right), a, \left(\left(\left(b \cdot b\right) \cdot \pi\right) \cdot angle\right) \cdot 0.011111111111111112\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(\left(\left(\mathsf{fma}\left(-2.8577960676726107 \cdot 10^{-8} \cdot \left(angle \cdot angle\right), \left(\pi \cdot \pi\right) \cdot \pi, \pi \cdot 0.005555555555555556\right) \cdot angle\right) \cdot 2\right) \cdot \left(b - a\right)\right) \cdot \left(a + b\right)\right) \cdot 1\\
\end{array}
\end{array}
if (pow.f64 b #s(literal 2 binary64)) < 2.0000000000000001e69Initial program 60.5%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6457.4
Applied rewrites57.4%
Taylor expanded in a around 0
Applied rewrites61.2%
if 2.0000000000000001e69 < (pow.f64 b #s(literal 2 binary64)) Initial program 45.2%
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-*.f6469.0
Applied rewrites68.0%
Taylor expanded in angle around 0
Applied rewrites79.6%
Taylor expanded in angle around 0
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow3N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-PI.f64N/A
lower-PI.f64N/A
lower-PI.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-PI.f6472.9
Applied rewrites72.9%
Final simplification66.4%
(FPCore (a b angle)
:precision binary64
(if (<= (pow b 2.0) 2e+69)
(fma
(fma
(* (* PI angle) a)
-0.011111111111111112
(* (* (* 0.0 PI) angle) 0.011111111111111112))
a
(* (* (* (* b b) PI) angle) 0.011111111111111112))
(*
(fma (* -1.54320987654321e-5 (* angle angle)) (* PI PI) 1.0)
(* (* (* (* PI (- b a)) angle) 0.011111111111111112) (+ a b)))))
double code(double a, double b, double angle) {
double tmp;
if (pow(b, 2.0) <= 2e+69) {
tmp = fma(fma(((((double) M_PI) * angle) * a), -0.011111111111111112, (((0.0 * ((double) M_PI)) * angle) * 0.011111111111111112)), a, ((((b * b) * ((double) M_PI)) * angle) * 0.011111111111111112));
} else {
tmp = fma((-1.54320987654321e-5 * (angle * angle)), (((double) M_PI) * ((double) M_PI)), 1.0) * ((((((double) M_PI) * (b - a)) * angle) * 0.011111111111111112) * (a + b));
}
return tmp;
}
function code(a, b, angle) tmp = 0.0 if ((b ^ 2.0) <= 2e+69) tmp = fma(fma(Float64(Float64(pi * angle) * a), -0.011111111111111112, Float64(Float64(Float64(0.0 * pi) * angle) * 0.011111111111111112)), a, Float64(Float64(Float64(Float64(b * b) * pi) * angle) * 0.011111111111111112)); else tmp = Float64(fma(Float64(-1.54320987654321e-5 * Float64(angle * angle)), Float64(pi * pi), 1.0) * Float64(Float64(Float64(Float64(pi * Float64(b - a)) * angle) * 0.011111111111111112) * Float64(a + b))); end return tmp end
code[a_, b_, angle_] := If[LessEqual[N[Power[b, 2.0], $MachinePrecision], 2e+69], N[(N[(N[(N[(Pi * angle), $MachinePrecision] * a), $MachinePrecision] * -0.011111111111111112 + N[(N[(N[(0.0 * Pi), $MachinePrecision] * angle), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]), $MachinePrecision] * a + N[(N[(N[(N[(b * b), $MachinePrecision] * Pi), $MachinePrecision] * angle), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]), $MachinePrecision], N[(N[(N[(-1.54320987654321e-5 * N[(angle * angle), $MachinePrecision]), $MachinePrecision] * N[(Pi * Pi), $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[(N[(N[(Pi * N[(b - a), $MachinePrecision]), $MachinePrecision] * angle), $MachinePrecision] * 0.011111111111111112), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;{b}^{2} \leq 2 \cdot 10^{+69}:\\
\;\;\;\;\mathsf{fma}\left(\mathsf{fma}\left(\left(\pi \cdot angle\right) \cdot a, -0.011111111111111112, \left(\left(0 \cdot \pi\right) \cdot angle\right) \cdot 0.011111111111111112\right), a, \left(\left(\left(b \cdot b\right) \cdot \pi\right) \cdot angle\right) \cdot 0.011111111111111112\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-1.54320987654321 \cdot 10^{-5} \cdot \left(angle \cdot angle\right), \pi \cdot \pi, 1\right) \cdot \left(\left(\left(\left(\pi \cdot \left(b - a\right)\right) \cdot angle\right) \cdot 0.011111111111111112\right) \cdot \left(a + b\right)\right)\\
\end{array}
\end{array}
if (pow.f64 b #s(literal 2 binary64)) < 2.0000000000000001e69Initial program 60.5%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6457.4
Applied rewrites57.4%
Taylor expanded in a around 0
Applied rewrites61.2%
if 2.0000000000000001e69 < (pow.f64 b #s(literal 2 binary64)) Initial program 45.2%
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-*.f6469.0
Applied rewrites68.0%
Taylor expanded in angle around 0
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-PI.f6466.5
Applied rewrites66.5%
Taylor expanded in angle around 0
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-PI.f64N/A
lower-PI.f6472.8
Applied rewrites72.8%
Final simplification66.3%
(FPCore (a b angle)
:precision binary64
(if (<= (/ angle 180.0) 4e+24)
(* (* (sin (* (* PI angle) 0.011111111111111112)) (- b a)) (+ a b))
(if (<= (/ angle 180.0) 1e+92)
(*
(* (* a a) 2.0)
(*
(fma
(* -1.1431184270690443e-7 (* (* PI PI) PI))
(* angle angle)
(* PI 0.005555555555555556))
angle))
(* (* (- b a) (+ a b)) (sin (* (* 0.011111111111111112 angle) PI))))))
double code(double a, double b, double angle) {
double tmp;
if ((angle / 180.0) <= 4e+24) {
tmp = (sin(((((double) M_PI) * angle) * 0.011111111111111112)) * (b - a)) * (a + b);
} else if ((angle / 180.0) <= 1e+92) {
tmp = ((a * a) * 2.0) * (fma((-1.1431184270690443e-7 * ((((double) M_PI) * ((double) M_PI)) * ((double) M_PI))), (angle * angle), (((double) M_PI) * 0.005555555555555556)) * angle);
} else {
tmp = ((b - a) * (a + b)) * sin(((0.011111111111111112 * angle) * ((double) M_PI)));
}
return tmp;
}
function code(a, b, angle) tmp = 0.0 if (Float64(angle / 180.0) <= 4e+24) tmp = Float64(Float64(sin(Float64(Float64(pi * angle) * 0.011111111111111112)) * Float64(b - a)) * Float64(a + b)); elseif (Float64(angle / 180.0) <= 1e+92) tmp = Float64(Float64(Float64(a * a) * 2.0) * Float64(fma(Float64(-1.1431184270690443e-7 * Float64(Float64(pi * pi) * pi)), Float64(angle * angle), Float64(pi * 0.005555555555555556)) * angle)); else tmp = Float64(Float64(Float64(b - a) * Float64(a + b)) * sin(Float64(Float64(0.011111111111111112 * angle) * pi))); end return tmp end
code[a_, b_, angle_] := If[LessEqual[N[(angle / 180.0), $MachinePrecision], 4e+24], N[(N[(N[Sin[N[(N[(Pi * angle), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 1e+92], N[(N[(N[(a * a), $MachinePrecision] * 2.0), $MachinePrecision] * N[(N[(N[(-1.1431184270690443e-7 * N[(N[(Pi * Pi), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision] * N[(angle * angle), $MachinePrecision] + N[(Pi * 0.005555555555555556), $MachinePrecision]), $MachinePrecision] * angle), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b - a), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[(0.011111111111111112 * angle), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{angle}{180} \leq 4 \cdot 10^{+24}:\\
\;\;\;\;\left(\sin \left(\left(\pi \cdot angle\right) \cdot 0.011111111111111112\right) \cdot \left(b - a\right)\right) \cdot \left(a + b\right)\\
\mathbf{elif}\;\frac{angle}{180} \leq 10^{+92}:\\
\;\;\;\;\left(\left(a \cdot a\right) \cdot 2\right) \cdot \left(\mathsf{fma}\left(-1.1431184270690443 \cdot 10^{-7} \cdot \left(\left(\pi \cdot \pi\right) \cdot \pi\right), angle \cdot angle, \pi \cdot 0.005555555555555556\right) \cdot angle\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b - a\right) \cdot \left(a + b\right)\right) \cdot \sin \left(\left(0.011111111111111112 \cdot angle\right) \cdot \pi\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 3.9999999999999999e24Initial program 60.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
associate-*l*N/A
lower-*.f64N/A
Applied rewrites77.0%
if 3.9999999999999999e24 < (/.f64 angle #s(literal 180 binary64)) < 1e92Initial program 27.6%
Applied rewrites1.3%
Taylor expanded in a around inf
unpow2N/A
lower-*.f6425.0
Applied rewrites25.0%
lift-*.f64N/A
lift-*.f64N/A
Applied rewrites18.5%
Taylor expanded in angle around 0
*-commutativeN/A
lower-*.f64N/A
Applied rewrites49.3%
if 1e92 < (/.f64 angle #s(literal 180 binary64)) Initial program 35.0%
Applied rewrites1.8%
Applied rewrites45.5%
Final simplification69.4%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (* (* PI PI) PI)))
(if (<= (/ angle 180.0) 2e+20)
(*
(*
(*
(*
(*
(fma
(* -2.8577960676726107e-8 (* angle angle))
t_0
(* PI 0.005555555555555556))
angle)
2.0)
(- b a))
(+ a b))
1.0)
(if (<= (/ angle 180.0) 1e+92)
(*
(* (* a a) 2.0)
(*
(fma
(* -1.1431184270690443e-7 t_0)
(* angle angle)
(* PI 0.005555555555555556))
angle))
(* (* (- b a) (+ a b)) (sin (* (* 0.011111111111111112 angle) PI)))))))
double code(double a, double b, double angle) {
double t_0 = (((double) M_PI) * ((double) M_PI)) * ((double) M_PI);
double tmp;
if ((angle / 180.0) <= 2e+20) {
tmp = ((((fma((-2.8577960676726107e-8 * (angle * angle)), t_0, (((double) M_PI) * 0.005555555555555556)) * angle) * 2.0) * (b - a)) * (a + b)) * 1.0;
} else if ((angle / 180.0) <= 1e+92) {
tmp = ((a * a) * 2.0) * (fma((-1.1431184270690443e-7 * t_0), (angle * angle), (((double) M_PI) * 0.005555555555555556)) * angle);
} else {
tmp = ((b - a) * (a + b)) * sin(((0.011111111111111112 * angle) * ((double) M_PI)));
}
return tmp;
}
function code(a, b, angle) t_0 = Float64(Float64(pi * pi) * pi) tmp = 0.0 if (Float64(angle / 180.0) <= 2e+20) tmp = Float64(Float64(Float64(Float64(Float64(fma(Float64(-2.8577960676726107e-8 * Float64(angle * angle)), t_0, Float64(pi * 0.005555555555555556)) * angle) * 2.0) * Float64(b - a)) * Float64(a + b)) * 1.0); elseif (Float64(angle / 180.0) <= 1e+92) tmp = Float64(Float64(Float64(a * a) * 2.0) * Float64(fma(Float64(-1.1431184270690443e-7 * t_0), Float64(angle * angle), Float64(pi * 0.005555555555555556)) * angle)); else tmp = Float64(Float64(Float64(b - a) * Float64(a + b)) * sin(Float64(Float64(0.011111111111111112 * angle) * pi))); end return tmp end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[(Pi * Pi), $MachinePrecision] * Pi), $MachinePrecision]}, If[LessEqual[N[(angle / 180.0), $MachinePrecision], 2e+20], N[(N[(N[(N[(N[(N[(N[(-2.8577960676726107e-8 * N[(angle * angle), $MachinePrecision]), $MachinePrecision] * t$95$0 + N[(Pi * 0.005555555555555556), $MachinePrecision]), $MachinePrecision] * angle), $MachinePrecision] * 2.0), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 1e+92], N[(N[(N[(a * a), $MachinePrecision] * 2.0), $MachinePrecision] * N[(N[(N[(-1.1431184270690443e-7 * t$95$0), $MachinePrecision] * N[(angle * angle), $MachinePrecision] + N[(Pi * 0.005555555555555556), $MachinePrecision]), $MachinePrecision] * angle), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b - a), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[(0.011111111111111112 * angle), $MachinePrecision] * Pi), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\pi \cdot \pi\right) \cdot \pi\\
\mathbf{if}\;\frac{angle}{180} \leq 2 \cdot 10^{+20}:\\
\;\;\;\;\left(\left(\left(\left(\mathsf{fma}\left(-2.8577960676726107 \cdot 10^{-8} \cdot \left(angle \cdot angle\right), t\_0, \pi \cdot 0.005555555555555556\right) \cdot angle\right) \cdot 2\right) \cdot \left(b - a\right)\right) \cdot \left(a + b\right)\right) \cdot 1\\
\mathbf{elif}\;\frac{angle}{180} \leq 10^{+92}:\\
\;\;\;\;\left(\left(a \cdot a\right) \cdot 2\right) \cdot \left(\mathsf{fma}\left(-1.1431184270690443 \cdot 10^{-7} \cdot t\_0, angle \cdot angle, \pi \cdot 0.005555555555555556\right) \cdot angle\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b - a\right) \cdot \left(a + b\right)\right) \cdot \sin \left(\left(0.011111111111111112 \cdot angle\right) \cdot \pi\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 2e20Initial program 60.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-*.f6477.0
Applied rewrites77.0%
Taylor expanded in angle around 0
Applied rewrites79.5%
Taylor expanded in angle around 0
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow3N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-PI.f64N/A
lower-PI.f64N/A
lower-PI.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-PI.f6474.3
Applied rewrites74.3%
if 2e20 < (/.f64 angle #s(literal 180 binary64)) < 1e92Initial program 27.6%
Applied rewrites1.3%
Taylor expanded in a around inf
unpow2N/A
lower-*.f6425.0
Applied rewrites25.0%
lift-*.f64N/A
lift-*.f64N/A
Applied rewrites18.5%
Taylor expanded in angle around 0
*-commutativeN/A
lower-*.f64N/A
Applied rewrites49.3%
if 1e92 < (/.f64 angle #s(literal 180 binary64)) Initial program 35.0%
Applied rewrites1.8%
Applied rewrites45.5%
Final simplification67.4%
(FPCore (a b angle)
:precision binary64
(let* ((t_0 (* (* PI PI) PI)))
(if (<= (/ angle 180.0) 2e+20)
(*
(*
(*
(*
(*
(fma
(* -2.8577960676726107e-8 (* angle angle))
t_0
(* PI 0.005555555555555556))
angle)
2.0)
(- b a))
(+ a b))
1.0)
(if (<= (/ angle 180.0) 1e+92)
(*
(* (* a a) 2.0)
(*
(fma
(* -1.1431184270690443e-7 t_0)
(* angle angle)
(* PI 0.005555555555555556))
angle))
(* (* (- b a) (+ a b)) (sin (* (* PI angle) 0.011111111111111112)))))))
double code(double a, double b, double angle) {
double t_0 = (((double) M_PI) * ((double) M_PI)) * ((double) M_PI);
double tmp;
if ((angle / 180.0) <= 2e+20) {
tmp = ((((fma((-2.8577960676726107e-8 * (angle * angle)), t_0, (((double) M_PI) * 0.005555555555555556)) * angle) * 2.0) * (b - a)) * (a + b)) * 1.0;
} else if ((angle / 180.0) <= 1e+92) {
tmp = ((a * a) * 2.0) * (fma((-1.1431184270690443e-7 * t_0), (angle * angle), (((double) M_PI) * 0.005555555555555556)) * angle);
} else {
tmp = ((b - a) * (a + b)) * sin(((((double) M_PI) * angle) * 0.011111111111111112));
}
return tmp;
}
function code(a, b, angle) t_0 = Float64(Float64(pi * pi) * pi) tmp = 0.0 if (Float64(angle / 180.0) <= 2e+20) tmp = Float64(Float64(Float64(Float64(Float64(fma(Float64(-2.8577960676726107e-8 * Float64(angle * angle)), t_0, Float64(pi * 0.005555555555555556)) * angle) * 2.0) * Float64(b - a)) * Float64(a + b)) * 1.0); elseif (Float64(angle / 180.0) <= 1e+92) tmp = Float64(Float64(Float64(a * a) * 2.0) * Float64(fma(Float64(-1.1431184270690443e-7 * t_0), Float64(angle * angle), Float64(pi * 0.005555555555555556)) * angle)); else tmp = Float64(Float64(Float64(b - a) * Float64(a + b)) * sin(Float64(Float64(pi * angle) * 0.011111111111111112))); end return tmp end
code[a_, b_, angle_] := Block[{t$95$0 = N[(N[(Pi * Pi), $MachinePrecision] * Pi), $MachinePrecision]}, If[LessEqual[N[(angle / 180.0), $MachinePrecision], 2e+20], N[(N[(N[(N[(N[(N[(N[(-2.8577960676726107e-8 * N[(angle * angle), $MachinePrecision]), $MachinePrecision] * t$95$0 + N[(Pi * 0.005555555555555556), $MachinePrecision]), $MachinePrecision] * angle), $MachinePrecision] * 2.0), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 1e+92], N[(N[(N[(a * a), $MachinePrecision] * 2.0), $MachinePrecision] * N[(N[(N[(-1.1431184270690443e-7 * t$95$0), $MachinePrecision] * N[(angle * angle), $MachinePrecision] + N[(Pi * 0.005555555555555556), $MachinePrecision]), $MachinePrecision] * angle), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b - a), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[Sin[N[(N[(Pi * angle), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(\pi \cdot \pi\right) \cdot \pi\\
\mathbf{if}\;\frac{angle}{180} \leq 2 \cdot 10^{+20}:\\
\;\;\;\;\left(\left(\left(\left(\mathsf{fma}\left(-2.8577960676726107 \cdot 10^{-8} \cdot \left(angle \cdot angle\right), t\_0, \pi \cdot 0.005555555555555556\right) \cdot angle\right) \cdot 2\right) \cdot \left(b - a\right)\right) \cdot \left(a + b\right)\right) \cdot 1\\
\mathbf{elif}\;\frac{angle}{180} \leq 10^{+92}:\\
\;\;\;\;\left(\left(a \cdot a\right) \cdot 2\right) \cdot \left(\mathsf{fma}\left(-1.1431184270690443 \cdot 10^{-7} \cdot t\_0, angle \cdot angle, \pi \cdot 0.005555555555555556\right) \cdot angle\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b - a\right) \cdot \left(a + b\right)\right) \cdot \sin \left(\left(\pi \cdot angle\right) \cdot 0.011111111111111112\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 2e20Initial program 60.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-*.f6477.0
Applied rewrites77.0%
Taylor expanded in angle around 0
Applied rewrites79.5%
Taylor expanded in angle around 0
*-commutativeN/A
lower-*.f64N/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow3N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-PI.f64N/A
lower-PI.f64N/A
lower-PI.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-PI.f6474.3
Applied rewrites74.3%
if 2e20 < (/.f64 angle #s(literal 180 binary64)) < 1e92Initial program 27.6%
Applied rewrites1.3%
Taylor expanded in a around inf
unpow2N/A
lower-*.f6425.0
Applied rewrites25.0%
lift-*.f64N/A
lift-*.f64N/A
Applied rewrites18.5%
Taylor expanded in angle around 0
*-commutativeN/A
lower-*.f64N/A
Applied rewrites49.3%
if 1e92 < (/.f64 angle #s(literal 180 binary64)) Initial program 35.0%
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lower-*.f64N/A
lift--.f64N/A
lift-pow.f64N/A
unpow2N/A
lift-pow.f64N/A
unpow2N/A
difference-of-squaresN/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
+-commutativeN/A
lower-+.f64N/A
Applied rewrites39.5%
Final simplification66.3%
(FPCore (a b angle)
:precision binary64
(if (<= b 4.8e+204)
(* (* (sin (* (* PI angle) 0.011111111111111112)) (- b a)) (+ a b))
(*
(* b (* (* (sin (* PI (* angle 0.005555555555555556))) 2.0) (- b a)))
1.0)))
double code(double a, double b, double angle) {
double tmp;
if (b <= 4.8e+204) {
tmp = (sin(((((double) M_PI) * angle) * 0.011111111111111112)) * (b - a)) * (a + b);
} else {
tmp = (b * ((sin((((double) M_PI) * (angle * 0.005555555555555556))) * 2.0) * (b - a))) * 1.0;
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (b <= 4.8e+204) {
tmp = (Math.sin(((Math.PI * angle) * 0.011111111111111112)) * (b - a)) * (a + b);
} else {
tmp = (b * ((Math.sin((Math.PI * (angle * 0.005555555555555556))) * 2.0) * (b - a))) * 1.0;
}
return tmp;
}
def code(a, b, angle): tmp = 0 if b <= 4.8e+204: tmp = (math.sin(((math.pi * angle) * 0.011111111111111112)) * (b - a)) * (a + b) else: tmp = (b * ((math.sin((math.pi * (angle * 0.005555555555555556))) * 2.0) * (b - a))) * 1.0 return tmp
function code(a, b, angle) tmp = 0.0 if (b <= 4.8e+204) tmp = Float64(Float64(sin(Float64(Float64(pi * angle) * 0.011111111111111112)) * Float64(b - a)) * Float64(a + b)); else tmp = Float64(Float64(b * Float64(Float64(sin(Float64(pi * Float64(angle * 0.005555555555555556))) * 2.0) * Float64(b - a))) * 1.0); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if (b <= 4.8e+204) tmp = (sin(((pi * angle) * 0.011111111111111112)) * (b - a)) * (a + b); else tmp = (b * ((sin((pi * (angle * 0.005555555555555556))) * 2.0) * (b - a))) * 1.0; end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[b, 4.8e+204], N[(N[(N[Sin[N[(N[(Pi * angle), $MachinePrecision] * 0.011111111111111112), $MachinePrecision]], $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision], N[(N[(b * N[(N[(N[Sin[N[(Pi * N[(angle * 0.005555555555555556), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * 2.0), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * 1.0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 4.8 \cdot 10^{+204}:\\
\;\;\;\;\left(\sin \left(\left(\pi \cdot angle\right) \cdot 0.011111111111111112\right) \cdot \left(b - a\right)\right) \cdot \left(a + b\right)\\
\mathbf{else}:\\
\;\;\;\;\left(b \cdot \left(\left(\sin \left(\pi \cdot \left(angle \cdot 0.005555555555555556\right)\right) \cdot 2\right) \cdot \left(b - a\right)\right)\right) \cdot 1\\
\end{array}
\end{array}
if b < 4.7999999999999999e204Initial program 54.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
associate-*l*N/A
lower-*.f64N/A
Applied rewrites66.5%
if 4.7999999999999999e204 < b Initial program 45.6%
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-*.f6477.7
Applied rewrites74.0%
Taylor expanded in angle around 0
Applied rewrites88.8%
lift-+.f64N/A
+-commutativeN/A
unpow1N/A
sqr-powN/A
lower-fma.f64N/A
metadata-evalN/A
unpow1/2N/A
lower-sqrt.f64N/A
metadata-evalN/A
unpow1/2N/A
lower-sqrt.f6488.6
Applied rewrites88.6%
Taylor expanded in b around -inf
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
mul-1-negN/A
distribute-lft-neg-inN/A
metadata-evalN/A
*-lft-identity85.1
Applied rewrites85.1%
Final simplification68.5%
(FPCore (a b angle) :precision binary64 (if (<= (pow a 2.0) 4e+218) (* (* (- b a) (+ a b)) (* (* 0.011111111111111112 PI) angle)) (* (* (* -0.011111111111111112 a) angle) (* PI a))))
double code(double a, double b, double angle) {
double tmp;
if (pow(a, 2.0) <= 4e+218) {
tmp = ((b - a) * (a + b)) * ((0.011111111111111112 * ((double) M_PI)) * angle);
} else {
tmp = ((-0.011111111111111112 * a) * angle) * (((double) M_PI) * a);
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (Math.pow(a, 2.0) <= 4e+218) {
tmp = ((b - a) * (a + b)) * ((0.011111111111111112 * Math.PI) * angle);
} else {
tmp = ((-0.011111111111111112 * a) * angle) * (Math.PI * a);
}
return tmp;
}
def code(a, b, angle): tmp = 0 if math.pow(a, 2.0) <= 4e+218: tmp = ((b - a) * (a + b)) * ((0.011111111111111112 * math.pi) * angle) else: tmp = ((-0.011111111111111112 * a) * angle) * (math.pi * a) return tmp
function code(a, b, angle) tmp = 0.0 if ((a ^ 2.0) <= 4e+218) tmp = Float64(Float64(Float64(b - a) * Float64(a + b)) * Float64(Float64(0.011111111111111112 * pi) * angle)); else tmp = Float64(Float64(Float64(-0.011111111111111112 * a) * angle) * Float64(pi * a)); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if ((a ^ 2.0) <= 4e+218) tmp = ((b - a) * (a + b)) * ((0.011111111111111112 * pi) * angle); else tmp = ((-0.011111111111111112 * a) * angle) * (pi * a); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[N[Power[a, 2.0], $MachinePrecision], 4e+218], N[(N[(N[(b - a), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[(N[(0.011111111111111112 * Pi), $MachinePrecision] * angle), $MachinePrecision]), $MachinePrecision], N[(N[(N[(-0.011111111111111112 * a), $MachinePrecision] * angle), $MachinePrecision] * N[(Pi * a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;{a}^{2} \leq 4 \cdot 10^{+218}:\\
\;\;\;\;\left(\left(b - a\right) \cdot \left(a + b\right)\right) \cdot \left(\left(0.011111111111111112 \cdot \pi\right) \cdot angle\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-0.011111111111111112 \cdot a\right) \cdot angle\right) \cdot \left(\pi \cdot a\right)\\
\end{array}
\end{array}
if (pow.f64 a #s(literal 2 binary64)) < 4.00000000000000033e218Initial program 59.2%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6455.4
Applied rewrites55.4%
Applied rewrites55.5%
if 4.00000000000000033e218 < (pow.f64 a #s(literal 2 binary64)) Initial program 42.9%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6453.8
Applied rewrites53.8%
Taylor expanded in b around 0
Applied rewrites55.0%
Applied rewrites66.8%
Applied rewrites66.8%
Final simplification59.3%
(FPCore (a b angle) :precision binary64 (if (<= (pow a 2.0) 4e+218) (* (* (- b a) (+ a b)) (* (* 0.011111111111111112 angle) PI)) (* (* (* -0.011111111111111112 a) angle) (* PI a))))
double code(double a, double b, double angle) {
double tmp;
if (pow(a, 2.0) <= 4e+218) {
tmp = ((b - a) * (a + b)) * ((0.011111111111111112 * angle) * ((double) M_PI));
} else {
tmp = ((-0.011111111111111112 * a) * angle) * (((double) M_PI) * a);
}
return tmp;
}
public static double code(double a, double b, double angle) {
double tmp;
if (Math.pow(a, 2.0) <= 4e+218) {
tmp = ((b - a) * (a + b)) * ((0.011111111111111112 * angle) * Math.PI);
} else {
tmp = ((-0.011111111111111112 * a) * angle) * (Math.PI * a);
}
return tmp;
}
def code(a, b, angle): tmp = 0 if math.pow(a, 2.0) <= 4e+218: tmp = ((b - a) * (a + b)) * ((0.011111111111111112 * angle) * math.pi) else: tmp = ((-0.011111111111111112 * a) * angle) * (math.pi * a) return tmp
function code(a, b, angle) tmp = 0.0 if ((a ^ 2.0) <= 4e+218) tmp = Float64(Float64(Float64(b - a) * Float64(a + b)) * Float64(Float64(0.011111111111111112 * angle) * pi)); else tmp = Float64(Float64(Float64(-0.011111111111111112 * a) * angle) * Float64(pi * a)); end return tmp end
function tmp_2 = code(a, b, angle) tmp = 0.0; if ((a ^ 2.0) <= 4e+218) tmp = ((b - a) * (a + b)) * ((0.011111111111111112 * angle) * pi); else tmp = ((-0.011111111111111112 * a) * angle) * (pi * a); end tmp_2 = tmp; end
code[a_, b_, angle_] := If[LessEqual[N[Power[a, 2.0], $MachinePrecision], 4e+218], N[(N[(N[(b - a), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[(N[(0.011111111111111112 * angle), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision], N[(N[(N[(-0.011111111111111112 * a), $MachinePrecision] * angle), $MachinePrecision] * N[(Pi * a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;{a}^{2} \leq 4 \cdot 10^{+218}:\\
\;\;\;\;\left(\left(b - a\right) \cdot \left(a + b\right)\right) \cdot \left(\left(0.011111111111111112 \cdot angle\right) \cdot \pi\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(-0.011111111111111112 \cdot a\right) \cdot angle\right) \cdot \left(\pi \cdot a\right)\\
\end{array}
\end{array}
if (pow.f64 a #s(literal 2 binary64)) < 4.00000000000000033e218Initial program 59.2%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6455.4
Applied rewrites55.4%
if 4.00000000000000033e218 < (pow.f64 a #s(literal 2 binary64)) Initial program 42.9%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6453.8
Applied rewrites53.8%
Taylor expanded in b around 0
Applied rewrites55.0%
Applied rewrites66.8%
Applied rewrites66.8%
Final simplification59.3%
(FPCore (a b angle)
:precision binary64
(if (<= (/ angle 180.0) 2e+54)
(* (* (* 0.011111111111111112 (+ a b)) (* PI angle)) (- b a))
(if (<= (/ angle 180.0) 5e+230)
(*
(* (* a a) 2.0)
(*
(fma
(* -1.1431184270690443e-7 (* (* PI PI) PI))
(* angle angle)
(* PI 0.005555555555555556))
angle))
(* (* (- b a) (+ a b)) (* (* 0.011111111111111112 PI) angle)))))
double code(double a, double b, double angle) {
double tmp;
if ((angle / 180.0) <= 2e+54) {
tmp = ((0.011111111111111112 * (a + b)) * (((double) M_PI) * angle)) * (b - a);
} else if ((angle / 180.0) <= 5e+230) {
tmp = ((a * a) * 2.0) * (fma((-1.1431184270690443e-7 * ((((double) M_PI) * ((double) M_PI)) * ((double) M_PI))), (angle * angle), (((double) M_PI) * 0.005555555555555556)) * angle);
} else {
tmp = ((b - a) * (a + b)) * ((0.011111111111111112 * ((double) M_PI)) * angle);
}
return tmp;
}
function code(a, b, angle) tmp = 0.0 if (Float64(angle / 180.0) <= 2e+54) tmp = Float64(Float64(Float64(0.011111111111111112 * Float64(a + b)) * Float64(pi * angle)) * Float64(b - a)); elseif (Float64(angle / 180.0) <= 5e+230) tmp = Float64(Float64(Float64(a * a) * 2.0) * Float64(fma(Float64(-1.1431184270690443e-7 * Float64(Float64(pi * pi) * pi)), Float64(angle * angle), Float64(pi * 0.005555555555555556)) * angle)); else tmp = Float64(Float64(Float64(b - a) * Float64(a + b)) * Float64(Float64(0.011111111111111112 * pi) * angle)); end return tmp end
code[a_, b_, angle_] := If[LessEqual[N[(angle / 180.0), $MachinePrecision], 2e+54], N[(N[(N[(0.011111111111111112 * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[(Pi * angle), $MachinePrecision]), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(angle / 180.0), $MachinePrecision], 5e+230], N[(N[(N[(a * a), $MachinePrecision] * 2.0), $MachinePrecision] * N[(N[(N[(-1.1431184270690443e-7 * N[(N[(Pi * Pi), $MachinePrecision] * Pi), $MachinePrecision]), $MachinePrecision] * N[(angle * angle), $MachinePrecision] + N[(Pi * 0.005555555555555556), $MachinePrecision]), $MachinePrecision] * angle), $MachinePrecision]), $MachinePrecision], N[(N[(N[(b - a), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[(N[(0.011111111111111112 * Pi), $MachinePrecision] * angle), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\frac{angle}{180} \leq 2 \cdot 10^{+54}:\\
\;\;\;\;\left(\left(0.011111111111111112 \cdot \left(a + b\right)\right) \cdot \left(\pi \cdot angle\right)\right) \cdot \left(b - a\right)\\
\mathbf{elif}\;\frac{angle}{180} \leq 5 \cdot 10^{+230}:\\
\;\;\;\;\left(\left(a \cdot a\right) \cdot 2\right) \cdot \left(\mathsf{fma}\left(-1.1431184270690443 \cdot 10^{-7} \cdot \left(\left(\pi \cdot \pi\right) \cdot \pi\right), angle \cdot angle, \pi \cdot 0.005555555555555556\right) \cdot angle\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\left(b - a\right) \cdot \left(a + b\right)\right) \cdot \left(\left(0.011111111111111112 \cdot \pi\right) \cdot angle\right)\\
\end{array}
\end{array}
if (/.f64 angle #s(literal 180 binary64)) < 2.0000000000000002e54Initial program 60.3%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6462.9
Applied rewrites62.9%
Applied rewrites73.9%
if 2.0000000000000002e54 < (/.f64 angle #s(literal 180 binary64)) < 5.0000000000000003e230Initial program 31.8%
Applied rewrites1.3%
Taylor expanded in a around inf
unpow2N/A
lower-*.f6418.9
Applied rewrites18.9%
lift-*.f64N/A
lift-*.f64N/A
Applied rewrites19.0%
Taylor expanded in angle around 0
*-commutativeN/A
lower-*.f64N/A
Applied rewrites30.2%
if 5.0000000000000003e230 < (/.f64 angle #s(literal 180 binary64)) Initial program 35.4%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6439.2
Applied rewrites39.2%
Applied rewrites39.2%
Final simplification64.0%
(FPCore (a b angle)
:precision binary64
(if (<= b 3.4e+167)
(* (* (* 0.011111111111111112 (+ a b)) (* PI angle)) (- b a))
(*
(fma (* -1.54320987654321e-5 (* angle angle)) (* PI PI) 1.0)
(* (* (* (* PI (- b a)) angle) 0.011111111111111112) (+ a b)))))
double code(double a, double b, double angle) {
double tmp;
if (b <= 3.4e+167) {
tmp = ((0.011111111111111112 * (a + b)) * (((double) M_PI) * angle)) * (b - a);
} else {
tmp = fma((-1.54320987654321e-5 * (angle * angle)), (((double) M_PI) * ((double) M_PI)), 1.0) * ((((((double) M_PI) * (b - a)) * angle) * 0.011111111111111112) * (a + b));
}
return tmp;
}
function code(a, b, angle) tmp = 0.0 if (b <= 3.4e+167) tmp = Float64(Float64(Float64(0.011111111111111112 * Float64(a + b)) * Float64(pi * angle)) * Float64(b - a)); else tmp = Float64(fma(Float64(-1.54320987654321e-5 * Float64(angle * angle)), Float64(pi * pi), 1.0) * Float64(Float64(Float64(Float64(pi * Float64(b - a)) * angle) * 0.011111111111111112) * Float64(a + b))); end return tmp end
code[a_, b_, angle_] := If[LessEqual[b, 3.4e+167], N[(N[(N[(0.011111111111111112 * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[(Pi * angle), $MachinePrecision]), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision], N[(N[(N[(-1.54320987654321e-5 * N[(angle * angle), $MachinePrecision]), $MachinePrecision] * N[(Pi * Pi), $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[(N[(N[(Pi * N[(b - a), $MachinePrecision]), $MachinePrecision] * angle), $MachinePrecision] * 0.011111111111111112), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq 3.4 \cdot 10^{+167}:\\
\;\;\;\;\left(\left(0.011111111111111112 \cdot \left(a + b\right)\right) \cdot \left(\pi \cdot angle\right)\right) \cdot \left(b - a\right)\\
\mathbf{else}:\\
\;\;\;\;\mathsf{fma}\left(-1.54320987654321 \cdot 10^{-5} \cdot \left(angle \cdot angle\right), \pi \cdot \pi, 1\right) \cdot \left(\left(\left(\left(\pi \cdot \left(b - a\right)\right) \cdot angle\right) \cdot 0.011111111111111112\right) \cdot \left(a + b\right)\right)\\
\end{array}
\end{array}
if b < 3.4e167Initial program 55.2%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6455.6
Applied rewrites55.6%
Applied rewrites61.6%
if 3.4e167 < b Initial program 44.9%
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-*.f6481.0
Applied rewrites78.2%
Taylor expanded in angle around 0
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower--.f64N/A
lower-PI.f6478.3
Applied rewrites78.3%
Taylor expanded in angle around 0
+-commutativeN/A
associate-*r*N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-PI.f64N/A
lower-PI.f6481.0
Applied rewrites81.0%
Final simplification64.4%
(FPCore (a b angle) :precision binary64 (* (* (* 0.011111111111111112 (+ a b)) (* PI angle)) (- b a)))
double code(double a, double b, double angle) {
return ((0.011111111111111112 * (a + b)) * (((double) M_PI) * angle)) * (b - a);
}
public static double code(double a, double b, double angle) {
return ((0.011111111111111112 * (a + b)) * (Math.PI * angle)) * (b - a);
}
def code(a, b, angle): return ((0.011111111111111112 * (a + b)) * (math.pi * angle)) * (b - a)
function code(a, b, angle) return Float64(Float64(Float64(0.011111111111111112 * Float64(a + b)) * Float64(pi * angle)) * Float64(b - a)) end
function tmp = code(a, b, angle) tmp = ((0.011111111111111112 * (a + b)) * (pi * angle)) * (b - a); end
code[a_, b_, angle_] := N[(N[(N[(0.011111111111111112 * N[(a + b), $MachinePrecision]), $MachinePrecision] * N[(Pi * angle), $MachinePrecision]), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(0.011111111111111112 \cdot \left(a + b\right)\right) \cdot \left(\pi \cdot angle\right)\right) \cdot \left(b - a\right)
\end{array}
Initial program 53.7%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6454.9
Applied rewrites54.9%
Applied rewrites62.9%
Final simplification62.9%
(FPCore (a b angle) :precision binary64 (* (* (* (* 0.011111111111111112 angle) PI) (- b a)) (+ a b)))
double code(double a, double b, double angle) {
return (((0.011111111111111112 * angle) * ((double) M_PI)) * (b - a)) * (a + b);
}
public static double code(double a, double b, double angle) {
return (((0.011111111111111112 * angle) * Math.PI) * (b - a)) * (a + b);
}
def code(a, b, angle): return (((0.011111111111111112 * angle) * math.pi) * (b - a)) * (a + b)
function code(a, b, angle) return Float64(Float64(Float64(Float64(0.011111111111111112 * angle) * pi) * Float64(b - a)) * Float64(a + b)) end
function tmp = code(a, b, angle) tmp = (((0.011111111111111112 * angle) * pi) * (b - a)) * (a + b); end
code[a_, b_, angle_] := N[(N[(N[(N[(0.011111111111111112 * angle), $MachinePrecision] * Pi), $MachinePrecision] * N[(b - a), $MachinePrecision]), $MachinePrecision] * N[(a + b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(\left(0.011111111111111112 \cdot angle\right) \cdot \pi\right) \cdot \left(b - a\right)\right) \cdot \left(a + b\right)
\end{array}
Initial program 53.7%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6454.9
Applied rewrites54.9%
Applied rewrites62.8%
Final simplification62.8%
(FPCore (a b angle) :precision binary64 (* (* (* -0.011111111111111112 a) angle) (* PI a)))
double code(double a, double b, double angle) {
return ((-0.011111111111111112 * a) * angle) * (((double) M_PI) * a);
}
public static double code(double a, double b, double angle) {
return ((-0.011111111111111112 * a) * angle) * (Math.PI * a);
}
def code(a, b, angle): return ((-0.011111111111111112 * a) * angle) * (math.pi * a)
function code(a, b, angle) return Float64(Float64(Float64(-0.011111111111111112 * a) * angle) * Float64(pi * a)) end
function tmp = code(a, b, angle) tmp = ((-0.011111111111111112 * a) * angle) * (pi * a); end
code[a_, b_, angle_] := N[(N[(N[(-0.011111111111111112 * a), $MachinePrecision] * angle), $MachinePrecision] * N[(Pi * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(\left(-0.011111111111111112 \cdot a\right) \cdot angle\right) \cdot \left(\pi \cdot a\right)
\end{array}
Initial program 53.7%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6454.9
Applied rewrites54.9%
Taylor expanded in b around 0
Applied rewrites37.5%
Applied rewrites40.4%
Applied rewrites40.4%
Final simplification40.4%
(FPCore (a b angle) :precision binary64 (* (* -0.011111111111111112 a) (* (* PI angle) a)))
double code(double a, double b, double angle) {
return (-0.011111111111111112 * a) * ((((double) M_PI) * angle) * a);
}
public static double code(double a, double b, double angle) {
return (-0.011111111111111112 * a) * ((Math.PI * angle) * a);
}
def code(a, b, angle): return (-0.011111111111111112 * a) * ((math.pi * angle) * a)
function code(a, b, angle) return Float64(Float64(-0.011111111111111112 * a) * Float64(Float64(pi * angle) * a)) end
function tmp = code(a, b, angle) tmp = (-0.011111111111111112 * a) * ((pi * angle) * a); end
code[a_, b_, angle_] := N[(N[(-0.011111111111111112 * a), $MachinePrecision] * N[(N[(Pi * angle), $MachinePrecision] * a), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(-0.011111111111111112 \cdot a\right) \cdot \left(\left(\pi \cdot angle\right) \cdot a\right)
\end{array}
Initial program 53.7%
Taylor expanded in angle around 0
associate-*r*N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-PI.f64N/A
unpow2N/A
unpow2N/A
difference-of-squaresN/A
lower-*.f64N/A
lower-+.f64N/A
lower--.f6454.9
Applied rewrites54.9%
Taylor expanded in b around 0
Applied rewrites37.5%
Applied rewrites40.4%
Final simplification40.4%
herbie shell --seed 2024235
(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)))))