
(FPCore (F B x) :precision binary64 (+ (- (* x (/ 1.0 (tan B)))) (* (/ F (sin B)) (pow (+ (+ (* F F) 2.0) (* 2.0 x)) (- (/ 1.0 2.0))))))
double code(double F, double B, double x) {
return -(x * (1.0 / tan(B))) + ((F / sin(B)) * pow((((F * F) + 2.0) + (2.0 * x)), -(1.0 / 2.0)));
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
code = -(x * (1.0d0 / tan(b))) + ((f / sin(b)) * ((((f * f) + 2.0d0) + (2.0d0 * x)) ** -(1.0d0 / 2.0d0)))
end function
public static double code(double F, double B, double x) {
return -(x * (1.0 / Math.tan(B))) + ((F / Math.sin(B)) * Math.pow((((F * F) + 2.0) + (2.0 * x)), -(1.0 / 2.0)));
}
def code(F, B, x): return -(x * (1.0 / math.tan(B))) + ((F / math.sin(B)) * math.pow((((F * F) + 2.0) + (2.0 * x)), -(1.0 / 2.0)))
function code(F, B, x) return Float64(Float64(-Float64(x * Float64(1.0 / tan(B)))) + Float64(Float64(F / sin(B)) * (Float64(Float64(Float64(F * F) + 2.0) + Float64(2.0 * x)) ^ Float64(-Float64(1.0 / 2.0))))) end
function tmp = code(F, B, x) tmp = -(x * (1.0 / tan(B))) + ((F / sin(B)) * ((((F * F) + 2.0) + (2.0 * x)) ^ -(1.0 / 2.0))); end
code[F_, B_, x_] := N[((-N[(x * N[(1.0 / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]) + N[(N[(F / N[Sin[B], $MachinePrecision]), $MachinePrecision] * N[Power[N[(N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision] + N[(2.0 * x), $MachinePrecision]), $MachinePrecision], (-N[(1.0 / 2.0), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(-x \cdot \frac{1}{\tan B}\right) + \frac{F}{\sin B} \cdot {\left(\left(F \cdot F + 2\right) + 2 \cdot x\right)}^{\left(-\frac{1}{2}\right)}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 16 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (F B x) :precision binary64 (+ (- (* x (/ 1.0 (tan B)))) (* (/ F (sin B)) (pow (+ (+ (* F F) 2.0) (* 2.0 x)) (- (/ 1.0 2.0))))))
double code(double F, double B, double x) {
return -(x * (1.0 / tan(B))) + ((F / sin(B)) * pow((((F * F) + 2.0) + (2.0 * x)), -(1.0 / 2.0)));
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
code = -(x * (1.0d0 / tan(b))) + ((f / sin(b)) * ((((f * f) + 2.0d0) + (2.0d0 * x)) ** -(1.0d0 / 2.0d0)))
end function
public static double code(double F, double B, double x) {
return -(x * (1.0 / Math.tan(B))) + ((F / Math.sin(B)) * Math.pow((((F * F) + 2.0) + (2.0 * x)), -(1.0 / 2.0)));
}
def code(F, B, x): return -(x * (1.0 / math.tan(B))) + ((F / math.sin(B)) * math.pow((((F * F) + 2.0) + (2.0 * x)), -(1.0 / 2.0)))
function code(F, B, x) return Float64(Float64(-Float64(x * Float64(1.0 / tan(B)))) + Float64(Float64(F / sin(B)) * (Float64(Float64(Float64(F * F) + 2.0) + Float64(2.0 * x)) ^ Float64(-Float64(1.0 / 2.0))))) end
function tmp = code(F, B, x) tmp = -(x * (1.0 / tan(B))) + ((F / sin(B)) * ((((F * F) + 2.0) + (2.0 * x)) ^ -(1.0 / 2.0))); end
code[F_, B_, x_] := N[((-N[(x * N[(1.0 / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]) + N[(N[(F / N[Sin[B], $MachinePrecision]), $MachinePrecision] * N[Power[N[(N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision] + N[(2.0 * x), $MachinePrecision]), $MachinePrecision], (-N[(1.0 / 2.0), $MachinePrecision])], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\left(-x \cdot \frac{1}{\tan B}\right) + \frac{F}{\sin B} \cdot {\left(\left(F \cdot F + 2\right) + 2 \cdot x\right)}^{\left(-\frac{1}{2}\right)}
\end{array}
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -3e+27)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 82000000.0)
(fma
(/ F (sin B))
(pow (fma x 2.0 (fma F F 2.0)) -0.5)
(/ (- x) (tan B)))
(- (/ 1.0 (sin B)) t_0)))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -3e+27) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 82000000.0) {
tmp = fma((F / sin(B)), pow(fma(x, 2.0, fma(F, F, 2.0)), -0.5), (-x / tan(B)));
} else {
tmp = (1.0 / sin(B)) - t_0;
}
return tmp;
}
function code(F, B, x) t_0 = Float64(x / tan(B)) tmp = 0.0 if (F <= -3e+27) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 82000000.0) tmp = fma(Float64(F / sin(B)), (fma(x, 2.0, fma(F, F, 2.0)) ^ -0.5), Float64(Float64(-x) / tan(B))); else tmp = Float64(Float64(1.0 / sin(B)) - t_0); end return tmp end
code[F_, B_, x_] := Block[{t$95$0 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -3e+27], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 82000000.0], N[(N[(F / N[Sin[B], $MachinePrecision]), $MachinePrecision] * N[Power[N[(x * 2.0 + N[(F * F + 2.0), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision] + N[((-x) / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -3 \cdot 10^{+27}:\\
\;\;\;\;\frac{-1}{\sin B} - t_0\\
\mathbf{elif}\;F \leq 82000000:\\
\;\;\;\;\mathsf{fma}\left(\frac{F}{\sin B}, {\left(\mathsf{fma}\left(x, 2, \mathsf{fma}\left(F, F, 2\right)\right)\right)}^{-0.5}, \frac{-x}{\tan B}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t_0\\
\end{array}
\end{array}
if F < -2.99999999999999976e27Initial program 52.6%
+-commutative52.6%
unsub-neg52.6%
associate-*l/60.4%
associate-*r/60.5%
*-commutative60.5%
Simplified60.5%
Taylor expanded in x around 0 60.5%
associate-*l/60.5%
*-lft-identity60.5%
unpow260.5%
fma-udef60.5%
Simplified60.5%
Taylor expanded in F around -inf 99.7%
if -2.99999999999999976e27 < F < 8.2e7Initial program 99.5%
+-commutative99.5%
fma-def99.5%
+-commutative99.5%
*-commutative99.5%
fma-def99.5%
fma-def99.5%
metadata-eval99.5%
metadata-eval99.5%
distribute-lft-neg-in99.5%
associate-*r/99.6%
*-rgt-identity99.6%
Simplified99.6%
if 8.2e7 < F Initial program 54.9%
+-commutative54.9%
unsub-neg54.9%
associate-*l/66.8%
associate-*r/66.8%
*-commutative66.8%
Simplified66.9%
Taylor expanded in x around 0 66.8%
associate-*l/66.9%
*-lft-identity66.9%
unpow266.9%
fma-udef66.9%
Simplified66.9%
Taylor expanded in F around inf 99.8%
Final simplification99.6%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -3e+27)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 8000000.0)
(+
(* x (/ -1.0 (tan B)))
(* (/ F (sin B)) (/ 1.0 (sqrt (fma F F (fma 2.0 x 2.0))))))
(- (/ 1.0 (sin B)) t_0)))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -3e+27) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 8000000.0) {
tmp = (x * (-1.0 / tan(B))) + ((F / sin(B)) * (1.0 / sqrt(fma(F, F, fma(2.0, x, 2.0)))));
} else {
tmp = (1.0 / sin(B)) - t_0;
}
return tmp;
}
function code(F, B, x) t_0 = Float64(x / tan(B)) tmp = 0.0 if (F <= -3e+27) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 8000000.0) tmp = Float64(Float64(x * Float64(-1.0 / tan(B))) + Float64(Float64(F / sin(B)) * Float64(1.0 / sqrt(fma(F, F, fma(2.0, x, 2.0)))))); else tmp = Float64(Float64(1.0 / sin(B)) - t_0); end return tmp end
code[F_, B_, x_] := Block[{t$95$0 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -3e+27], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 8000000.0], N[(N[(x * N[(-1.0 / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(F / N[Sin[B], $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[Sqrt[N[(F * F + N[(2.0 * x + 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -3 \cdot 10^{+27}:\\
\;\;\;\;\frac{-1}{\sin B} - t_0\\
\mathbf{elif}\;F \leq 8000000:\\
\;\;\;\;x \cdot \frac{-1}{\tan B} + \frac{F}{\sin B} \cdot \frac{1}{\sqrt{\mathsf{fma}\left(F, F, \mathsf{fma}\left(2, x, 2\right)\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t_0\\
\end{array}
\end{array}
if F < -2.99999999999999976e27Initial program 52.6%
+-commutative52.6%
unsub-neg52.6%
associate-*l/60.4%
associate-*r/60.5%
*-commutative60.5%
Simplified60.5%
Taylor expanded in x around 0 60.5%
associate-*l/60.5%
*-lft-identity60.5%
unpow260.5%
fma-udef60.5%
Simplified60.5%
Taylor expanded in F around -inf 99.7%
if -2.99999999999999976e27 < F < 8e6Initial program 99.5%
add-sqr-sqrt99.5%
unpow-prod-down99.5%
+-commutative99.5%
fma-def99.5%
fma-def99.5%
metadata-eval99.5%
metadata-eval99.5%
+-commutative99.5%
fma-def99.5%
fma-def99.5%
metadata-eval99.5%
metadata-eval99.5%
Applied egg-rr99.5%
pow-sqr99.5%
metadata-eval99.5%
unpow-199.5%
fma-udef99.5%
fma-udef99.5%
unpow299.5%
+-commutative99.5%
associate-+r+99.5%
+-commutative99.5%
+-commutative99.5%
unpow299.5%
fma-def99.5%
+-commutative99.5%
fma-def99.5%
Simplified99.5%
if 8e6 < F Initial program 54.9%
+-commutative54.9%
unsub-neg54.9%
associate-*l/66.8%
associate-*r/66.8%
*-commutative66.8%
Simplified66.9%
Taylor expanded in x around 0 66.8%
associate-*l/66.9%
*-lft-identity66.9%
unpow266.9%
fma-udef66.9%
Simplified66.9%
Taylor expanded in F around inf 99.8%
Final simplification99.6%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -400000000.0)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 102000000.0)
(- (* F (/ (sqrt (/ 1.0 (fma F F 2.0))) (sin B))) t_0)
(- (/ 1.0 (sin B)) t_0)))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -400000000.0) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 102000000.0) {
tmp = (F * (sqrt((1.0 / fma(F, F, 2.0))) / sin(B))) - t_0;
} else {
tmp = (1.0 / sin(B)) - t_0;
}
return tmp;
}
function code(F, B, x) t_0 = Float64(x / tan(B)) tmp = 0.0 if (F <= -400000000.0) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 102000000.0) tmp = Float64(Float64(F * Float64(sqrt(Float64(1.0 / fma(F, F, 2.0))) / sin(B))) - t_0); else tmp = Float64(Float64(1.0 / sin(B)) - t_0); end return tmp end
code[F_, B_, x_] := Block[{t$95$0 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -400000000.0], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 102000000.0], N[(N[(F * N[(N[Sqrt[N[(1.0 / N[(F * F + 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -400000000:\\
\;\;\;\;\frac{-1}{\sin B} - t_0\\
\mathbf{elif}\;F \leq 102000000:\\
\;\;\;\;F \cdot \frac{\sqrt{\frac{1}{\mathsf{fma}\left(F, F, 2\right)}}}{\sin B} - t_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t_0\\
\end{array}
\end{array}
if F < -4e8Initial program 54.6%
+-commutative54.6%
unsub-neg54.6%
associate-*l/62.2%
associate-*r/62.2%
*-commutative62.2%
Simplified62.2%
Taylor expanded in x around 0 62.2%
associate-*l/62.2%
*-lft-identity62.2%
unpow262.2%
fma-udef62.2%
Simplified62.2%
Taylor expanded in F around -inf 99.7%
if -4e8 < F < 1.02e8Initial program 99.5%
+-commutative99.5%
unsub-neg99.5%
associate-*l/99.4%
associate-*r/99.4%
*-commutative99.4%
Simplified99.5%
Taylor expanded in x around 0 99.4%
associate-*l/99.5%
*-lft-identity99.5%
unpow299.5%
fma-udef99.5%
Simplified99.5%
if 1.02e8 < F Initial program 54.9%
+-commutative54.9%
unsub-neg54.9%
associate-*l/66.8%
associate-*r/66.8%
*-commutative66.8%
Simplified66.9%
Taylor expanded in x around 0 66.8%
associate-*l/66.9%
*-lft-identity66.9%
unpow266.9%
fma-udef66.9%
Simplified66.9%
Taylor expanded in F around inf 99.8%
Final simplification99.6%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -3.5e+27)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 128000000.0)
(+
(* x (/ -1.0 (tan B)))
(* (/ F (sin B)) (pow (+ (+ 2.0 (* F F)) (* x 2.0)) -0.5)))
(- (/ 1.0 (sin B)) t_0)))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -3.5e+27) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 128000000.0) {
tmp = (x * (-1.0 / tan(B))) + ((F / sin(B)) * pow(((2.0 + (F * F)) + (x * 2.0)), -0.5));
} else {
tmp = (1.0 / sin(B)) - t_0;
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: tmp
t_0 = x / tan(b)
if (f <= (-3.5d+27)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 128000000.0d0) then
tmp = (x * ((-1.0d0) / tan(b))) + ((f / sin(b)) * (((2.0d0 + (f * f)) + (x * 2.0d0)) ** (-0.5d0)))
else
tmp = (1.0d0 / sin(b)) - t_0
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double t_0 = x / Math.tan(B);
double tmp;
if (F <= -3.5e+27) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 128000000.0) {
tmp = (x * (-1.0 / Math.tan(B))) + ((F / Math.sin(B)) * Math.pow(((2.0 + (F * F)) + (x * 2.0)), -0.5));
} else {
tmp = (1.0 / Math.sin(B)) - t_0;
}
return tmp;
}
def code(F, B, x): t_0 = x / math.tan(B) tmp = 0 if F <= -3.5e+27: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 128000000.0: tmp = (x * (-1.0 / math.tan(B))) + ((F / math.sin(B)) * math.pow(((2.0 + (F * F)) + (x * 2.0)), -0.5)) else: tmp = (1.0 / math.sin(B)) - t_0 return tmp
function code(F, B, x) t_0 = Float64(x / tan(B)) tmp = 0.0 if (F <= -3.5e+27) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 128000000.0) tmp = Float64(Float64(x * Float64(-1.0 / tan(B))) + Float64(Float64(F / sin(B)) * (Float64(Float64(2.0 + Float64(F * F)) + Float64(x * 2.0)) ^ -0.5))); else tmp = Float64(Float64(1.0 / sin(B)) - t_0); end return tmp end
function tmp_2 = code(F, B, x) t_0 = x / tan(B); tmp = 0.0; if (F <= -3.5e+27) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 128000000.0) tmp = (x * (-1.0 / tan(B))) + ((F / sin(B)) * (((2.0 + (F * F)) + (x * 2.0)) ^ -0.5)); else tmp = (1.0 / sin(B)) - t_0; end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -3.5e+27], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 128000000.0], N[(N[(x * N[(-1.0 / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(F / N[Sin[B], $MachinePrecision]), $MachinePrecision] * N[Power[N[(N[(2.0 + N[(F * F), $MachinePrecision]), $MachinePrecision] + N[(x * 2.0), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -3.5 \cdot 10^{+27}:\\
\;\;\;\;\frac{-1}{\sin B} - t_0\\
\mathbf{elif}\;F \leq 128000000:\\
\;\;\;\;x \cdot \frac{-1}{\tan B} + \frac{F}{\sin B} \cdot {\left(\left(2 + F \cdot F\right) + x \cdot 2\right)}^{-0.5}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t_0\\
\end{array}
\end{array}
if F < -3.5000000000000002e27Initial program 52.6%
+-commutative52.6%
unsub-neg52.6%
associate-*l/60.4%
associate-*r/60.5%
*-commutative60.5%
Simplified60.5%
Taylor expanded in x around 0 60.5%
associate-*l/60.5%
*-lft-identity60.5%
unpow260.5%
fma-udef60.5%
Simplified60.5%
Taylor expanded in F around -inf 99.7%
if -3.5000000000000002e27 < F < 1.28e8Initial program 99.5%
if 1.28e8 < F Initial program 54.9%
+-commutative54.9%
unsub-neg54.9%
associate-*l/66.8%
associate-*r/66.8%
*-commutative66.8%
Simplified66.9%
Taylor expanded in x around 0 66.8%
associate-*l/66.9%
*-lft-identity66.9%
unpow266.9%
fma-udef66.9%
Simplified66.9%
Taylor expanded in F around inf 99.8%
Final simplification99.6%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -19000000.0)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 1.4)
(- (* F (/ (sqrt 0.5) (sin B))) t_0)
(- (/ 1.0 (sin B)) t_0)))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -19000000.0) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 1.4) {
tmp = (F * (sqrt(0.5) / sin(B))) - t_0;
} else {
tmp = (1.0 / sin(B)) - t_0;
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: tmp
t_0 = x / tan(b)
if (f <= (-19000000.0d0)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 1.4d0) then
tmp = (f * (sqrt(0.5d0) / sin(b))) - t_0
else
tmp = (1.0d0 / sin(b)) - t_0
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double t_0 = x / Math.tan(B);
double tmp;
if (F <= -19000000.0) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 1.4) {
tmp = (F * (Math.sqrt(0.5) / Math.sin(B))) - t_0;
} else {
tmp = (1.0 / Math.sin(B)) - t_0;
}
return tmp;
}
def code(F, B, x): t_0 = x / math.tan(B) tmp = 0 if F <= -19000000.0: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 1.4: tmp = (F * (math.sqrt(0.5) / math.sin(B))) - t_0 else: tmp = (1.0 / math.sin(B)) - t_0 return tmp
function code(F, B, x) t_0 = Float64(x / tan(B)) tmp = 0.0 if (F <= -19000000.0) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 1.4) tmp = Float64(Float64(F * Float64(sqrt(0.5) / sin(B))) - t_0); else tmp = Float64(Float64(1.0 / sin(B)) - t_0); end return tmp end
function tmp_2 = code(F, B, x) t_0 = x / tan(B); tmp = 0.0; if (F <= -19000000.0) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 1.4) tmp = (F * (sqrt(0.5) / sin(B))) - t_0; else tmp = (1.0 / sin(B)) - t_0; end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -19000000.0], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 1.4], N[(N[(F * N[(N[Sqrt[0.5], $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -19000000:\\
\;\;\;\;\frac{-1}{\sin B} - t_0\\
\mathbf{elif}\;F \leq 1.4:\\
\;\;\;\;F \cdot \frac{\sqrt{0.5}}{\sin B} - t_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t_0\\
\end{array}
\end{array}
if F < -1.9e7Initial program 54.6%
+-commutative54.6%
unsub-neg54.6%
associate-*l/62.2%
associate-*r/62.2%
*-commutative62.2%
Simplified62.2%
Taylor expanded in x around 0 62.2%
associate-*l/62.2%
*-lft-identity62.2%
unpow262.2%
fma-udef62.2%
Simplified62.2%
Taylor expanded in F around -inf 99.7%
if -1.9e7 < F < 1.3999999999999999Initial program 99.4%
+-commutative99.4%
unsub-neg99.4%
associate-*l/99.4%
associate-*r/99.4%
*-commutative99.4%
Simplified99.5%
Taylor expanded in x around 0 99.5%
associate-*l/99.5%
*-lft-identity99.5%
unpow299.5%
fma-udef99.5%
Simplified99.5%
Taylor expanded in F around 0 99.5%
if 1.3999999999999999 < F Initial program 55.6%
+-commutative55.6%
unsub-neg55.6%
associate-*l/67.3%
associate-*r/67.3%
*-commutative67.3%
Simplified67.4%
Taylor expanded in x around 0 67.3%
associate-*l/67.4%
*-lft-identity67.4%
unpow267.4%
fma-udef67.4%
Simplified67.4%
Taylor expanded in F around inf 98.7%
Final simplification99.4%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -19000000.0)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 1.4)
(- (/ (* F (sqrt 0.5)) (sin B)) t_0)
(- (/ 1.0 (sin B)) t_0)))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -19000000.0) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 1.4) {
tmp = ((F * sqrt(0.5)) / sin(B)) - t_0;
} else {
tmp = (1.0 / sin(B)) - t_0;
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: tmp
t_0 = x / tan(b)
if (f <= (-19000000.0d0)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 1.4d0) then
tmp = ((f * sqrt(0.5d0)) / sin(b)) - t_0
else
tmp = (1.0d0 / sin(b)) - t_0
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double t_0 = x / Math.tan(B);
double tmp;
if (F <= -19000000.0) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 1.4) {
tmp = ((F * Math.sqrt(0.5)) / Math.sin(B)) - t_0;
} else {
tmp = (1.0 / Math.sin(B)) - t_0;
}
return tmp;
}
def code(F, B, x): t_0 = x / math.tan(B) tmp = 0 if F <= -19000000.0: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 1.4: tmp = ((F * math.sqrt(0.5)) / math.sin(B)) - t_0 else: tmp = (1.0 / math.sin(B)) - t_0 return tmp
function code(F, B, x) t_0 = Float64(x / tan(B)) tmp = 0.0 if (F <= -19000000.0) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 1.4) tmp = Float64(Float64(Float64(F * sqrt(0.5)) / sin(B)) - t_0); else tmp = Float64(Float64(1.0 / sin(B)) - t_0); end return tmp end
function tmp_2 = code(F, B, x) t_0 = x / tan(B); tmp = 0.0; if (F <= -19000000.0) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 1.4) tmp = ((F * sqrt(0.5)) / sin(B)) - t_0; else tmp = (1.0 / sin(B)) - t_0; end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -19000000.0], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 1.4], N[(N[(N[(F * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -19000000:\\
\;\;\;\;\frac{-1}{\sin B} - t_0\\
\mathbf{elif}\;F \leq 1.4:\\
\;\;\;\;\frac{F \cdot \sqrt{0.5}}{\sin B} - t_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t_0\\
\end{array}
\end{array}
if F < -1.9e7Initial program 54.6%
+-commutative54.6%
unsub-neg54.6%
associate-*l/62.2%
associate-*r/62.2%
*-commutative62.2%
Simplified62.2%
Taylor expanded in x around 0 62.2%
associate-*l/62.2%
*-lft-identity62.2%
unpow262.2%
fma-udef62.2%
Simplified62.2%
Taylor expanded in F around -inf 99.7%
if -1.9e7 < F < 1.3999999999999999Initial program 99.4%
+-commutative99.4%
unsub-neg99.4%
associate-*l/99.4%
associate-*r/99.4%
*-commutative99.4%
Simplified99.5%
Taylor expanded in x around 0 99.5%
associate-*l/99.5%
*-lft-identity99.5%
unpow299.5%
fma-udef99.5%
Simplified99.5%
Taylor expanded in F around 0 99.5%
if 1.3999999999999999 < F Initial program 55.6%
+-commutative55.6%
unsub-neg55.6%
associate-*l/67.3%
associate-*r/67.3%
*-commutative67.3%
Simplified67.4%
Taylor expanded in x around 0 67.3%
associate-*l/67.4%
*-lft-identity67.4%
unpow267.4%
fma-udef67.4%
Simplified67.4%
Taylor expanded in F around inf 98.7%
Final simplification99.4%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -1.5e-45)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 8e-78)
(/ (- x) (tan B))
(if (<= F 1.05e-6)
(/ (- (* F (sqrt 0.5)) x) B)
(- (/ 1.0 (sin B)) t_0))))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -1.5e-45) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 8e-78) {
tmp = -x / tan(B);
} else if (F <= 1.05e-6) {
tmp = ((F * sqrt(0.5)) - x) / B;
} else {
tmp = (1.0 / sin(B)) - t_0;
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: tmp
t_0 = x / tan(b)
if (f <= (-1.5d-45)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 8d-78) then
tmp = -x / tan(b)
else if (f <= 1.05d-6) then
tmp = ((f * sqrt(0.5d0)) - x) / b
else
tmp = (1.0d0 / sin(b)) - t_0
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double t_0 = x / Math.tan(B);
double tmp;
if (F <= -1.5e-45) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 8e-78) {
tmp = -x / Math.tan(B);
} else if (F <= 1.05e-6) {
tmp = ((F * Math.sqrt(0.5)) - x) / B;
} else {
tmp = (1.0 / Math.sin(B)) - t_0;
}
return tmp;
}
def code(F, B, x): t_0 = x / math.tan(B) tmp = 0 if F <= -1.5e-45: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 8e-78: tmp = -x / math.tan(B) elif F <= 1.05e-6: tmp = ((F * math.sqrt(0.5)) - x) / B else: tmp = (1.0 / math.sin(B)) - t_0 return tmp
function code(F, B, x) t_0 = Float64(x / tan(B)) tmp = 0.0 if (F <= -1.5e-45) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 8e-78) tmp = Float64(Float64(-x) / tan(B)); elseif (F <= 1.05e-6) tmp = Float64(Float64(Float64(F * sqrt(0.5)) - x) / B); else tmp = Float64(Float64(1.0 / sin(B)) - t_0); end return tmp end
function tmp_2 = code(F, B, x) t_0 = x / tan(B); tmp = 0.0; if (F <= -1.5e-45) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 8e-78) tmp = -x / tan(B); elseif (F <= 1.05e-6) tmp = ((F * sqrt(0.5)) - x) / B; else tmp = (1.0 / sin(B)) - t_0; end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -1.5e-45], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 8e-78], N[((-x) / N[Tan[B], $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 1.05e-6], N[(N[(N[(F * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -1.5 \cdot 10^{-45}:\\
\;\;\;\;\frac{-1}{\sin B} - t_0\\
\mathbf{elif}\;F \leq 8 \cdot 10^{-78}:\\
\;\;\;\;\frac{-x}{\tan B}\\
\mathbf{elif}\;F \leq 1.05 \cdot 10^{-6}:\\
\;\;\;\;\frac{F \cdot \sqrt{0.5} - x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t_0\\
\end{array}
\end{array}
if F < -1.50000000000000005e-45Initial program 59.8%
+-commutative59.8%
unsub-neg59.8%
associate-*l/66.5%
associate-*r/66.5%
*-commutative66.5%
Simplified66.5%
Taylor expanded in x around 0 66.5%
associate-*l/66.5%
*-lft-identity66.5%
unpow266.5%
fma-udef66.5%
Simplified66.5%
Taylor expanded in F around -inf 95.0%
if -1.50000000000000005e-45 < F < 7.99999999999999999e-78Initial program 99.5%
+-commutative99.5%
fma-def99.5%
+-commutative99.5%
*-commutative99.5%
fma-def99.5%
fma-def99.5%
metadata-eval99.5%
metadata-eval99.5%
distribute-lft-neg-in99.5%
associate-*r/99.6%
*-rgt-identity99.6%
Simplified99.6%
Taylor expanded in F around 0 74.8%
mul-1-neg74.8%
*-commutative74.8%
associate-*l/74.8%
*-commutative74.8%
Simplified74.8%
associate-*r/74.8%
clear-num74.6%
Applied egg-rr74.6%
associate-/r*74.6%
tan-quot74.7%
clear-num74.9%
expm1-log1p-u51.2%
expm1-udef30.8%
Applied egg-rr30.8%
expm1-def51.2%
expm1-log1p74.9%
Simplified74.9%
if 7.99999999999999999e-78 < F < 1.0499999999999999e-6Initial program 99.1%
+-commutative99.1%
unsub-neg99.1%
associate-*l/99.1%
associate-*r/98.8%
*-commutative98.8%
Simplified98.8%
Taylor expanded in x around 0 99.1%
associate-*l/98.8%
*-lft-identity98.8%
unpow298.8%
fma-udef98.8%
Simplified98.8%
Taylor expanded in F around 0 98.8%
Taylor expanded in B around 0 74.8%
if 1.0499999999999999e-6 < F Initial program 55.6%
+-commutative55.6%
unsub-neg55.6%
associate-*l/67.3%
associate-*r/67.3%
*-commutative67.3%
Simplified67.4%
Taylor expanded in x around 0 67.3%
associate-*l/67.4%
*-lft-identity67.4%
unpow267.4%
fma-udef67.4%
Simplified67.4%
Taylor expanded in F around inf 98.7%
Final simplification87.0%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -9e-14)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 0.11) (- (* F (/ (sqrt 0.5) B)) t_0) (- (/ 1.0 (sin B)) t_0)))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -9e-14) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 0.11) {
tmp = (F * (sqrt(0.5) / B)) - t_0;
} else {
tmp = (1.0 / sin(B)) - t_0;
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: tmp
t_0 = x / tan(b)
if (f <= (-9d-14)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 0.11d0) then
tmp = (f * (sqrt(0.5d0) / b)) - t_0
else
tmp = (1.0d0 / sin(b)) - t_0
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double t_0 = x / Math.tan(B);
double tmp;
if (F <= -9e-14) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 0.11) {
tmp = (F * (Math.sqrt(0.5) / B)) - t_0;
} else {
tmp = (1.0 / Math.sin(B)) - t_0;
}
return tmp;
}
def code(F, B, x): t_0 = x / math.tan(B) tmp = 0 if F <= -9e-14: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 0.11: tmp = (F * (math.sqrt(0.5) / B)) - t_0 else: tmp = (1.0 / math.sin(B)) - t_0 return tmp
function code(F, B, x) t_0 = Float64(x / tan(B)) tmp = 0.0 if (F <= -9e-14) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 0.11) tmp = Float64(Float64(F * Float64(sqrt(0.5) / B)) - t_0); else tmp = Float64(Float64(1.0 / sin(B)) - t_0); end return tmp end
function tmp_2 = code(F, B, x) t_0 = x / tan(B); tmp = 0.0; if (F <= -9e-14) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 0.11) tmp = (F * (sqrt(0.5) / B)) - t_0; else tmp = (1.0 / sin(B)) - t_0; end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -9e-14], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 0.11], N[(N[(F * N[(N[Sqrt[0.5], $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -9 \cdot 10^{-14}:\\
\;\;\;\;\frac{-1}{\sin B} - t_0\\
\mathbf{elif}\;F \leq 0.11:\\
\;\;\;\;F \cdot \frac{\sqrt{0.5}}{B} - t_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t_0\\
\end{array}
\end{array}
if F < -8.9999999999999995e-14Initial program 55.9%
+-commutative55.9%
unsub-neg55.9%
associate-*l/63.2%
associate-*r/63.2%
*-commutative63.2%
Simplified63.2%
Taylor expanded in x around 0 63.2%
associate-*l/63.2%
*-lft-identity63.2%
unpow263.2%
fma-udef63.2%
Simplified63.2%
Taylor expanded in F around -inf 98.4%
if -8.9999999999999995e-14 < F < 0.110000000000000001Initial program 99.5%
+-commutative99.5%
unsub-neg99.5%
associate-*l/99.4%
associate-*r/99.4%
*-commutative99.4%
Simplified99.5%
Taylor expanded in x around 0 99.5%
associate-*l/99.5%
*-lft-identity99.5%
unpow299.5%
fma-udef99.5%
Simplified99.5%
Taylor expanded in F around 0 99.5%
Taylor expanded in B around 0 85.2%
if 0.110000000000000001 < F Initial program 55.6%
+-commutative55.6%
unsub-neg55.6%
associate-*l/67.3%
associate-*r/67.3%
*-commutative67.3%
Simplified67.4%
Taylor expanded in x around 0 67.3%
associate-*l/67.4%
*-lft-identity67.4%
unpow267.4%
fma-udef67.4%
Simplified67.4%
Taylor expanded in F around inf 98.7%
Final simplification92.2%
(FPCore (F B x)
:precision binary64
(if (<= F -4.5e-46)
(- (/ -1.0 (sin B)) (/ x (tan B)))
(if (<= F 5.5e-78)
(/ (- x) (tan B))
(if (<= F 0.47)
(/ (- (* F (sqrt 0.5)) x) B)
(- (/ 1.0 (sin B)) (/ x B))))))
double code(double F, double B, double x) {
double tmp;
if (F <= -4.5e-46) {
tmp = (-1.0 / sin(B)) - (x / tan(B));
} else if (F <= 5.5e-78) {
tmp = -x / tan(B);
} else if (F <= 0.47) {
tmp = ((F * sqrt(0.5)) - x) / B;
} else {
tmp = (1.0 / sin(B)) - (x / B);
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: tmp
if (f <= (-4.5d-46)) then
tmp = ((-1.0d0) / sin(b)) - (x / tan(b))
else if (f <= 5.5d-78) then
tmp = -x / tan(b)
else if (f <= 0.47d0) then
tmp = ((f * sqrt(0.5d0)) - x) / b
else
tmp = (1.0d0 / sin(b)) - (x / b)
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= -4.5e-46) {
tmp = (-1.0 / Math.sin(B)) - (x / Math.tan(B));
} else if (F <= 5.5e-78) {
tmp = -x / Math.tan(B);
} else if (F <= 0.47) {
tmp = ((F * Math.sqrt(0.5)) - x) / B;
} else {
tmp = (1.0 / Math.sin(B)) - (x / B);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -4.5e-46: tmp = (-1.0 / math.sin(B)) - (x / math.tan(B)) elif F <= 5.5e-78: tmp = -x / math.tan(B) elif F <= 0.47: tmp = ((F * math.sqrt(0.5)) - x) / B else: tmp = (1.0 / math.sin(B)) - (x / B) return tmp
function code(F, B, x) tmp = 0.0 if (F <= -4.5e-46) tmp = Float64(Float64(-1.0 / sin(B)) - Float64(x / tan(B))); elseif (F <= 5.5e-78) tmp = Float64(Float64(-x) / tan(B)); elseif (F <= 0.47) tmp = Float64(Float64(Float64(F * sqrt(0.5)) - x) / B); else tmp = Float64(Float64(1.0 / sin(B)) - Float64(x / B)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -4.5e-46) tmp = (-1.0 / sin(B)) - (x / tan(B)); elseif (F <= 5.5e-78) tmp = -x / tan(B); elseif (F <= 0.47) tmp = ((F * sqrt(0.5)) - x) / B; else tmp = (1.0 / sin(B)) - (x / B); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -4.5e-46], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 5.5e-78], N[((-x) / N[Tan[B], $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 0.47], N[(N[(N[(F * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(x / B), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -4.5 \cdot 10^{-46}:\\
\;\;\;\;\frac{-1}{\sin B} - \frac{x}{\tan B}\\
\mathbf{elif}\;F \leq 5.5 \cdot 10^{-78}:\\
\;\;\;\;\frac{-x}{\tan B}\\
\mathbf{elif}\;F \leq 0.47:\\
\;\;\;\;\frac{F \cdot \sqrt{0.5} - x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - \frac{x}{B}\\
\end{array}
\end{array}
if F < -4.50000000000000001e-46Initial program 59.8%
+-commutative59.8%
unsub-neg59.8%
associate-*l/66.5%
associate-*r/66.5%
*-commutative66.5%
Simplified66.5%
Taylor expanded in x around 0 66.5%
associate-*l/66.5%
*-lft-identity66.5%
unpow266.5%
fma-udef66.5%
Simplified66.5%
Taylor expanded in F around -inf 95.0%
if -4.50000000000000001e-46 < F < 5.50000000000000017e-78Initial program 99.5%
+-commutative99.5%
fma-def99.5%
+-commutative99.5%
*-commutative99.5%
fma-def99.5%
fma-def99.5%
metadata-eval99.5%
metadata-eval99.5%
distribute-lft-neg-in99.5%
associate-*r/99.6%
*-rgt-identity99.6%
Simplified99.6%
Taylor expanded in F around 0 74.8%
mul-1-neg74.8%
*-commutative74.8%
associate-*l/74.8%
*-commutative74.8%
Simplified74.8%
associate-*r/74.8%
clear-num74.6%
Applied egg-rr74.6%
associate-/r*74.6%
tan-quot74.7%
clear-num74.9%
expm1-log1p-u51.2%
expm1-udef30.8%
Applied egg-rr30.8%
expm1-def51.2%
expm1-log1p74.9%
Simplified74.9%
if 5.50000000000000017e-78 < F < 0.46999999999999997Initial program 99.1%
+-commutative99.1%
unsub-neg99.1%
associate-*l/99.1%
associate-*r/98.8%
*-commutative98.8%
Simplified98.8%
Taylor expanded in x around 0 99.1%
associate-*l/98.8%
*-lft-identity98.8%
unpow298.8%
fma-udef98.8%
Simplified98.8%
Taylor expanded in F around 0 98.8%
Taylor expanded in B around 0 74.8%
if 0.46999999999999997 < F Initial program 55.6%
Taylor expanded in F around inf 73.4%
Taylor expanded in B around 0 56.1%
Taylor expanded in x around 0 81.3%
mul-1-neg81.3%
+-commutative81.3%
sub-neg81.3%
Simplified81.3%
Final simplification82.6%
(FPCore (F B x) :precision binary64 (if (<= F 4.5e-78) (/ (- x) (tan B)) (if (<= F 0.21) (/ (- (* F (sqrt 0.5)) x) B) (- (/ 1.0 (sin B)) (/ x B)))))
double code(double F, double B, double x) {
double tmp;
if (F <= 4.5e-78) {
tmp = -x / tan(B);
} else if (F <= 0.21) {
tmp = ((F * sqrt(0.5)) - x) / B;
} else {
tmp = (1.0 / sin(B)) - (x / B);
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: tmp
if (f <= 4.5d-78) then
tmp = -x / tan(b)
else if (f <= 0.21d0) then
tmp = ((f * sqrt(0.5d0)) - x) / b
else
tmp = (1.0d0 / sin(b)) - (x / b)
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= 4.5e-78) {
tmp = -x / Math.tan(B);
} else if (F <= 0.21) {
tmp = ((F * Math.sqrt(0.5)) - x) / B;
} else {
tmp = (1.0 / Math.sin(B)) - (x / B);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= 4.5e-78: tmp = -x / math.tan(B) elif F <= 0.21: tmp = ((F * math.sqrt(0.5)) - x) / B else: tmp = (1.0 / math.sin(B)) - (x / B) return tmp
function code(F, B, x) tmp = 0.0 if (F <= 4.5e-78) tmp = Float64(Float64(-x) / tan(B)); elseif (F <= 0.21) tmp = Float64(Float64(Float64(F * sqrt(0.5)) - x) / B); else tmp = Float64(Float64(1.0 / sin(B)) - Float64(x / B)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= 4.5e-78) tmp = -x / tan(B); elseif (F <= 0.21) tmp = ((F * sqrt(0.5)) - x) / B; else tmp = (1.0 / sin(B)) - (x / B); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, 4.5e-78], N[((-x) / N[Tan[B], $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 0.21], N[(N[(N[(F * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(x / B), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq 4.5 \cdot 10^{-78}:\\
\;\;\;\;\frac{-x}{\tan B}\\
\mathbf{elif}\;F \leq 0.21:\\
\;\;\;\;\frac{F \cdot \sqrt{0.5} - x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - \frac{x}{B}\\
\end{array}
\end{array}
if F < 4.5e-78Initial program 82.3%
+-commutative82.3%
fma-def82.3%
+-commutative82.3%
*-commutative82.3%
fma-def82.3%
fma-def82.3%
metadata-eval82.3%
metadata-eval82.3%
distribute-lft-neg-in82.3%
associate-*r/82.4%
*-rgt-identity82.4%
Simplified82.4%
Taylor expanded in F around 0 62.0%
mul-1-neg62.0%
*-commutative62.0%
associate-*l/62.0%
*-commutative62.0%
Simplified62.0%
associate-*r/62.0%
clear-num61.9%
Applied egg-rr61.9%
associate-/r*61.8%
tan-quot61.9%
clear-num62.0%
expm1-log1p-u38.9%
expm1-udef27.1%
Applied egg-rr27.1%
expm1-def38.9%
expm1-log1p62.0%
Simplified62.0%
if 4.5e-78 < F < 0.209999999999999992Initial program 99.1%
+-commutative99.1%
unsub-neg99.1%
associate-*l/99.1%
associate-*r/98.8%
*-commutative98.8%
Simplified98.8%
Taylor expanded in x around 0 99.1%
associate-*l/98.8%
*-lft-identity98.8%
unpow298.8%
fma-udef98.8%
Simplified98.8%
Taylor expanded in F around 0 98.8%
Taylor expanded in B around 0 74.8%
if 0.209999999999999992 < F Initial program 55.6%
Taylor expanded in F around inf 73.4%
Taylor expanded in B around 0 56.1%
Taylor expanded in x around 0 81.3%
mul-1-neg81.3%
+-commutative81.3%
sub-neg81.3%
Simplified81.3%
Final simplification67.5%
(FPCore (F B x) :precision binary64 (if (<= F 8e-49) (/ (- x) (tan B)) (- (/ 1.0 (sin B)) (/ x B))))
double code(double F, double B, double x) {
double tmp;
if (F <= 8e-49) {
tmp = -x / tan(B);
} else {
tmp = (1.0 / sin(B)) - (x / B);
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: tmp
if (f <= 8d-49) then
tmp = -x / tan(b)
else
tmp = (1.0d0 / sin(b)) - (x / b)
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= 8e-49) {
tmp = -x / Math.tan(B);
} else {
tmp = (1.0 / Math.sin(B)) - (x / B);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= 8e-49: tmp = -x / math.tan(B) else: tmp = (1.0 / math.sin(B)) - (x / B) return tmp
function code(F, B, x) tmp = 0.0 if (F <= 8e-49) tmp = Float64(Float64(-x) / tan(B)); else tmp = Float64(Float64(1.0 / sin(B)) - Float64(x / B)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= 8e-49) tmp = -x / tan(B); else tmp = (1.0 / sin(B)) - (x / B); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, 8e-49], N[((-x) / N[Tan[B], $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(x / B), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq 8 \cdot 10^{-49}:\\
\;\;\;\;\frac{-x}{\tan B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - \frac{x}{B}\\
\end{array}
\end{array}
if F < 7.99999999999999949e-49Initial program 82.8%
+-commutative82.8%
fma-def82.8%
+-commutative82.8%
*-commutative82.8%
fma-def82.8%
fma-def82.8%
metadata-eval82.8%
metadata-eval82.8%
distribute-lft-neg-in82.8%
associate-*r/82.8%
*-rgt-identity82.8%
Simplified82.8%
Taylor expanded in F around 0 61.4%
mul-1-neg61.4%
*-commutative61.4%
associate-*l/61.4%
*-commutative61.4%
Simplified61.4%
associate-*r/61.4%
clear-num61.3%
Applied egg-rr61.3%
associate-/r*61.3%
tan-quot61.4%
clear-num61.5%
expm1-log1p-u38.8%
expm1-udef27.4%
Applied egg-rr27.4%
expm1-def38.8%
expm1-log1p61.5%
Simplified61.5%
if 7.99999999999999949e-49 < F Initial program 59.9%
Taylor expanded in F around inf 68.3%
Taylor expanded in B around 0 52.7%
Taylor expanded in x around 0 75.4%
mul-1-neg75.4%
+-commutative75.4%
sub-neg75.4%
Simplified75.4%
Final simplification65.4%
(FPCore (F B x) :precision binary64 (if (<= F 1.65e-45) (/ (- x) (tan B)) (+ (* B 0.16666666666666666) (/ (- 1.0 x) B))))
double code(double F, double B, double x) {
double tmp;
if (F <= 1.65e-45) {
tmp = -x / tan(B);
} else {
tmp = (B * 0.16666666666666666) + ((1.0 - x) / B);
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: tmp
if (f <= 1.65d-45) then
tmp = -x / tan(b)
else
tmp = (b * 0.16666666666666666d0) + ((1.0d0 - x) / b)
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= 1.65e-45) {
tmp = -x / Math.tan(B);
} else {
tmp = (B * 0.16666666666666666) + ((1.0 - x) / B);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= 1.65e-45: tmp = -x / math.tan(B) else: tmp = (B * 0.16666666666666666) + ((1.0 - x) / B) return tmp
function code(F, B, x) tmp = 0.0 if (F <= 1.65e-45) tmp = Float64(Float64(-x) / tan(B)); else tmp = Float64(Float64(B * 0.16666666666666666) + Float64(Float64(1.0 - x) / B)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= 1.65e-45) tmp = -x / tan(B); else tmp = (B * 0.16666666666666666) + ((1.0 - x) / B); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, 1.65e-45], N[((-x) / N[Tan[B], $MachinePrecision]), $MachinePrecision], N[(N[(B * 0.16666666666666666), $MachinePrecision] + N[(N[(1.0 - x), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq 1.65 \cdot 10^{-45}:\\
\;\;\;\;\frac{-x}{\tan B}\\
\mathbf{else}:\\
\;\;\;\;B \cdot 0.16666666666666666 + \frac{1 - x}{B}\\
\end{array}
\end{array}
if F < 1.65e-45Initial program 82.8%
+-commutative82.8%
fma-def82.9%
+-commutative82.9%
*-commutative82.9%
fma-def82.9%
fma-def82.9%
metadata-eval82.9%
metadata-eval82.9%
distribute-lft-neg-in82.9%
associate-*r/82.9%
*-rgt-identity82.9%
Simplified82.9%
Taylor expanded in F around 0 61.1%
mul-1-neg61.1%
*-commutative61.1%
associate-*l/61.1%
*-commutative61.1%
Simplified61.1%
associate-*r/61.1%
clear-num61.0%
Applied egg-rr61.0%
associate-/r*61.0%
tan-quot61.1%
clear-num61.2%
expm1-log1p-u38.6%
expm1-udef27.3%
Applied egg-rr27.3%
expm1-def38.6%
expm1-log1p61.2%
Simplified61.2%
if 1.65e-45 < F Initial program 59.3%
Taylor expanded in F around inf 69.1%
Taylor expanded in B around 0 53.3%
Taylor expanded in B around 0 59.6%
associate--l+59.6%
*-commutative59.6%
div-sub59.6%
Simplified59.6%
Final simplification60.8%
(FPCore (F B x) :precision binary64 (if (<= F 8.2e-78) (- (/ (- x) B) (* B (* x -0.3333333333333333))) (+ (* B 0.16666666666666666) (/ (- 1.0 x) B))))
double code(double F, double B, double x) {
double tmp;
if (F <= 8.2e-78) {
tmp = (-x / B) - (B * (x * -0.3333333333333333));
} else {
tmp = (B * 0.16666666666666666) + ((1.0 - x) / B);
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: tmp
if (f <= 8.2d-78) then
tmp = (-x / b) - (b * (x * (-0.3333333333333333d0)))
else
tmp = (b * 0.16666666666666666d0) + ((1.0d0 - x) / b)
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= 8.2e-78) {
tmp = (-x / B) - (B * (x * -0.3333333333333333));
} else {
tmp = (B * 0.16666666666666666) + ((1.0 - x) / B);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= 8.2e-78: tmp = (-x / B) - (B * (x * -0.3333333333333333)) else: tmp = (B * 0.16666666666666666) + ((1.0 - x) / B) return tmp
function code(F, B, x) tmp = 0.0 if (F <= 8.2e-78) tmp = Float64(Float64(Float64(-x) / B) - Float64(B * Float64(x * -0.3333333333333333))); else tmp = Float64(Float64(B * 0.16666666666666666) + Float64(Float64(1.0 - x) / B)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= 8.2e-78) tmp = (-x / B) - (B * (x * -0.3333333333333333)); else tmp = (B * 0.16666666666666666) + ((1.0 - x) / B); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, 8.2e-78], N[(N[((-x) / B), $MachinePrecision] - N[(B * N[(x * -0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(B * 0.16666666666666666), $MachinePrecision] + N[(N[(1.0 - x), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq 8.2 \cdot 10^{-78}:\\
\;\;\;\;\frac{-x}{B} - B \cdot \left(x \cdot -0.3333333333333333\right)\\
\mathbf{else}:\\
\;\;\;\;B \cdot 0.16666666666666666 + \frac{1 - x}{B}\\
\end{array}
\end{array}
if F < 8.1999999999999996e-78Initial program 82.3%
+-commutative82.3%
fma-def82.3%
+-commutative82.3%
*-commutative82.3%
fma-def82.3%
fma-def82.3%
metadata-eval82.3%
metadata-eval82.3%
distribute-lft-neg-in82.3%
associate-*r/82.4%
*-rgt-identity82.4%
Simplified82.4%
Taylor expanded in F around 0 62.0%
mul-1-neg62.0%
*-commutative62.0%
associate-*l/62.0%
*-commutative62.0%
Simplified62.0%
Taylor expanded in B around 0 33.0%
*-commutative33.0%
distribute-rgt-out--33.0%
metadata-eval33.0%
Simplified33.0%
if 8.1999999999999996e-78 < F Initial program 62.5%
Taylor expanded in F around inf 66.6%
Taylor expanded in B around 0 50.8%
Taylor expanded in B around 0 56.6%
associate--l+56.6%
*-commutative56.6%
div-sub56.7%
Simplified56.7%
Final simplification40.1%
(FPCore (F B x) :precision binary64 (if (<= F 9e-78) (/ (- x) B) (+ (* B 0.16666666666666666) (/ (- 1.0 x) B))))
double code(double F, double B, double x) {
double tmp;
if (F <= 9e-78) {
tmp = -x / B;
} else {
tmp = (B * 0.16666666666666666) + ((1.0 - x) / B);
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: tmp
if (f <= 9d-78) then
tmp = -x / b
else
tmp = (b * 0.16666666666666666d0) + ((1.0d0 - x) / b)
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= 9e-78) {
tmp = -x / B;
} else {
tmp = (B * 0.16666666666666666) + ((1.0 - x) / B);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= 9e-78: tmp = -x / B else: tmp = (B * 0.16666666666666666) + ((1.0 - x) / B) return tmp
function code(F, B, x) tmp = 0.0 if (F <= 9e-78) tmp = Float64(Float64(-x) / B); else tmp = Float64(Float64(B * 0.16666666666666666) + Float64(Float64(1.0 - x) / B)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= 9e-78) tmp = -x / B; else tmp = (B * 0.16666666666666666) + ((1.0 - x) / B); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, 9e-78], N[((-x) / B), $MachinePrecision], N[(N[(B * 0.16666666666666666), $MachinePrecision] + N[(N[(1.0 - x), $MachinePrecision] / B), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq 9 \cdot 10^{-78}:\\
\;\;\;\;\frac{-x}{B}\\
\mathbf{else}:\\
\;\;\;\;B \cdot 0.16666666666666666 + \frac{1 - x}{B}\\
\end{array}
\end{array}
if F < 9e-78Initial program 82.3%
+-commutative82.3%
fma-def82.3%
+-commutative82.3%
*-commutative82.3%
fma-def82.3%
fma-def82.3%
metadata-eval82.3%
metadata-eval82.3%
distribute-lft-neg-in82.3%
associate-*r/82.4%
*-rgt-identity82.4%
Simplified82.4%
Taylor expanded in F around 0 62.0%
mul-1-neg62.0%
*-commutative62.0%
associate-*l/62.0%
*-commutative62.0%
Simplified62.0%
Taylor expanded in B around 0 32.7%
if 9e-78 < F Initial program 62.5%
Taylor expanded in F around inf 66.6%
Taylor expanded in B around 0 50.8%
Taylor expanded in B around 0 56.6%
associate--l+56.6%
*-commutative56.6%
div-sub56.7%
Simplified56.7%
Final simplification39.8%
(FPCore (F B x) :precision binary64 (if (<= F 1.3e-94) (/ (- x) B) (/ (- 1.0 x) B)))
double code(double F, double B, double x) {
double tmp;
if (F <= 1.3e-94) {
tmp = -x / B;
} else {
tmp = (1.0 - x) / B;
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: tmp
if (f <= 1.3d-94) then
tmp = -x / b
else
tmp = (1.0d0 - x) / b
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= 1.3e-94) {
tmp = -x / B;
} else {
tmp = (1.0 - x) / B;
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= 1.3e-94: tmp = -x / B else: tmp = (1.0 - x) / B return tmp
function code(F, B, x) tmp = 0.0 if (F <= 1.3e-94) tmp = Float64(Float64(-x) / B); else tmp = Float64(Float64(1.0 - x) / B); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= 1.3e-94) tmp = -x / B; else tmp = (1.0 - x) / B; end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, 1.3e-94], N[((-x) / B), $MachinePrecision], N[(N[(1.0 - x), $MachinePrecision] / B), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq 1.3 \cdot 10^{-94}:\\
\;\;\;\;\frac{-x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - x}{B}\\
\end{array}
\end{array}
if F < 1.29999999999999997e-94Initial program 81.8%
+-commutative81.8%
fma-def81.8%
+-commutative81.8%
*-commutative81.8%
fma-def81.8%
fma-def81.8%
metadata-eval81.8%
metadata-eval81.8%
distribute-lft-neg-in81.8%
associate-*r/81.9%
*-rgt-identity81.9%
Simplified81.9%
Taylor expanded in F around 0 62.3%
mul-1-neg62.3%
*-commutative62.3%
associate-*l/62.3%
*-commutative62.3%
Simplified62.3%
Taylor expanded in B around 0 33.3%
if 1.29999999999999997e-94 < F Initial program 64.7%
Taylor expanded in F around inf 65.2%
Taylor expanded in B around 0 48.4%
Taylor expanded in B around 0 53.1%
Final simplification39.6%
(FPCore (F B x) :precision binary64 (/ (- x) B))
double code(double F, double B, double x) {
return -x / B;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
code = -x / b
end function
public static double code(double F, double B, double x) {
return -x / B;
}
def code(F, B, x): return -x / B
function code(F, B, x) return Float64(Float64(-x) / B) end
function tmp = code(F, B, x) tmp = -x / B; end
code[F_, B_, x_] := N[((-x) / B), $MachinePrecision]
\begin{array}{l}
\\
\frac{-x}{B}
\end{array}
Initial program 76.4%
+-commutative76.4%
fma-def76.4%
+-commutative76.4%
*-commutative76.4%
fma-def76.4%
fma-def76.4%
metadata-eval76.4%
metadata-eval76.4%
distribute-lft-neg-in76.4%
associate-*r/76.5%
*-rgt-identity76.5%
Simplified76.5%
Taylor expanded in F around 0 56.1%
mul-1-neg56.1%
*-commutative56.1%
associate-*l/56.1%
*-commutative56.1%
Simplified56.1%
Taylor expanded in B around 0 31.4%
Final simplification31.4%
herbie shell --seed 2023200
(FPCore (F B x)
:name "VandenBroeck and Keller, Equation (23)"
:precision binary64
(+ (- (* x (/ 1.0 (tan B)))) (* (/ F (sin B)) (pow (+ (+ (* F F) 2.0) (* 2.0 x)) (- (/ 1.0 2.0))))))