
(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 35 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 -9.5e+32)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 0.0092)
(- (/ (pow (+ (* F F) (* (+ x 1.0) 2.0)) -0.5) (/ (sin B) F)) 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 <= -9.5e+32) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 0.0092) {
tmp = (pow(((F * F) + ((x + 1.0) * 2.0)), -0.5) / (sin(B) / F)) - 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 <= (-9.5d+32)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 0.0092d0) then
tmp = ((((f * f) + ((x + 1.0d0) * 2.0d0)) ** (-0.5d0)) / (sin(b) / f)) - 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 <= -9.5e+32) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 0.0092) {
tmp = (Math.pow(((F * F) + ((x + 1.0) * 2.0)), -0.5) / (Math.sin(B) / F)) - 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 <= -9.5e+32: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 0.0092: tmp = (math.pow(((F * F) + ((x + 1.0) * 2.0)), -0.5) / (math.sin(B) / F)) - 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 <= -9.5e+32) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 0.0092) tmp = Float64(Float64((Float64(Float64(F * F) + Float64(Float64(x + 1.0) * 2.0)) ^ -0.5) / Float64(sin(B) / F)) - 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 <= -9.5e+32) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 0.0092) tmp = ((((F * F) + ((x + 1.0) * 2.0)) ^ -0.5) / (sin(B) / F)) - 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, -9.5e+32], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 0.0092], N[(N[(N[Power[N[(N[(F * F), $MachinePrecision] + N[(N[(x + 1.0), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision] / N[(N[Sin[B], $MachinePrecision] / F), $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.5 \cdot 10^{+32}:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 0.0092:\\
\;\;\;\;\frac{{\left(F \cdot F + \left(x + 1\right) \cdot 2\right)}^{-0.5}}{\frac{\sin B}{F}} - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -9.50000000000000006e32Initial program 60.6%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified78.8%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.9%
Simplified99.9%
if -9.50000000000000006e32 < F < 0.0091999999999999998Initial program 99.5%
+-commutativeN/A
div-invN/A
unsub-negN/A
--lowering--.f64N/A
Applied egg-rr99.7%
if 0.0091999999999999998 < F Initial program 58.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified73.0%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -5e+28)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 0.0092)
(- (/ (* F (pow (+ (* F F) (- 2.0 (* x -2.0))) -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 <= -5e+28) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 0.0092) {
tmp = ((F * pow(((F * F) + (2.0 - (x * -2.0))), -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 <= (-5d+28)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 0.0092d0) then
tmp = ((f * (((f * f) + (2.0d0 - (x * (-2.0d0)))) ** (-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 <= -5e+28) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 0.0092) {
tmp = ((F * Math.pow(((F * F) + (2.0 - (x * -2.0))), -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 <= -5e+28: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 0.0092: tmp = ((F * math.pow(((F * F) + (2.0 - (x * -2.0))), -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 <= -5e+28) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 0.0092) tmp = Float64(Float64(Float64(F * (Float64(Float64(F * F) + Float64(2.0 - Float64(x * -2.0))) ^ -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 <= -5e+28) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 0.0092) tmp = ((F * (((F * F) + (2.0 - (x * -2.0))) ^ -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, -5e+28], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 0.0092], N[(N[(N[(F * N[Power[N[(N[(F * F), $MachinePrecision] + N[(2.0 - N[(x * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -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 -5 \cdot 10^{+28}:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 0.0092:\\
\;\;\;\;\frac{F \cdot {\left(F \cdot F + \left(2 - x \cdot -2\right)\right)}^{-0.5}}{\sin B} - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -4.99999999999999957e28Initial program 62.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified79.6%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.9%
Simplified99.9%
if -4.99999999999999957e28 < F < 0.0091999999999999998Initial program 99.6%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.6%
if 0.0091999999999999998 < F Initial program 58.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified73.0%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -2e+154)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 4e+23)
(- (/ (/ F (sqrt (+ (* F F) (+ 2.0 (* x 2.0))))) (sin B)) t_0)
(- (/ 1.0 (sin B)) (/ (* x (cos B)) (sin B)))))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -2e+154) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 4e+23) {
tmp = ((F / sqrt(((F * F) + (2.0 + (x * 2.0))))) / sin(B)) - t_0;
} else {
tmp = (1.0 / sin(B)) - ((x * cos(B)) / sin(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) :: t_0
real(8) :: tmp
t_0 = x / tan(b)
if (f <= (-2d+154)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 4d+23) then
tmp = ((f / sqrt(((f * f) + (2.0d0 + (x * 2.0d0))))) / sin(b)) - t_0
else
tmp = (1.0d0 / sin(b)) - ((x * cos(b)) / sin(b))
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 <= -2e+154) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 4e+23) {
tmp = ((F / Math.sqrt(((F * F) + (2.0 + (x * 2.0))))) / Math.sin(B)) - t_0;
} else {
tmp = (1.0 / Math.sin(B)) - ((x * Math.cos(B)) / Math.sin(B));
}
return tmp;
}
def code(F, B, x): t_0 = x / math.tan(B) tmp = 0 if F <= -2e+154: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 4e+23: tmp = ((F / math.sqrt(((F * F) + (2.0 + (x * 2.0))))) / math.sin(B)) - t_0 else: tmp = (1.0 / math.sin(B)) - ((x * math.cos(B)) / math.sin(B)) return tmp
function code(F, B, x) t_0 = Float64(x / tan(B)) tmp = 0.0 if (F <= -2e+154) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 4e+23) tmp = Float64(Float64(Float64(F / sqrt(Float64(Float64(F * F) + Float64(2.0 + Float64(x * 2.0))))) / sin(B)) - t_0); else tmp = Float64(Float64(1.0 / sin(B)) - Float64(Float64(x * cos(B)) / sin(B))); end return tmp end
function tmp_2 = code(F, B, x) t_0 = x / tan(B); tmp = 0.0; if (F <= -2e+154) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 4e+23) tmp = ((F / sqrt(((F * F) + (2.0 + (x * 2.0))))) / sin(B)) - t_0; else tmp = (1.0 / sin(B)) - ((x * cos(B)) / sin(B)); end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -2e+154], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 4e+23], N[(N[(N[(F / N[Sqrt[N[(N[(F * F), $MachinePrecision] + N[(2.0 + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(N[(x * N[Cos[B], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -2 \cdot 10^{+154}:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 4 \cdot 10^{+23}:\\
\;\;\;\;\frac{\frac{F}{\sqrt{F \cdot F + \left(2 + x \cdot 2\right)}}}{\sin B} - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - \frac{x \cdot \cos B}{\sin B}\\
\end{array}
\end{array}
if F < -2.00000000000000007e154Initial program 34.8%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified56.0%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.9%
Simplified99.9%
if -2.00000000000000007e154 < F < 3.9999999999999997e23Initial program 96.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.6%
metadata-evalN/A
metadata-evalN/A
sqr-powN/A
pow2N/A
pow-lowering-pow.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
*-commutativeN/A
distribute-rgt1-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-eval99.5%
Applied egg-rr99.5%
pow-powN/A
metadata-evalN/A
*-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
+-commutativeN/A
metadata-evalN/A
sqrt-pow1N/A
inv-powN/A
/-lowering-/.f64N/A
Applied egg-rr99.6%
if 3.9999999999999997e23 < F Initial program 54.0%
Taylor expanded in F around inf
--lowering--.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -1.45e+26)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 2.05e+23)
(- (/ (/ F (sin B)) (sqrt (+ (* F F) (+ 2.0 (* x 2.0))))) t_0)
(- (/ 1.0 (sin B)) (/ (* x (cos B)) (sin B)))))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -1.45e+26) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 2.05e+23) {
tmp = ((F / sin(B)) / sqrt(((F * F) + (2.0 + (x * 2.0))))) - t_0;
} else {
tmp = (1.0 / sin(B)) - ((x * cos(B)) / sin(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) :: t_0
real(8) :: tmp
t_0 = x / tan(b)
if (f <= (-1.45d+26)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 2.05d+23) then
tmp = ((f / sin(b)) / sqrt(((f * f) + (2.0d0 + (x * 2.0d0))))) - t_0
else
tmp = (1.0d0 / sin(b)) - ((x * cos(b)) / sin(b))
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.45e+26) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 2.05e+23) {
tmp = ((F / Math.sin(B)) / Math.sqrt(((F * F) + (2.0 + (x * 2.0))))) - t_0;
} else {
tmp = (1.0 / Math.sin(B)) - ((x * Math.cos(B)) / Math.sin(B));
}
return tmp;
}
def code(F, B, x): t_0 = x / math.tan(B) tmp = 0 if F <= -1.45e+26: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 2.05e+23: tmp = ((F / math.sin(B)) / math.sqrt(((F * F) + (2.0 + (x * 2.0))))) - t_0 else: tmp = (1.0 / math.sin(B)) - ((x * math.cos(B)) / math.sin(B)) return tmp
function code(F, B, x) t_0 = Float64(x / tan(B)) tmp = 0.0 if (F <= -1.45e+26) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 2.05e+23) tmp = Float64(Float64(Float64(F / sin(B)) / sqrt(Float64(Float64(F * F) + Float64(2.0 + Float64(x * 2.0))))) - t_0); else tmp = Float64(Float64(1.0 / sin(B)) - Float64(Float64(x * cos(B)) / sin(B))); end return tmp end
function tmp_2 = code(F, B, x) t_0 = x / tan(B); tmp = 0.0; if (F <= -1.45e+26) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 2.05e+23) tmp = ((F / sin(B)) / sqrt(((F * F) + (2.0 + (x * 2.0))))) - t_0; else tmp = (1.0 / sin(B)) - ((x * cos(B)) / sin(B)); end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -1.45e+26], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 2.05e+23], N[(N[(N[(F / N[Sin[B], $MachinePrecision]), $MachinePrecision] / N[Sqrt[N[(N[(F * F), $MachinePrecision] + N[(2.0 + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(N[(x * N[Cos[B], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -1.45 \cdot 10^{+26}:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 2.05 \cdot 10^{+23}:\\
\;\;\;\;\frac{\frac{F}{\sin B}}{\sqrt{F \cdot F + \left(2 + x \cdot 2\right)}} - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - \frac{x \cdot \cos B}{\sin B}\\
\end{array}
\end{array}
if F < -1.45e26Initial program 62.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified79.6%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.9%
Simplified99.9%
if -1.45e26 < F < 2.04999999999999998e23Initial program 99.6%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.6%
metadata-evalN/A
metadata-evalN/A
sqr-powN/A
pow2N/A
pow-lowering-pow.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
*-commutativeN/A
distribute-rgt1-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-eval99.4%
Applied egg-rr99.4%
pow-powN/A
metadata-evalN/A
*-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
+-commutativeN/A
metadata-evalN/A
sqrt-pow1N/A
inv-powN/A
/-lowering-/.f64N/A
Applied egg-rr99.5%
--lowering--.f64N/A
associate-/l/N/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
tan-lowering-tan.f6499.5%
Applied egg-rr99.5%
if 2.04999999999999998e23 < F Initial program 54.0%
Taylor expanded in F around inf
--lowering--.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
Final simplification99.7%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -10000000000.0)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 4e+23)
(- (/ (* F (sqrt (/ 1.0 (+ (* F F) 2.0)))) (sin B)) t_0)
(- (/ 1.0 (sin B)) (/ (* x (cos B)) (sin B)))))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -10000000000.0) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 4e+23) {
tmp = ((F * sqrt((1.0 / ((F * F) + 2.0)))) / sin(B)) - t_0;
} else {
tmp = (1.0 / sin(B)) - ((x * cos(B)) / sin(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) :: t_0
real(8) :: tmp
t_0 = x / tan(b)
if (f <= (-10000000000.0d0)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 4d+23) then
tmp = ((f * sqrt((1.0d0 / ((f * f) + 2.0d0)))) / sin(b)) - t_0
else
tmp = (1.0d0 / sin(b)) - ((x * cos(b)) / sin(b))
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 <= -10000000000.0) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 4e+23) {
tmp = ((F * Math.sqrt((1.0 / ((F * F) + 2.0)))) / Math.sin(B)) - t_0;
} else {
tmp = (1.0 / Math.sin(B)) - ((x * Math.cos(B)) / Math.sin(B));
}
return tmp;
}
def code(F, B, x): t_0 = x / math.tan(B) tmp = 0 if F <= -10000000000.0: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 4e+23: tmp = ((F * math.sqrt((1.0 / ((F * F) + 2.0)))) / math.sin(B)) - t_0 else: tmp = (1.0 / math.sin(B)) - ((x * math.cos(B)) / math.sin(B)) return tmp
function code(F, B, x) t_0 = Float64(x / tan(B)) tmp = 0.0 if (F <= -10000000000.0) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 4e+23) tmp = Float64(Float64(Float64(F * sqrt(Float64(1.0 / Float64(Float64(F * F) + 2.0)))) / sin(B)) - t_0); else tmp = Float64(Float64(1.0 / sin(B)) - Float64(Float64(x * cos(B)) / sin(B))); end return tmp end
function tmp_2 = code(F, B, x) t_0 = x / tan(B); tmp = 0.0; if (F <= -10000000000.0) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 4e+23) tmp = ((F * sqrt((1.0 / ((F * F) + 2.0)))) / sin(B)) - t_0; else tmp = (1.0 / sin(B)) - ((x * cos(B)) / sin(B)); end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -10000000000.0], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 4e+23], N[(N[(N[(F * N[Sqrt[N[(1.0 / N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(N[(x * N[Cos[B], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -10000000000:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 4 \cdot 10^{+23}:\\
\;\;\;\;\frac{F \cdot \sqrt{\frac{1}{F \cdot F + 2}}}{\sin B} - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - \frac{x \cdot \cos B}{\sin B}\\
\end{array}
\end{array}
if F < -1e10Initial program 64.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified80.6%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
if -1e10 < F < 3.9999999999999997e23Initial program 99.6%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.6%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6498.9%
Simplified98.9%
if 3.9999999999999997e23 < F Initial program 54.0%
Taylor expanded in F around inf
--lowering--.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
Final simplification99.4%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -9.5e+32)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 0.0092)
(- (/ (pow (+ (* F F) 2.0) -0.5) (/ (sin B) F)) 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 <= -9.5e+32) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 0.0092) {
tmp = (pow(((F * F) + 2.0), -0.5) / (sin(B) / F)) - 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 <= (-9.5d+32)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 0.0092d0) then
tmp = ((((f * f) + 2.0d0) ** (-0.5d0)) / (sin(b) / f)) - 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 <= -9.5e+32) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 0.0092) {
tmp = (Math.pow(((F * F) + 2.0), -0.5) / (Math.sin(B) / F)) - 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 <= -9.5e+32: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 0.0092: tmp = (math.pow(((F * F) + 2.0), -0.5) / (math.sin(B) / F)) - 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 <= -9.5e+32) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 0.0092) tmp = Float64(Float64((Float64(Float64(F * F) + 2.0) ^ -0.5) / Float64(sin(B) / F)) - 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 <= -9.5e+32) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 0.0092) tmp = ((((F * F) + 2.0) ^ -0.5) / (sin(B) / F)) - 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, -9.5e+32], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 0.0092], N[(N[(N[Power[N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision], -0.5], $MachinePrecision] / N[(N[Sin[B], $MachinePrecision] / F), $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.5 \cdot 10^{+32}:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 0.0092:\\
\;\;\;\;\frac{{\left(F \cdot F + 2\right)}^{-0.5}}{\frac{\sin B}{F}} - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -9.50000000000000006e32Initial program 60.6%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified78.8%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.9%
Simplified99.9%
if -9.50000000000000006e32 < F < 0.0091999999999999998Initial program 99.5%
+-commutativeN/A
div-invN/A
unsub-negN/A
--lowering--.f64N/A
Applied egg-rr99.7%
Taylor expanded in x around 0
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6498.9%
Simplified98.9%
if 0.0091999999999999998 < F Initial program 58.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified73.0%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
Final simplification99.4%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -2e+154)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 4e+27)
(- (/ (/ F (sqrt (+ (* F F) 2.0))) (sin B)) t_0)
(- (/ 1.0 (sin B)) (/ (* x (cos B)) (sin B)))))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -2e+154) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 4e+27) {
tmp = ((F / sqrt(((F * F) + 2.0))) / sin(B)) - t_0;
} else {
tmp = (1.0 / sin(B)) - ((x * cos(B)) / sin(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) :: t_0
real(8) :: tmp
t_0 = x / tan(b)
if (f <= (-2d+154)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 4d+27) then
tmp = ((f / sqrt(((f * f) + 2.0d0))) / sin(b)) - t_0
else
tmp = (1.0d0 / sin(b)) - ((x * cos(b)) / sin(b))
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 <= -2e+154) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 4e+27) {
tmp = ((F / Math.sqrt(((F * F) + 2.0))) / Math.sin(B)) - t_0;
} else {
tmp = (1.0 / Math.sin(B)) - ((x * Math.cos(B)) / Math.sin(B));
}
return tmp;
}
def code(F, B, x): t_0 = x / math.tan(B) tmp = 0 if F <= -2e+154: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 4e+27: tmp = ((F / math.sqrt(((F * F) + 2.0))) / math.sin(B)) - t_0 else: tmp = (1.0 / math.sin(B)) - ((x * math.cos(B)) / math.sin(B)) return tmp
function code(F, B, x) t_0 = Float64(x / tan(B)) tmp = 0.0 if (F <= -2e+154) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 4e+27) tmp = Float64(Float64(Float64(F / sqrt(Float64(Float64(F * F) + 2.0))) / sin(B)) - t_0); else tmp = Float64(Float64(1.0 / sin(B)) - Float64(Float64(x * cos(B)) / sin(B))); end return tmp end
function tmp_2 = code(F, B, x) t_0 = x / tan(B); tmp = 0.0; if (F <= -2e+154) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 4e+27) tmp = ((F / sqrt(((F * F) + 2.0))) / sin(B)) - t_0; else tmp = (1.0 / sin(B)) - ((x * cos(B)) / sin(B)); end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -2e+154], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 4e+27], N[(N[(N[(F / N[Sqrt[N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(N[(x * N[Cos[B], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -2 \cdot 10^{+154}:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 4 \cdot 10^{+27}:\\
\;\;\;\;\frac{\frac{F}{\sqrt{F \cdot F + 2}}}{\sin B} - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - \frac{x \cdot \cos B}{\sin B}\\
\end{array}
\end{array}
if F < -2.00000000000000007e154Initial program 34.8%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified56.0%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.9%
Simplified99.9%
if -2.00000000000000007e154 < F < 4.0000000000000001e27Initial program 96.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.6%
metadata-evalN/A
metadata-evalN/A
sqr-powN/A
pow2N/A
pow-lowering-pow.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
*-commutativeN/A
distribute-rgt1-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-eval99.5%
Applied egg-rr99.5%
pow-powN/A
metadata-evalN/A
*-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
+-commutativeN/A
metadata-evalN/A
sqrt-pow1N/A
inv-powN/A
/-lowering-/.f64N/A
Applied egg-rr99.6%
Taylor expanded in x around 0
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.0%
Simplified99.0%
if 4.0000000000000001e27 < F Initial program 54.0%
Taylor expanded in F around inf
--lowering--.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
Final simplification99.4%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -1.45)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 0.0092)
(- (/ (* 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 <= -1.45) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 0.0092) {
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 <= (-1.45d0)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 0.0092d0) 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 <= -1.45) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 0.0092) {
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 <= -1.45: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 0.0092: 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 <= -1.45) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 0.0092) 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 <= -1.45) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 0.0092) 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, -1.45], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 0.0092], 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 -1.45:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 0.0092:\\
\;\;\;\;\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.44999999999999996Initial program 64.9%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified81.1%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6498.0%
Simplified98.0%
if -1.44999999999999996 < F < 0.0091999999999999998Initial program 99.6%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
metadata-evalN/A
metadata-evalN/A
sqr-powN/A
pow2N/A
pow-lowering-pow.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
*-commutativeN/A
distribute-rgt1-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-eval99.4%
Applied egg-rr99.4%
pow-powN/A
metadata-evalN/A
*-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
+-commutativeN/A
metadata-evalN/A
sqrt-pow1N/A
inv-powN/A
/-lowering-/.f64N/A
Applied egg-rr99.5%
Taylor expanded in x around 0
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.1%
Simplified99.1%
Taylor expanded in F around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
sin-lowering-sin.f6498.7%
Simplified98.7%
if 0.0091999999999999998 < F Initial program 58.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified73.0%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -4.4)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 1.3e-89)
(- (* (sqrt (/ 1.0 (+ 2.0 (+ (* F F) (* x 2.0))))) (/ F B)) t_0)
(if (<= F 0.0032)
(-
(* (/ F (sin B)) (pow (+ (* x 2.0) (+ (* F F) 2.0)) (/ -1.0 2.0)))
(/ 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 <= -4.4) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 1.3e-89) {
tmp = (sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F / B)) - t_0;
} else if (F <= 0.0032) {
tmp = ((F / sin(B)) * pow(((x * 2.0) + ((F * F) + 2.0)), (-1.0 / 2.0))) - (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 <= (-4.4d0)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 1.3d-89) then
tmp = (sqrt((1.0d0 / (2.0d0 + ((f * f) + (x * 2.0d0))))) * (f / b)) - t_0
else if (f <= 0.0032d0) then
tmp = ((f / sin(b)) * (((x * 2.0d0) + ((f * f) + 2.0d0)) ** ((-1.0d0) / 2.0d0))) - (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 <= -4.4) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 1.3e-89) {
tmp = (Math.sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F / B)) - t_0;
} else if (F <= 0.0032) {
tmp = ((F / Math.sin(B)) * Math.pow(((x * 2.0) + ((F * F) + 2.0)), (-1.0 / 2.0))) - (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 <= -4.4: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 1.3e-89: tmp = (math.sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F / B)) - t_0 elif F <= 0.0032: tmp = ((F / math.sin(B)) * math.pow(((x * 2.0) + ((F * F) + 2.0)), (-1.0 / 2.0))) - (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 <= -4.4) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 1.3e-89) tmp = Float64(Float64(sqrt(Float64(1.0 / Float64(2.0 + Float64(Float64(F * F) + Float64(x * 2.0))))) * Float64(F / B)) - t_0); elseif (F <= 0.0032) tmp = Float64(Float64(Float64(F / sin(B)) * (Float64(Float64(x * 2.0) + Float64(Float64(F * F) + 2.0)) ^ Float64(-1.0 / 2.0))) - Float64(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 <= -4.4) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 1.3e-89) tmp = (sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F / B)) - t_0; elseif (F <= 0.0032) tmp = ((F / sin(B)) * (((x * 2.0) + ((F * F) + 2.0)) ^ (-1.0 / 2.0))) - (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, -4.4], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 1.3e-89], N[(N[(N[Sqrt[N[(1.0 / N[(2.0 + N[(N[(F * F), $MachinePrecision] + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(F / B), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 0.0032], N[(N[(N[(F / N[Sin[B], $MachinePrecision]), $MachinePrecision] * N[Power[N[(N[(x * 2.0), $MachinePrecision] + N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision], N[(-1.0 / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - N[(x / B), $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 -4.4:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 1.3 \cdot 10^{-89}:\\
\;\;\;\;\sqrt{\frac{1}{2 + \left(F \cdot F + x \cdot 2\right)}} \cdot \frac{F}{B} - t\_0\\
\mathbf{elif}\;F \leq 0.0032:\\
\;\;\;\;\frac{F}{\sin B} \cdot {\left(x \cdot 2 + \left(F \cdot F + 2\right)\right)}^{\left(\frac{-1}{2}\right)} - \frac{x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -4.4000000000000004Initial program 64.9%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified81.1%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6498.0%
Simplified98.0%
if -4.4000000000000004 < F < 1.2999999999999999e-89Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
Taylor expanded in B around 0
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6485.6%
Simplified85.6%
if 1.2999999999999999e-89 < F < 0.00320000000000000015Initial program 99.8%
Taylor expanded in B around 0
/-lowering-/.f6499.8%
Simplified99.8%
if 0.00320000000000000015 < F Initial program 58.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified73.0%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
Final simplification94.3%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (- (/ (/ F (sqrt (+ (* F F) 2.0))) (sin B)) (/ x B)))
(t_1 (/ x (tan B))))
(if (<= F -22000000000000.0)
(- (/ -1.0 (sin B)) t_1)
(if (<= F -5.2e-149)
t_0
(if (<= F 1.9e-94)
(- 0.0 (/ (* x (cos B)) (sin B)))
(if (<= F 0.0092) t_0 (- (/ 1.0 (sin B)) t_1)))))))
double code(double F, double B, double x) {
double t_0 = ((F / sqrt(((F * F) + 2.0))) / sin(B)) - (x / B);
double t_1 = x / tan(B);
double tmp;
if (F <= -22000000000000.0) {
tmp = (-1.0 / sin(B)) - t_1;
} else if (F <= -5.2e-149) {
tmp = t_0;
} else if (F <= 1.9e-94) {
tmp = 0.0 - ((x * cos(B)) / sin(B));
} else if (F <= 0.0092) {
tmp = t_0;
} else {
tmp = (1.0 / sin(B)) - t_1;
}
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) :: t_1
real(8) :: tmp
t_0 = ((f / sqrt(((f * f) + 2.0d0))) / sin(b)) - (x / b)
t_1 = x / tan(b)
if (f <= (-22000000000000.0d0)) then
tmp = ((-1.0d0) / sin(b)) - t_1
else if (f <= (-5.2d-149)) then
tmp = t_0
else if (f <= 1.9d-94) then
tmp = 0.0d0 - ((x * cos(b)) / sin(b))
else if (f <= 0.0092d0) then
tmp = t_0
else
tmp = (1.0d0 / sin(b)) - t_1
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double t_0 = ((F / Math.sqrt(((F * F) + 2.0))) / Math.sin(B)) - (x / B);
double t_1 = x / Math.tan(B);
double tmp;
if (F <= -22000000000000.0) {
tmp = (-1.0 / Math.sin(B)) - t_1;
} else if (F <= -5.2e-149) {
tmp = t_0;
} else if (F <= 1.9e-94) {
tmp = 0.0 - ((x * Math.cos(B)) / Math.sin(B));
} else if (F <= 0.0092) {
tmp = t_0;
} else {
tmp = (1.0 / Math.sin(B)) - t_1;
}
return tmp;
}
def code(F, B, x): t_0 = ((F / math.sqrt(((F * F) + 2.0))) / math.sin(B)) - (x / B) t_1 = x / math.tan(B) tmp = 0 if F <= -22000000000000.0: tmp = (-1.0 / math.sin(B)) - t_1 elif F <= -5.2e-149: tmp = t_0 elif F <= 1.9e-94: tmp = 0.0 - ((x * math.cos(B)) / math.sin(B)) elif F <= 0.0092: tmp = t_0 else: tmp = (1.0 / math.sin(B)) - t_1 return tmp
function code(F, B, x) t_0 = Float64(Float64(Float64(F / sqrt(Float64(Float64(F * F) + 2.0))) / sin(B)) - Float64(x / B)) t_1 = Float64(x / tan(B)) tmp = 0.0 if (F <= -22000000000000.0) tmp = Float64(Float64(-1.0 / sin(B)) - t_1); elseif (F <= -5.2e-149) tmp = t_0; elseif (F <= 1.9e-94) tmp = Float64(0.0 - Float64(Float64(x * cos(B)) / sin(B))); elseif (F <= 0.0092) tmp = t_0; else tmp = Float64(Float64(1.0 / sin(B)) - t_1); end return tmp end
function tmp_2 = code(F, B, x) t_0 = ((F / sqrt(((F * F) + 2.0))) / sin(B)) - (x / B); t_1 = x / tan(B); tmp = 0.0; if (F <= -22000000000000.0) tmp = (-1.0 / sin(B)) - t_1; elseif (F <= -5.2e-149) tmp = t_0; elseif (F <= 1.9e-94) tmp = 0.0 - ((x * cos(B)) / sin(B)); elseif (F <= 0.0092) tmp = t_0; else tmp = (1.0 / sin(B)) - t_1; end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(N[(N[(F / N[Sqrt[N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(x / B), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -22000000000000.0], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[F, -5.2e-149], t$95$0, If[LessEqual[F, 1.9e-94], N[(0.0 - N[(N[(x * N[Cos[B], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 0.0092], t$95$0, N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{\frac{F}{\sqrt{F \cdot F + 2}}}{\sin B} - \frac{x}{B}\\
t_1 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -22000000000000:\\
\;\;\;\;\frac{-1}{\sin B} - t\_1\\
\mathbf{elif}\;F \leq -5.2 \cdot 10^{-149}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;F \leq 1.9 \cdot 10^{-94}:\\
\;\;\;\;0 - \frac{x \cdot \cos B}{\sin B}\\
\mathbf{elif}\;F \leq 0.0092:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_1\\
\end{array}
\end{array}
if F < -2.2e13Initial program 63.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified80.3%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
if -2.2e13 < F < -5.19999999999999998e-149 or 1.9e-94 < F < 0.0091999999999999998Initial program 99.7%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.6%
metadata-evalN/A
metadata-evalN/A
sqr-powN/A
pow2N/A
pow-lowering-pow.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
*-commutativeN/A
distribute-rgt1-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-eval99.2%
Applied egg-rr99.2%
pow-powN/A
metadata-evalN/A
*-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
+-commutativeN/A
metadata-evalN/A
sqrt-pow1N/A
inv-powN/A
/-lowering-/.f64N/A
Applied egg-rr99.4%
Taylor expanded in x around 0
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6497.7%
Simplified97.7%
Taylor expanded in B around 0
/-lowering-/.f6486.0%
Simplified86.0%
if -5.19999999999999998e-149 < F < 1.9e-94Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
metadata-evalN/A
metadata-evalN/A
sqr-powN/A
pow2N/A
pow-lowering-pow.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
*-commutativeN/A
distribute-rgt1-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-eval99.6%
Applied egg-rr99.6%
Taylor expanded in F around 0
mul-1-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
neg-lowering-neg.f64N/A
sin-lowering-sin.f6484.6%
Simplified84.6%
if 0.0091999999999999998 < F Initial program 58.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified73.0%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
Final simplification93.5%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -4.4)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 4.3e-75)
(- (* (sqrt (/ 1.0 (+ 2.0 (+ (* F F) (* x 2.0))))) (/ F B)) t_0)
(if (<= F 0.0085)
(-
(/ (* F (pow (+ (* F F) (- 2.0 (* x -2.0))) -0.5)) (sin B))
(/ 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 <= -4.4) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 4.3e-75) {
tmp = (sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F / B)) - t_0;
} else if (F <= 0.0085) {
tmp = ((F * pow(((F * F) + (2.0 - (x * -2.0))), -0.5)) / sin(B)) - (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 <= (-4.4d0)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 4.3d-75) then
tmp = (sqrt((1.0d0 / (2.0d0 + ((f * f) + (x * 2.0d0))))) * (f / b)) - t_0
else if (f <= 0.0085d0) then
tmp = ((f * (((f * f) + (2.0d0 - (x * (-2.0d0)))) ** (-0.5d0))) / sin(b)) - (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 <= -4.4) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 4.3e-75) {
tmp = (Math.sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F / B)) - t_0;
} else if (F <= 0.0085) {
tmp = ((F * Math.pow(((F * F) + (2.0 - (x * -2.0))), -0.5)) / Math.sin(B)) - (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 <= -4.4: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 4.3e-75: tmp = (math.sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F / B)) - t_0 elif F <= 0.0085: tmp = ((F * math.pow(((F * F) + (2.0 - (x * -2.0))), -0.5)) / math.sin(B)) - (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 <= -4.4) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 4.3e-75) tmp = Float64(Float64(sqrt(Float64(1.0 / Float64(2.0 + Float64(Float64(F * F) + Float64(x * 2.0))))) * Float64(F / B)) - t_0); elseif (F <= 0.0085) tmp = Float64(Float64(Float64(F * (Float64(Float64(F * F) + Float64(2.0 - Float64(x * -2.0))) ^ -0.5)) / sin(B)) - Float64(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 <= -4.4) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 4.3e-75) tmp = (sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F / B)) - t_0; elseif (F <= 0.0085) tmp = ((F * (((F * F) + (2.0 - (x * -2.0))) ^ -0.5)) / sin(B)) - (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, -4.4], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 4.3e-75], N[(N[(N[Sqrt[N[(1.0 / N[(2.0 + N[(N[(F * F), $MachinePrecision] + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(F / B), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 0.0085], N[(N[(N[(F * N[Power[N[(N[(F * F), $MachinePrecision] + N[(2.0 - N[(x * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(x / B), $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 -4.4:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 4.3 \cdot 10^{-75}:\\
\;\;\;\;\sqrt{\frac{1}{2 + \left(F \cdot F + x \cdot 2\right)}} \cdot \frac{F}{B} - t\_0\\
\mathbf{elif}\;F \leq 0.0085:\\
\;\;\;\;\frac{F \cdot {\left(F \cdot F + \left(2 - x \cdot -2\right)\right)}^{-0.5}}{\sin B} - \frac{x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -4.4000000000000004Initial program 64.9%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified81.1%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6498.0%
Simplified98.0%
if -4.4000000000000004 < F < 4.2999999999999999e-75Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
Taylor expanded in B around 0
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6486.1%
Simplified86.1%
if 4.2999999999999999e-75 < F < 0.0085000000000000006Initial program 99.8%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.6%
Taylor expanded in B around 0
/-lowering-/.f6499.6%
Simplified99.6%
if 0.0085000000000000006 < F Initial program 58.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified73.0%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
Final simplification94.2%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -0.28)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 6e-77)
(- (* (/ F B) (sqrt (/ 1.0 (+ 2.0 (* x 2.0))))) t_0)
(if (<= F 0.0092)
(-
(/ (* F (pow (+ (* F F) (- 2.0 (* x -2.0))) -0.5)) (sin B))
(/ 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 <= -0.28) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 6e-77) {
tmp = ((F / B) * sqrt((1.0 / (2.0 + (x * 2.0))))) - t_0;
} else if (F <= 0.0092) {
tmp = ((F * pow(((F * F) + (2.0 - (x * -2.0))), -0.5)) / sin(B)) - (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 <= (-0.28d0)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 6d-77) then
tmp = ((f / b) * sqrt((1.0d0 / (2.0d0 + (x * 2.0d0))))) - t_0
else if (f <= 0.0092d0) then
tmp = ((f * (((f * f) + (2.0d0 - (x * (-2.0d0)))) ** (-0.5d0))) / sin(b)) - (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 <= -0.28) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 6e-77) {
tmp = ((F / B) * Math.sqrt((1.0 / (2.0 + (x * 2.0))))) - t_0;
} else if (F <= 0.0092) {
tmp = ((F * Math.pow(((F * F) + (2.0 - (x * -2.0))), -0.5)) / Math.sin(B)) - (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 <= -0.28: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 6e-77: tmp = ((F / B) * math.sqrt((1.0 / (2.0 + (x * 2.0))))) - t_0 elif F <= 0.0092: tmp = ((F * math.pow(((F * F) + (2.0 - (x * -2.0))), -0.5)) / math.sin(B)) - (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 <= -0.28) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 6e-77) tmp = Float64(Float64(Float64(F / B) * sqrt(Float64(1.0 / Float64(2.0 + Float64(x * 2.0))))) - t_0); elseif (F <= 0.0092) tmp = Float64(Float64(Float64(F * (Float64(Float64(F * F) + Float64(2.0 - Float64(x * -2.0))) ^ -0.5)) / sin(B)) - Float64(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 <= -0.28) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 6e-77) tmp = ((F / B) * sqrt((1.0 / (2.0 + (x * 2.0))))) - t_0; elseif (F <= 0.0092) tmp = ((F * (((F * F) + (2.0 - (x * -2.0))) ^ -0.5)) / sin(B)) - (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, -0.28], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 6e-77], N[(N[(N[(F / B), $MachinePrecision] * N[Sqrt[N[(1.0 / N[(2.0 + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 0.0092], N[(N[(N[(F * N[Power[N[(N[(F * F), $MachinePrecision] + N[(2.0 - N[(x * -2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(x / B), $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 -0.28:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 6 \cdot 10^{-77}:\\
\;\;\;\;\frac{F}{B} \cdot \sqrt{\frac{1}{2 + x \cdot 2}} - t\_0\\
\mathbf{elif}\;F \leq 0.0092:\\
\;\;\;\;\frac{F \cdot {\left(F \cdot F + \left(2 - x \cdot -2\right)\right)}^{-0.5}}{\sin B} - \frac{x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -0.28000000000000003Initial program 64.9%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified81.1%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6498.0%
Simplified98.0%
if -0.28000000000000003 < F < 6.00000000000000033e-77Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
Taylor expanded in B around 0
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6486.1%
Simplified86.1%
Taylor expanded in F around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6485.5%
Simplified85.5%
if 6.00000000000000033e-77 < F < 0.0091999999999999998Initial program 99.8%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.6%
Taylor expanded in B around 0
/-lowering-/.f6499.6%
Simplified99.6%
if 0.0091999999999999998 < F Initial program 58.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified73.0%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (+ 2.0 (* x 2.0))) (t_1 (/ x (tan B))))
(if (<= F -0.31)
(- (/ -1.0 (sin B)) t_1)
(if (<= F 1.95e-70)
(- (* (/ F B) (sqrt (/ 1.0 t_0))) t_1)
(if (<= F 0.0092)
(- (/ (/ F (sqrt (+ (* F F) t_0))) (sin B)) (/ x B))
(- (/ 1.0 (sin B)) t_1))))))
double code(double F, double B, double x) {
double t_0 = 2.0 + (x * 2.0);
double t_1 = x / tan(B);
double tmp;
if (F <= -0.31) {
tmp = (-1.0 / sin(B)) - t_1;
} else if (F <= 1.95e-70) {
tmp = ((F / B) * sqrt((1.0 / t_0))) - t_1;
} else if (F <= 0.0092) {
tmp = ((F / sqrt(((F * F) + t_0))) / sin(B)) - (x / B);
} else {
tmp = (1.0 / sin(B)) - t_1;
}
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) :: t_1
real(8) :: tmp
t_0 = 2.0d0 + (x * 2.0d0)
t_1 = x / tan(b)
if (f <= (-0.31d0)) then
tmp = ((-1.0d0) / sin(b)) - t_1
else if (f <= 1.95d-70) then
tmp = ((f / b) * sqrt((1.0d0 / t_0))) - t_1
else if (f <= 0.0092d0) then
tmp = ((f / sqrt(((f * f) + t_0))) / sin(b)) - (x / b)
else
tmp = (1.0d0 / sin(b)) - t_1
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double t_0 = 2.0 + (x * 2.0);
double t_1 = x / Math.tan(B);
double tmp;
if (F <= -0.31) {
tmp = (-1.0 / Math.sin(B)) - t_1;
} else if (F <= 1.95e-70) {
tmp = ((F / B) * Math.sqrt((1.0 / t_0))) - t_1;
} else if (F <= 0.0092) {
tmp = ((F / Math.sqrt(((F * F) + t_0))) / Math.sin(B)) - (x / B);
} else {
tmp = (1.0 / Math.sin(B)) - t_1;
}
return tmp;
}
def code(F, B, x): t_0 = 2.0 + (x * 2.0) t_1 = x / math.tan(B) tmp = 0 if F <= -0.31: tmp = (-1.0 / math.sin(B)) - t_1 elif F <= 1.95e-70: tmp = ((F / B) * math.sqrt((1.0 / t_0))) - t_1 elif F <= 0.0092: tmp = ((F / math.sqrt(((F * F) + t_0))) / math.sin(B)) - (x / B) else: tmp = (1.0 / math.sin(B)) - t_1 return tmp
function code(F, B, x) t_0 = Float64(2.0 + Float64(x * 2.0)) t_1 = Float64(x / tan(B)) tmp = 0.0 if (F <= -0.31) tmp = Float64(Float64(-1.0 / sin(B)) - t_1); elseif (F <= 1.95e-70) tmp = Float64(Float64(Float64(F / B) * sqrt(Float64(1.0 / t_0))) - t_1); elseif (F <= 0.0092) tmp = Float64(Float64(Float64(F / sqrt(Float64(Float64(F * F) + t_0))) / sin(B)) - Float64(x / B)); else tmp = Float64(Float64(1.0 / sin(B)) - t_1); end return tmp end
function tmp_2 = code(F, B, x) t_0 = 2.0 + (x * 2.0); t_1 = x / tan(B); tmp = 0.0; if (F <= -0.31) tmp = (-1.0 / sin(B)) - t_1; elseif (F <= 1.95e-70) tmp = ((F / B) * sqrt((1.0 / t_0))) - t_1; elseif (F <= 0.0092) tmp = ((F / sqrt(((F * F) + t_0))) / sin(B)) - (x / B); else tmp = (1.0 / sin(B)) - t_1; end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(2.0 + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -0.31], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[F, 1.95e-70], N[(N[(N[(F / B), $MachinePrecision] * N[Sqrt[N[(1.0 / t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[F, 0.0092], N[(N[(N[(F / N[Sqrt[N[(N[(F * F), $MachinePrecision] + t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(x / B), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 2 + x \cdot 2\\
t_1 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -0.31:\\
\;\;\;\;\frac{-1}{\sin B} - t\_1\\
\mathbf{elif}\;F \leq 1.95 \cdot 10^{-70}:\\
\;\;\;\;\frac{F}{B} \cdot \sqrt{\frac{1}{t\_0}} - t\_1\\
\mathbf{elif}\;F \leq 0.0092:\\
\;\;\;\;\frac{\frac{F}{\sqrt{F \cdot F + t\_0}}}{\sin B} - \frac{x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_1\\
\end{array}
\end{array}
if F < -0.309999999999999998Initial program 64.9%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified81.1%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6498.0%
Simplified98.0%
if -0.309999999999999998 < F < 1.9500000000000001e-70Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
Taylor expanded in B around 0
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6486.2%
Simplified86.2%
Taylor expanded in F around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6485.7%
Simplified85.7%
if 1.9500000000000001e-70 < F < 0.0091999999999999998Initial program 99.8%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.6%
metadata-evalN/A
metadata-evalN/A
sqr-powN/A
pow2N/A
pow-lowering-pow.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
*-commutativeN/A
distribute-rgt1-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-eval98.9%
Applied egg-rr98.9%
pow-powN/A
metadata-evalN/A
*-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
+-commutativeN/A
metadata-evalN/A
sqrt-pow1N/A
inv-powN/A
/-lowering-/.f64N/A
Applied egg-rr99.2%
Taylor expanded in B around 0
/-lowering-/.f6499.2%
Simplified99.2%
if 0.0091999999999999998 < F Initial program 58.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified73.0%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -0.4)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 1.3e-70)
(- (* (/ F B) (sqrt (/ 1.0 (+ 2.0 (* x 2.0))))) t_0)
(if (<= F 0.0092)
(- (/ (/ F (sqrt (+ (* F F) 2.0))) (sin B)) (/ 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 <= -0.4) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 1.3e-70) {
tmp = ((F / B) * sqrt((1.0 / (2.0 + (x * 2.0))))) - t_0;
} else if (F <= 0.0092) {
tmp = ((F / sqrt(((F * F) + 2.0))) / sin(B)) - (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 <= (-0.4d0)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 1.3d-70) then
tmp = ((f / b) * sqrt((1.0d0 / (2.0d0 + (x * 2.0d0))))) - t_0
else if (f <= 0.0092d0) then
tmp = ((f / sqrt(((f * f) + 2.0d0))) / sin(b)) - (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 <= -0.4) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 1.3e-70) {
tmp = ((F / B) * Math.sqrt((1.0 / (2.0 + (x * 2.0))))) - t_0;
} else if (F <= 0.0092) {
tmp = ((F / Math.sqrt(((F * F) + 2.0))) / Math.sin(B)) - (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 <= -0.4: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 1.3e-70: tmp = ((F / B) * math.sqrt((1.0 / (2.0 + (x * 2.0))))) - t_0 elif F <= 0.0092: tmp = ((F / math.sqrt(((F * F) + 2.0))) / math.sin(B)) - (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 <= -0.4) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 1.3e-70) tmp = Float64(Float64(Float64(F / B) * sqrt(Float64(1.0 / Float64(2.0 + Float64(x * 2.0))))) - t_0); elseif (F <= 0.0092) tmp = Float64(Float64(Float64(F / sqrt(Float64(Float64(F * F) + 2.0))) / sin(B)) - Float64(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 <= -0.4) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 1.3e-70) tmp = ((F / B) * sqrt((1.0 / (2.0 + (x * 2.0))))) - t_0; elseif (F <= 0.0092) tmp = ((F / sqrt(((F * F) + 2.0))) / sin(B)) - (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, -0.4], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 1.3e-70], N[(N[(N[(F / B), $MachinePrecision] * N[Sqrt[N[(1.0 / N[(2.0 + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 0.0092], N[(N[(N[(F / N[Sqrt[N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(x / B), $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 -0.4:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 1.3 \cdot 10^{-70}:\\
\;\;\;\;\frac{F}{B} \cdot \sqrt{\frac{1}{2 + x \cdot 2}} - t\_0\\
\mathbf{elif}\;F \leq 0.0092:\\
\;\;\;\;\frac{\frac{F}{\sqrt{F \cdot F + 2}}}{\sin B} - \frac{x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -0.40000000000000002Initial program 64.9%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified81.1%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6498.0%
Simplified98.0%
if -0.40000000000000002 < F < 1.30000000000000001e-70Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
Taylor expanded in B around 0
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6486.2%
Simplified86.2%
Taylor expanded in F around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6485.7%
Simplified85.7%
if 1.30000000000000001e-70 < F < 0.0091999999999999998Initial program 99.8%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.6%
metadata-evalN/A
metadata-evalN/A
sqr-powN/A
pow2N/A
pow-lowering-pow.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
*-commutativeN/A
distribute-rgt1-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-eval98.9%
Applied egg-rr98.9%
pow-powN/A
metadata-evalN/A
*-commutativeN/A
distribute-lft-inN/A
metadata-evalN/A
associate-+l+N/A
+-commutativeN/A
metadata-evalN/A
sqrt-pow1N/A
inv-powN/A
/-lowering-/.f64N/A
Applied egg-rr99.2%
Taylor expanded in x around 0
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6495.8%
Simplified95.8%
Taylor expanded in B around 0
/-lowering-/.f6495.8%
Simplified95.8%
if 0.0091999999999999998 < F Initial program 58.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified73.0%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
Final simplification93.8%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -5.5e-45)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 2e-95)
(- 0.0 (/ (* x (cos B)) (sin B)))
(if (<= F 0.0068)
(* (/ F (sin B)) (sqrt (/ 1.0 (+ (* F F) 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 <= -5.5e-45) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 2e-95) {
tmp = 0.0 - ((x * cos(B)) / sin(B));
} else if (F <= 0.0068) {
tmp = (F / sin(B)) * sqrt((1.0 / ((F * F) + 2.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 <= (-5.5d-45)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 2d-95) then
tmp = 0.0d0 - ((x * cos(b)) / sin(b))
else if (f <= 0.0068d0) then
tmp = (f / sin(b)) * sqrt((1.0d0 / ((f * f) + 2.0d0)))
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 <= -5.5e-45) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 2e-95) {
tmp = 0.0 - ((x * Math.cos(B)) / Math.sin(B));
} else if (F <= 0.0068) {
tmp = (F / Math.sin(B)) * Math.sqrt((1.0 / ((F * F) + 2.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 <= -5.5e-45: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 2e-95: tmp = 0.0 - ((x * math.cos(B)) / math.sin(B)) elif F <= 0.0068: tmp = (F / math.sin(B)) * math.sqrt((1.0 / ((F * F) + 2.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 <= -5.5e-45) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 2e-95) tmp = Float64(0.0 - Float64(Float64(x * cos(B)) / sin(B))); elseif (F <= 0.0068) tmp = Float64(Float64(F / sin(B)) * sqrt(Float64(1.0 / Float64(Float64(F * F) + 2.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 <= -5.5e-45) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 2e-95) tmp = 0.0 - ((x * cos(B)) / sin(B)); elseif (F <= 0.0068) tmp = (F / sin(B)) * sqrt((1.0 / ((F * F) + 2.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, -5.5e-45], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 2e-95], N[(0.0 - N[(N[(x * N[Cos[B], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 0.0068], N[(N[(F / N[Sin[B], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(1.0 / N[(N[(F * F), $MachinePrecision] + 2.0), $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 -5.5 \cdot 10^{-45}:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 2 \cdot 10^{-95}:\\
\;\;\;\;0 - \frac{x \cdot \cos B}{\sin B}\\
\mathbf{elif}\;F \leq 0.0068:\\
\;\;\;\;\frac{F}{\sin B} \cdot \sqrt{\frac{1}{F \cdot F + 2}}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -5.5000000000000003e-45Initial program 67.3%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified82.4%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6493.9%
Simplified93.9%
if -5.5000000000000003e-45 < F < 1.99999999999999998e-95Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
metadata-evalN/A
metadata-evalN/A
sqr-powN/A
pow2N/A
pow-lowering-pow.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
*-commutativeN/A
distribute-rgt1-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-eval99.6%
Applied egg-rr99.6%
Taylor expanded in F around 0
mul-1-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
neg-lowering-neg.f64N/A
sin-lowering-sin.f6477.7%
Simplified77.7%
if 1.99999999999999998e-95 < F < 0.00679999999999999962Initial program 99.8%
Taylor expanded in x around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6480.0%
Simplified80.0%
if 0.00679999999999999962 < F Initial program 58.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified73.0%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
Final simplification89.2%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -5.5e-45)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 9.8e-92)
(- 0.0 (/ (* x (cos B)) (sin B)))
(if (<= F 0.0068)
(/ (- (* F (sqrt (/ 1.0 (+ 2.0 (+ (* F F) (* x 2.0)))))) 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 <= -5.5e-45) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 9.8e-92) {
tmp = 0.0 - ((x * cos(B)) / sin(B));
} else if (F <= 0.0068) {
tmp = ((F * sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0)))))) - 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 <= (-5.5d-45)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 9.8d-92) then
tmp = 0.0d0 - ((x * cos(b)) / sin(b))
else if (f <= 0.0068d0) then
tmp = ((f * sqrt((1.0d0 / (2.0d0 + ((f * f) + (x * 2.0d0)))))) - 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 <= -5.5e-45) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 9.8e-92) {
tmp = 0.0 - ((x * Math.cos(B)) / Math.sin(B));
} else if (F <= 0.0068) {
tmp = ((F * Math.sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0)))))) - 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 <= -5.5e-45: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 9.8e-92: tmp = 0.0 - ((x * math.cos(B)) / math.sin(B)) elif F <= 0.0068: tmp = ((F * math.sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0)))))) - 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 <= -5.5e-45) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 9.8e-92) tmp = Float64(0.0 - Float64(Float64(x * cos(B)) / sin(B))); elseif (F <= 0.0068) tmp = Float64(Float64(Float64(F * sqrt(Float64(1.0 / Float64(2.0 + Float64(Float64(F * F) + Float64(x * 2.0)))))) - 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 <= -5.5e-45) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 9.8e-92) tmp = 0.0 - ((x * cos(B)) / sin(B)); elseif (F <= 0.0068) tmp = ((F * sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0)))))) - 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, -5.5e-45], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 9.8e-92], N[(0.0 - N[(N[(x * N[Cos[B], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 0.0068], N[(N[(N[(F * N[Sqrt[N[(1.0 / N[(2.0 + N[(N[(F * F), $MachinePrecision] + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $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 -5.5 \cdot 10^{-45}:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 9.8 \cdot 10^{-92}:\\
\;\;\;\;0 - \frac{x \cdot \cos B}{\sin B}\\
\mathbf{elif}\;F \leq 0.0068:\\
\;\;\;\;\frac{F \cdot \sqrt{\frac{1}{2 + \left(F \cdot F + x \cdot 2\right)}} - x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -5.5000000000000003e-45Initial program 67.3%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified82.4%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6493.9%
Simplified93.9%
if -5.5000000000000003e-45 < F < 9.8e-92Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
metadata-evalN/A
metadata-evalN/A
sqr-powN/A
pow2N/A
pow-lowering-pow.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
*-commutativeN/A
distribute-rgt1-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-eval99.6%
Applied egg-rr99.6%
Taylor expanded in F around 0
mul-1-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
neg-lowering-neg.f64N/A
sin-lowering-sin.f6477.7%
Simplified77.7%
if 9.8e-92 < F < 0.00679999999999999962Initial program 99.8%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6468.0%
Simplified68.0%
if 0.00679999999999999962 < F Initial program 58.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified73.0%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
Final simplification88.4%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -5.4e-45)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 6.8e-104)
(- 0.0 (/ (* x (cos B)) (sin B)))
(if (<= F 0.0092)
(/ (- (* F (sqrt (/ 1.0 (+ 2.0 (+ (* F F) (* x 2.0)))))) x) B)
(- (/ 1.0 B) t_0))))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -5.4e-45) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 6.8e-104) {
tmp = 0.0 - ((x * cos(B)) / sin(B));
} else if (F <= 0.0092) {
tmp = ((F * sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0)))))) - x) / B;
} else {
tmp = (1.0 / 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 <= (-5.4d-45)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 6.8d-104) then
tmp = 0.0d0 - ((x * cos(b)) / sin(b))
else if (f <= 0.0092d0) then
tmp = ((f * sqrt((1.0d0 / (2.0d0 + ((f * f) + (x * 2.0d0)))))) - x) / b
else
tmp = (1.0d0 / 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 <= -5.4e-45) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 6.8e-104) {
tmp = 0.0 - ((x * Math.cos(B)) / Math.sin(B));
} else if (F <= 0.0092) {
tmp = ((F * Math.sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0)))))) - x) / B;
} else {
tmp = (1.0 / B) - t_0;
}
return tmp;
}
def code(F, B, x): t_0 = x / math.tan(B) tmp = 0 if F <= -5.4e-45: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 6.8e-104: tmp = 0.0 - ((x * math.cos(B)) / math.sin(B)) elif F <= 0.0092: tmp = ((F * math.sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0)))))) - x) / B else: tmp = (1.0 / B) - t_0 return tmp
function code(F, B, x) t_0 = Float64(x / tan(B)) tmp = 0.0 if (F <= -5.4e-45) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 6.8e-104) tmp = Float64(0.0 - Float64(Float64(x * cos(B)) / sin(B))); elseif (F <= 0.0092) tmp = Float64(Float64(Float64(F * sqrt(Float64(1.0 / Float64(2.0 + Float64(Float64(F * F) + Float64(x * 2.0)))))) - x) / B); else tmp = Float64(Float64(1.0 / B) - t_0); end return tmp end
function tmp_2 = code(F, B, x) t_0 = x / tan(B); tmp = 0.0; if (F <= -5.4e-45) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 6.8e-104) tmp = 0.0 - ((x * cos(B)) / sin(B)); elseif (F <= 0.0092) tmp = ((F * sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0)))))) - x) / B; else tmp = (1.0 / 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, -5.4e-45], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 6.8e-104], N[(0.0 - N[(N[(x * N[Cos[B], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 0.0092], N[(N[(N[(F * N[Sqrt[N[(1.0 / N[(2.0 + N[(N[(F * F), $MachinePrecision] + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision], N[(N[(1.0 / B), $MachinePrecision] - t$95$0), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -5.4 \cdot 10^{-45}:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 6.8 \cdot 10^{-104}:\\
\;\;\;\;0 - \frac{x \cdot \cos B}{\sin B}\\
\mathbf{elif}\;F \leq 0.0092:\\
\;\;\;\;\frac{F \cdot \sqrt{\frac{1}{2 + \left(F \cdot F + x \cdot 2\right)}} - x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{B} - t\_0\\
\end{array}
\end{array}
if F < -5.3999999999999997e-45Initial program 67.3%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified82.4%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6493.9%
Simplified93.9%
if -5.3999999999999997e-45 < F < 6.80000000000000031e-104Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
metadata-evalN/A
metadata-evalN/A
sqr-powN/A
pow2N/A
pow-lowering-pow.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
*-commutativeN/A
distribute-rgt1-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-eval99.6%
Applied egg-rr99.6%
Taylor expanded in F around 0
mul-1-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
neg-lowering-neg.f64N/A
sin-lowering-sin.f6477.7%
Simplified77.7%
if 6.80000000000000031e-104 < F < 0.0091999999999999998Initial program 99.8%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6468.0%
Simplified68.0%
if 0.0091999999999999998 < F Initial program 58.0%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified73.0%
Taylor expanded in B around 0
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6449.5%
Simplified49.5%
Taylor expanded in F around inf
/-lowering-/.f6478.6%
Simplified78.6%
Final simplification82.7%
(FPCore (F B x)
:precision binary64
(if (<= B 0.0305)
(/
(-
(+
(*
(sqrt (/ 1.0 (+ 2.0 (+ (* F F) (* x 2.0)))))
(* F (+ 1.0 (* 0.16666666666666666 (* B B)))))
(* B (* B (* x 0.3333333333333333))))
x)
B)
(- 0.0 (/ (* x (cos B)) (sin B)))))
double code(double F, double B, double x) {
double tmp;
if (B <= 0.0305) {
tmp = (((sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F * (1.0 + (0.16666666666666666 * (B * B))))) + (B * (B * (x * 0.3333333333333333)))) - x) / B;
} else {
tmp = 0.0 - ((x * cos(B)) / sin(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 (b <= 0.0305d0) then
tmp = (((sqrt((1.0d0 / (2.0d0 + ((f * f) + (x * 2.0d0))))) * (f * (1.0d0 + (0.16666666666666666d0 * (b * b))))) + (b * (b * (x * 0.3333333333333333d0)))) - x) / b
else
tmp = 0.0d0 - ((x * cos(b)) / sin(b))
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (B <= 0.0305) {
tmp = (((Math.sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F * (1.0 + (0.16666666666666666 * (B * B))))) + (B * (B * (x * 0.3333333333333333)))) - x) / B;
} else {
tmp = 0.0 - ((x * Math.cos(B)) / Math.sin(B));
}
return tmp;
}
def code(F, B, x): tmp = 0 if B <= 0.0305: tmp = (((math.sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F * (1.0 + (0.16666666666666666 * (B * B))))) + (B * (B * (x * 0.3333333333333333)))) - x) / B else: tmp = 0.0 - ((x * math.cos(B)) / math.sin(B)) return tmp
function code(F, B, x) tmp = 0.0 if (B <= 0.0305) tmp = Float64(Float64(Float64(Float64(sqrt(Float64(1.0 / Float64(2.0 + Float64(Float64(F * F) + Float64(x * 2.0))))) * Float64(F * Float64(1.0 + Float64(0.16666666666666666 * Float64(B * B))))) + Float64(B * Float64(B * Float64(x * 0.3333333333333333)))) - x) / B); else tmp = Float64(0.0 - Float64(Float64(x * cos(B)) / sin(B))); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (B <= 0.0305) tmp = (((sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F * (1.0 + (0.16666666666666666 * (B * B))))) + (B * (B * (x * 0.3333333333333333)))) - x) / B; else tmp = 0.0 - ((x * cos(B)) / sin(B)); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[B, 0.0305], N[(N[(N[(N[(N[Sqrt[N[(1.0 / N[(2.0 + N[(N[(F * F), $MachinePrecision] + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(F * N[(1.0 + N[(0.16666666666666666 * N[(B * B), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(B * N[(B * N[(x * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision], N[(0.0 - N[(N[(x * N[Cos[B], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq 0.0305:\\
\;\;\;\;\frac{\left(\sqrt{\frac{1}{2 + \left(F \cdot F + x \cdot 2\right)}} \cdot \left(F \cdot \left(1 + 0.16666666666666666 \cdot \left(B \cdot B\right)\right)\right) + B \cdot \left(B \cdot \left(x \cdot 0.3333333333333333\right)\right)\right) - x}{B}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{x \cdot \cos B}{\sin B}\\
\end{array}
\end{array}
if B < 0.030499999999999999Initial program 73.2%
Taylor expanded in B around 0
/-lowering-/.f64N/A
Simplified62.6%
if 0.030499999999999999 < B Initial program 90.2%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified90.3%
metadata-evalN/A
metadata-evalN/A
sqr-powN/A
pow2N/A
pow-lowering-pow.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
*-commutativeN/A
distribute-rgt1-inN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
metadata-evalN/A
metadata-evalN/A
metadata-eval90.1%
Applied egg-rr90.1%
Taylor expanded in F around 0
mul-1-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
cos-lowering-cos.f64N/A
neg-lowering-neg.f64N/A
sin-lowering-sin.f6452.5%
Simplified52.5%
Final simplification60.0%
(FPCore (F B x)
:precision binary64
(if (<= B 1.3e-9)
(/ (- (/ F (sqrt (+ (* F F) (+ 2.0 (* x 2.0))))) x) B)
(-
(/
(/ -1.0 F)
(/
(*
B
(+
1.0
(* B (* B (+ (* (* B B) 0.008333333333333333) -0.16666666666666666)))))
F))
(/ x (tan B)))))
double code(double F, double B, double x) {
double tmp;
if (B <= 1.3e-9) {
tmp = ((F / sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B;
} else {
tmp = ((-1.0 / F) / ((B * (1.0 + (B * (B * (((B * B) * 0.008333333333333333) + -0.16666666666666666))))) / F)) - (x / tan(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 (b <= 1.3d-9) then
tmp = ((f / sqrt(((f * f) + (2.0d0 + (x * 2.0d0))))) - x) / b
else
tmp = (((-1.0d0) / f) / ((b * (1.0d0 + (b * (b * (((b * b) * 0.008333333333333333d0) + (-0.16666666666666666d0)))))) / f)) - (x / tan(b))
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (B <= 1.3e-9) {
tmp = ((F / Math.sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B;
} else {
tmp = ((-1.0 / F) / ((B * (1.0 + (B * (B * (((B * B) * 0.008333333333333333) + -0.16666666666666666))))) / F)) - (x / Math.tan(B));
}
return tmp;
}
def code(F, B, x): tmp = 0 if B <= 1.3e-9: tmp = ((F / math.sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B else: tmp = ((-1.0 / F) / ((B * (1.0 + (B * (B * (((B * B) * 0.008333333333333333) + -0.16666666666666666))))) / F)) - (x / math.tan(B)) return tmp
function code(F, B, x) tmp = 0.0 if (B <= 1.3e-9) tmp = Float64(Float64(Float64(F / sqrt(Float64(Float64(F * F) + Float64(2.0 + Float64(x * 2.0))))) - x) / B); else tmp = Float64(Float64(Float64(-1.0 / F) / Float64(Float64(B * Float64(1.0 + Float64(B * Float64(B * Float64(Float64(Float64(B * B) * 0.008333333333333333) + -0.16666666666666666))))) / F)) - Float64(x / tan(B))); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (B <= 1.3e-9) tmp = ((F / sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B; else tmp = ((-1.0 / F) / ((B * (1.0 + (B * (B * (((B * B) * 0.008333333333333333) + -0.16666666666666666))))) / F)) - (x / tan(B)); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[B, 1.3e-9], N[(N[(N[(F / N[Sqrt[N[(N[(F * F), $MachinePrecision] + N[(2.0 + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision], N[(N[(N[(-1.0 / F), $MachinePrecision] / N[(N[(B * N[(1.0 + N[(B * N[(B * N[(N[(N[(B * B), $MachinePrecision] * 0.008333333333333333), $MachinePrecision] + -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / F), $MachinePrecision]), $MachinePrecision] - N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq 1.3 \cdot 10^{-9}:\\
\;\;\;\;\frac{\frac{F}{\sqrt{F \cdot F + \left(2 + x \cdot 2\right)}} - x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{-1}{F}}{\frac{B \cdot \left(1 + B \cdot \left(B \cdot \left(\left(B \cdot B\right) \cdot 0.008333333333333333 + -0.16666666666666666\right)\right)\right)}{F}} - \frac{x}{\tan B}\\
\end{array}
\end{array}
if B < 1.3000000000000001e-9Initial program 73.5%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6463.3%
Simplified63.3%
/-lowering-/.f64N/A
Applied egg-rr63.3%
if 1.3000000000000001e-9 < B Initial program 89.1%
+-commutativeN/A
div-invN/A
unsub-negN/A
--lowering--.f64N/A
Applied egg-rr89.1%
Taylor expanded in F around -inf
/-lowering-/.f6460.7%
Simplified60.7%
Taylor expanded in B around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
unpow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6452.3%
Simplified52.3%
Final simplification60.4%
(FPCore (F B x)
:precision binary64
(if (<= B 1.3e-9)
(/ (- (/ F (sqrt (+ (* F F) (+ 2.0 (* x 2.0))))) x) B)
(-
(/ (/ -1.0 F) (/ (* B (+ 1.0 (* (* B B) -0.16666666666666666))) F))
(/ x (tan B)))))
double code(double F, double B, double x) {
double tmp;
if (B <= 1.3e-9) {
tmp = ((F / sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B;
} else {
tmp = ((-1.0 / F) / ((B * (1.0 + ((B * B) * -0.16666666666666666))) / F)) - (x / tan(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 (b <= 1.3d-9) then
tmp = ((f / sqrt(((f * f) + (2.0d0 + (x * 2.0d0))))) - x) / b
else
tmp = (((-1.0d0) / f) / ((b * (1.0d0 + ((b * b) * (-0.16666666666666666d0)))) / f)) - (x / tan(b))
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (B <= 1.3e-9) {
tmp = ((F / Math.sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B;
} else {
tmp = ((-1.0 / F) / ((B * (1.0 + ((B * B) * -0.16666666666666666))) / F)) - (x / Math.tan(B));
}
return tmp;
}
def code(F, B, x): tmp = 0 if B <= 1.3e-9: tmp = ((F / math.sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B else: tmp = ((-1.0 / F) / ((B * (1.0 + ((B * B) * -0.16666666666666666))) / F)) - (x / math.tan(B)) return tmp
function code(F, B, x) tmp = 0.0 if (B <= 1.3e-9) tmp = Float64(Float64(Float64(F / sqrt(Float64(Float64(F * F) + Float64(2.0 + Float64(x * 2.0))))) - x) / B); else tmp = Float64(Float64(Float64(-1.0 / F) / Float64(Float64(B * Float64(1.0 + Float64(Float64(B * B) * -0.16666666666666666))) / F)) - Float64(x / tan(B))); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (B <= 1.3e-9) tmp = ((F / sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B; else tmp = ((-1.0 / F) / ((B * (1.0 + ((B * B) * -0.16666666666666666))) / F)) - (x / tan(B)); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[B, 1.3e-9], N[(N[(N[(F / N[Sqrt[N[(N[(F * F), $MachinePrecision] + N[(2.0 + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision], N[(N[(N[(-1.0 / F), $MachinePrecision] / N[(N[(B * N[(1.0 + N[(N[(B * B), $MachinePrecision] * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / F), $MachinePrecision]), $MachinePrecision] - N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq 1.3 \cdot 10^{-9}:\\
\;\;\;\;\frac{\frac{F}{\sqrt{F \cdot F + \left(2 + x \cdot 2\right)}} - x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{-1}{F}}{\frac{B \cdot \left(1 + \left(B \cdot B\right) \cdot -0.16666666666666666\right)}{F}} - \frac{x}{\tan B}\\
\end{array}
\end{array}
if B < 1.3000000000000001e-9Initial program 73.5%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6463.3%
Simplified63.3%
/-lowering-/.f64N/A
Applied egg-rr63.3%
if 1.3000000000000001e-9 < B Initial program 89.1%
+-commutativeN/A
div-invN/A
unsub-negN/A
--lowering--.f64N/A
Applied egg-rr89.1%
Taylor expanded in F around -inf
/-lowering-/.f6460.7%
Simplified60.7%
Taylor expanded in B around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6451.9%
Simplified51.9%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (* (* x 2.0) 0.5)))
(if (<= B 5.8e-179)
(* (/ 1.0 B) (- (/ F (* F (+ -1.0 (/ (- -1.0 t_0) (* F F))))) x))
(if (<= B 1.2e-9)
(* (/ 1.0 B) (- (/ F (* F (+ 1.0 (/ (+ 1.0 t_0) (* F F))))) x))
(- (* (/ F B) (/ -1.0 F)) (/ x (tan B)))))))
double code(double F, double B, double x) {
double t_0 = (x * 2.0) * 0.5;
double tmp;
if (B <= 5.8e-179) {
tmp = (1.0 / B) * ((F / (F * (-1.0 + ((-1.0 - t_0) / (F * F))))) - x);
} else if (B <= 1.2e-9) {
tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + t_0) / (F * F))))) - x);
} else {
tmp = ((F / B) * (-1.0 / F)) - (x / tan(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) :: t_0
real(8) :: tmp
t_0 = (x * 2.0d0) * 0.5d0
if (b <= 5.8d-179) then
tmp = (1.0d0 / b) * ((f / (f * ((-1.0d0) + (((-1.0d0) - t_0) / (f * f))))) - x)
else if (b <= 1.2d-9) then
tmp = (1.0d0 / b) * ((f / (f * (1.0d0 + ((1.0d0 + t_0) / (f * f))))) - x)
else
tmp = ((f / b) * ((-1.0d0) / f)) - (x / tan(b))
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double t_0 = (x * 2.0) * 0.5;
double tmp;
if (B <= 5.8e-179) {
tmp = (1.0 / B) * ((F / (F * (-1.0 + ((-1.0 - t_0) / (F * F))))) - x);
} else if (B <= 1.2e-9) {
tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + t_0) / (F * F))))) - x);
} else {
tmp = ((F / B) * (-1.0 / F)) - (x / Math.tan(B));
}
return tmp;
}
def code(F, B, x): t_0 = (x * 2.0) * 0.5 tmp = 0 if B <= 5.8e-179: tmp = (1.0 / B) * ((F / (F * (-1.0 + ((-1.0 - t_0) / (F * F))))) - x) elif B <= 1.2e-9: tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + t_0) / (F * F))))) - x) else: tmp = ((F / B) * (-1.0 / F)) - (x / math.tan(B)) return tmp
function code(F, B, x) t_0 = Float64(Float64(x * 2.0) * 0.5) tmp = 0.0 if (B <= 5.8e-179) tmp = Float64(Float64(1.0 / B) * Float64(Float64(F / Float64(F * Float64(-1.0 + Float64(Float64(-1.0 - t_0) / Float64(F * F))))) - x)); elseif (B <= 1.2e-9) tmp = Float64(Float64(1.0 / B) * Float64(Float64(F / Float64(F * Float64(1.0 + Float64(Float64(1.0 + t_0) / Float64(F * F))))) - x)); else tmp = Float64(Float64(Float64(F / B) * Float64(-1.0 / F)) - Float64(x / tan(B))); end return tmp end
function tmp_2 = code(F, B, x) t_0 = (x * 2.0) * 0.5; tmp = 0.0; if (B <= 5.8e-179) tmp = (1.0 / B) * ((F / (F * (-1.0 + ((-1.0 - t_0) / (F * F))))) - x); elseif (B <= 1.2e-9) tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + t_0) / (F * F))))) - x); else tmp = ((F / B) * (-1.0 / F)) - (x / tan(B)); end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(N[(x * 2.0), $MachinePrecision] * 0.5), $MachinePrecision]}, If[LessEqual[B, 5.8e-179], N[(N[(1.0 / B), $MachinePrecision] * N[(N[(F / N[(F * N[(-1.0 + N[(N[(-1.0 - t$95$0), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 1.2e-9], N[(N[(1.0 / B), $MachinePrecision] * N[(N[(F / N[(F * N[(1.0 + N[(N[(1.0 + t$95$0), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision], N[(N[(N[(F / B), $MachinePrecision] * N[(-1.0 / F), $MachinePrecision]), $MachinePrecision] - N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(x \cdot 2\right) \cdot 0.5\\
\mathbf{if}\;B \leq 5.8 \cdot 10^{-179}:\\
\;\;\;\;\frac{1}{B} \cdot \left(\frac{F}{F \cdot \left(-1 + \frac{-1 - t\_0}{F \cdot F}\right)} - x\right)\\
\mathbf{elif}\;B \leq 1.2 \cdot 10^{-9}:\\
\;\;\;\;\frac{1}{B} \cdot \left(\frac{F}{F \cdot \left(1 + \frac{1 + t\_0}{F \cdot F}\right)} - x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{F}{B} \cdot \frac{-1}{F} - \frac{x}{\tan B}\\
\end{array}
\end{array}
if B < 5.7999999999999998e-179Initial program 72.2%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6459.4%
Simplified59.4%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
Applied egg-rr59.3%
Taylor expanded in F around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-rgt-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6450.9%
Simplified50.9%
if 5.7999999999999998e-179 < B < 1.2e-9Initial program 80.1%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6483.7%
Simplified83.7%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
Applied egg-rr83.5%
Taylor expanded in F around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-rgt-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6483.9%
Simplified83.9%
if 1.2e-9 < B Initial program 89.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified89.2%
Taylor expanded in B around 0
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6451.6%
Simplified51.6%
Taylor expanded in F around -inf
/-lowering-/.f6450.2%
Simplified50.2%
Final simplification54.6%
(FPCore (F B x) :precision binary64 (if (<= B 1.3e-9) (/ (- (/ F (sqrt (+ (* F F) (+ 2.0 (* x 2.0))))) x) B) (- (* (/ F B) (/ -1.0 F)) (/ x (tan B)))))
double code(double F, double B, double x) {
double tmp;
if (B <= 1.3e-9) {
tmp = ((F / sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B;
} else {
tmp = ((F / B) * (-1.0 / F)) - (x / tan(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 (b <= 1.3d-9) then
tmp = ((f / sqrt(((f * f) + (2.0d0 + (x * 2.0d0))))) - x) / b
else
tmp = ((f / b) * ((-1.0d0) / f)) - (x / tan(b))
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (B <= 1.3e-9) {
tmp = ((F / Math.sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B;
} else {
tmp = ((F / B) * (-1.0 / F)) - (x / Math.tan(B));
}
return tmp;
}
def code(F, B, x): tmp = 0 if B <= 1.3e-9: tmp = ((F / math.sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B else: tmp = ((F / B) * (-1.0 / F)) - (x / math.tan(B)) return tmp
function code(F, B, x) tmp = 0.0 if (B <= 1.3e-9) tmp = Float64(Float64(Float64(F / sqrt(Float64(Float64(F * F) + Float64(2.0 + Float64(x * 2.0))))) - x) / B); else tmp = Float64(Float64(Float64(F / B) * Float64(-1.0 / F)) - Float64(x / tan(B))); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (B <= 1.3e-9) tmp = ((F / sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B; else tmp = ((F / B) * (-1.0 / F)) - (x / tan(B)); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[B, 1.3e-9], N[(N[(N[(F / N[Sqrt[N[(N[(F * F), $MachinePrecision] + N[(2.0 + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision], N[(N[(N[(F / B), $MachinePrecision] * N[(-1.0 / F), $MachinePrecision]), $MachinePrecision] - N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq 1.3 \cdot 10^{-9}:\\
\;\;\;\;\frac{\frac{F}{\sqrt{F \cdot F + \left(2 + x \cdot 2\right)}} - x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{F}{B} \cdot \frac{-1}{F} - \frac{x}{\tan B}\\
\end{array}
\end{array}
if B < 1.3000000000000001e-9Initial program 73.5%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6463.3%
Simplified63.3%
/-lowering-/.f64N/A
Applied egg-rr63.3%
if 1.3000000000000001e-9 < B Initial program 89.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified89.2%
Taylor expanded in B around 0
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6451.6%
Simplified51.6%
Taylor expanded in F around -inf
/-lowering-/.f6450.2%
Simplified50.2%
Final simplification59.8%
(FPCore (F B x)
:precision binary64
(if (<= F -3.65e+71)
(/
(+
(*
(* B B)
(+
(* x 0.3333333333333333)
(+
-0.16666666666666666
(*
(* B B)
(+
(+
(* x 0.022222222222222223)
(*
B
(*
B
(+
(* x -0.007407407407407408)
(+ (* x 0.009523809523809525) -0.00205026455026455)))))
-0.019444444444444445)))))
(- -1.0 x))
B)
(if (<= F -2.5e-13)
(/ -1.0 (sin B))
(if (<= F 5.8e+87)
(*
(/ 1.0 B)
(- (/ F (* F (+ 1.0 (/ (+ 1.0 (* (* x 2.0) 0.5)) (* F F))))) x))
(/ 1.0 (sin B))))))
double code(double F, double B, double x) {
double tmp;
if (F <= -3.65e+71) {
tmp = (((B * B) * ((x * 0.3333333333333333) + (-0.16666666666666666 + ((B * B) * (((x * 0.022222222222222223) + (B * (B * ((x * -0.007407407407407408) + ((x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + (-1.0 - x)) / B;
} else if (F <= -2.5e-13) {
tmp = -1.0 / sin(B);
} else if (F <= 5.8e+87) {
tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x);
} else {
tmp = 1.0 / sin(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 <= (-3.65d+71)) then
tmp = (((b * b) * ((x * 0.3333333333333333d0) + ((-0.16666666666666666d0) + ((b * b) * (((x * 0.022222222222222223d0) + (b * (b * ((x * (-0.007407407407407408d0)) + ((x * 0.009523809523809525d0) + (-0.00205026455026455d0)))))) + (-0.019444444444444445d0)))))) + ((-1.0d0) - x)) / b
else if (f <= (-2.5d-13)) then
tmp = (-1.0d0) / sin(b)
else if (f <= 5.8d+87) then
tmp = (1.0d0 / b) * ((f / (f * (1.0d0 + ((1.0d0 + ((x * 2.0d0) * 0.5d0)) / (f * f))))) - x)
else
tmp = 1.0d0 / sin(b)
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= -3.65e+71) {
tmp = (((B * B) * ((x * 0.3333333333333333) + (-0.16666666666666666 + ((B * B) * (((x * 0.022222222222222223) + (B * (B * ((x * -0.007407407407407408) + ((x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + (-1.0 - x)) / B;
} else if (F <= -2.5e-13) {
tmp = -1.0 / Math.sin(B);
} else if (F <= 5.8e+87) {
tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x);
} else {
tmp = 1.0 / Math.sin(B);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -3.65e+71: tmp = (((B * B) * ((x * 0.3333333333333333) + (-0.16666666666666666 + ((B * B) * (((x * 0.022222222222222223) + (B * (B * ((x * -0.007407407407407408) + ((x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + (-1.0 - x)) / B elif F <= -2.5e-13: tmp = -1.0 / math.sin(B) elif F <= 5.8e+87: tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x) else: tmp = 1.0 / math.sin(B) return tmp
function code(F, B, x) tmp = 0.0 if (F <= -3.65e+71) tmp = Float64(Float64(Float64(Float64(B * B) * Float64(Float64(x * 0.3333333333333333) + Float64(-0.16666666666666666 + Float64(Float64(B * B) * Float64(Float64(Float64(x * 0.022222222222222223) + Float64(B * Float64(B * Float64(Float64(x * -0.007407407407407408) + Float64(Float64(x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + Float64(-1.0 - x)) / B); elseif (F <= -2.5e-13) tmp = Float64(-1.0 / sin(B)); elseif (F <= 5.8e+87) tmp = Float64(Float64(1.0 / B) * Float64(Float64(F / Float64(F * Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(x * 2.0) * 0.5)) / Float64(F * F))))) - x)); else tmp = Float64(1.0 / sin(B)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -3.65e+71) tmp = (((B * B) * ((x * 0.3333333333333333) + (-0.16666666666666666 + ((B * B) * (((x * 0.022222222222222223) + (B * (B * ((x * -0.007407407407407408) + ((x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + (-1.0 - x)) / B; elseif (F <= -2.5e-13) tmp = -1.0 / sin(B); elseif (F <= 5.8e+87) tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x); else tmp = 1.0 / sin(B); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -3.65e+71], N[(N[(N[(N[(B * B), $MachinePrecision] * N[(N[(x * 0.3333333333333333), $MachinePrecision] + N[(-0.16666666666666666 + N[(N[(B * B), $MachinePrecision] * N[(N[(N[(x * 0.022222222222222223), $MachinePrecision] + N[(B * N[(B * N[(N[(x * -0.007407407407407408), $MachinePrecision] + N[(N[(x * 0.009523809523809525), $MachinePrecision] + -0.00205026455026455), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -0.019444444444444445), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-1.0 - x), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision], If[LessEqual[F, -2.5e-13], N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 5.8e+87], N[(N[(1.0 / B), $MachinePrecision] * N[(N[(F / N[(F * N[(1.0 + N[(N[(1.0 + N[(N[(x * 2.0), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -3.65 \cdot 10^{+71}:\\
\;\;\;\;\frac{\left(B \cdot B\right) \cdot \left(x \cdot 0.3333333333333333 + \left(-0.16666666666666666 + \left(B \cdot B\right) \cdot \left(\left(x \cdot 0.022222222222222223 + B \cdot \left(B \cdot \left(x \cdot -0.007407407407407408 + \left(x \cdot 0.009523809523809525 + -0.00205026455026455\right)\right)\right)\right) + -0.019444444444444445\right)\right)\right) + \left(-1 - x\right)}{B}\\
\mathbf{elif}\;F \leq -2.5 \cdot 10^{-13}:\\
\;\;\;\;\frac{-1}{\sin B}\\
\mathbf{elif}\;F \leq 5.8 \cdot 10^{+87}:\\
\;\;\;\;\frac{1}{B} \cdot \left(\frac{F}{F \cdot \left(1 + \frac{1 + \left(x \cdot 2\right) \cdot 0.5}{F \cdot F}\right)} - x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B}\\
\end{array}
\end{array}
if F < -3.64999999999999998e71Initial program 56.4%
+-commutativeN/A
div-invN/A
unsub-negN/A
--lowering--.f64N/A
Applied egg-rr56.6%
Taylor expanded in F around -inf
/-lowering-/.f6479.0%
Simplified79.0%
Taylor expanded in B around 0
Simplified61.8%
if -3.64999999999999998e71 < F < -2.49999999999999995e-13Initial program 91.2%
+-commutativeN/A
div-invN/A
unsub-negN/A
--lowering--.f64N/A
Applied egg-rr91.9%
Taylor expanded in F around -inf
/-lowering-/.f6477.4%
Simplified77.4%
Taylor expanded in x around 0
/-lowering-/.f64N/A
sin-lowering-sin.f6458.8%
Simplified58.8%
if -2.49999999999999995e-13 < F < 5.7999999999999996e87Initial program 98.0%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6457.8%
Simplified57.8%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
Applied egg-rr57.6%
Taylor expanded in F around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-rgt-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6444.2%
Simplified44.2%
if 5.7999999999999996e87 < F Initial program 45.9%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.7%
Simplified99.7%
Taylor expanded in x around 0
/-lowering-/.f64N/A
sin-lowering-sin.f6457.9%
Simplified57.9%
Final simplification52.2%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (* (* x 2.0) 0.5)))
(if (<= B 2.95e-179)
(* (/ 1.0 B) (- (/ F (* F (+ -1.0 (/ (- -1.0 t_0) (* F F))))) x))
(if (<= B 4e-5)
(* (/ 1.0 B) (- (/ F (* F (+ 1.0 (/ (+ 1.0 t_0) (* F F))))) x))
(- (/ 1.0 B) (/ x (tan B)))))))
double code(double F, double B, double x) {
double t_0 = (x * 2.0) * 0.5;
double tmp;
if (B <= 2.95e-179) {
tmp = (1.0 / B) * ((F / (F * (-1.0 + ((-1.0 - t_0) / (F * F))))) - x);
} else if (B <= 4e-5) {
tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + t_0) / (F * F))))) - x);
} else {
tmp = (1.0 / B) - (x / tan(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) :: t_0
real(8) :: tmp
t_0 = (x * 2.0d0) * 0.5d0
if (b <= 2.95d-179) then
tmp = (1.0d0 / b) * ((f / (f * ((-1.0d0) + (((-1.0d0) - t_0) / (f * f))))) - x)
else if (b <= 4d-5) then
tmp = (1.0d0 / b) * ((f / (f * (1.0d0 + ((1.0d0 + t_0) / (f * f))))) - x)
else
tmp = (1.0d0 / b) - (x / tan(b))
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double t_0 = (x * 2.0) * 0.5;
double tmp;
if (B <= 2.95e-179) {
tmp = (1.0 / B) * ((F / (F * (-1.0 + ((-1.0 - t_0) / (F * F))))) - x);
} else if (B <= 4e-5) {
tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + t_0) / (F * F))))) - x);
} else {
tmp = (1.0 / B) - (x / Math.tan(B));
}
return tmp;
}
def code(F, B, x): t_0 = (x * 2.0) * 0.5 tmp = 0 if B <= 2.95e-179: tmp = (1.0 / B) * ((F / (F * (-1.0 + ((-1.0 - t_0) / (F * F))))) - x) elif B <= 4e-5: tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + t_0) / (F * F))))) - x) else: tmp = (1.0 / B) - (x / math.tan(B)) return tmp
function code(F, B, x) t_0 = Float64(Float64(x * 2.0) * 0.5) tmp = 0.0 if (B <= 2.95e-179) tmp = Float64(Float64(1.0 / B) * Float64(Float64(F / Float64(F * Float64(-1.0 + Float64(Float64(-1.0 - t_0) / Float64(F * F))))) - x)); elseif (B <= 4e-5) tmp = Float64(Float64(1.0 / B) * Float64(Float64(F / Float64(F * Float64(1.0 + Float64(Float64(1.0 + t_0) / Float64(F * F))))) - x)); else tmp = Float64(Float64(1.0 / B) - Float64(x / tan(B))); end return tmp end
function tmp_2 = code(F, B, x) t_0 = (x * 2.0) * 0.5; tmp = 0.0; if (B <= 2.95e-179) tmp = (1.0 / B) * ((F / (F * (-1.0 + ((-1.0 - t_0) / (F * F))))) - x); elseif (B <= 4e-5) tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + t_0) / (F * F))))) - x); else tmp = (1.0 / B) - (x / tan(B)); end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(N[(x * 2.0), $MachinePrecision] * 0.5), $MachinePrecision]}, If[LessEqual[B, 2.95e-179], N[(N[(1.0 / B), $MachinePrecision] * N[(N[(F / N[(F * N[(-1.0 + N[(N[(-1.0 - t$95$0), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision], If[LessEqual[B, 4e-5], N[(N[(1.0 / B), $MachinePrecision] * N[(N[(F / N[(F * N[(1.0 + N[(N[(1.0 + t$95$0), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / B), $MachinePrecision] - N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \left(x \cdot 2\right) \cdot 0.5\\
\mathbf{if}\;B \leq 2.95 \cdot 10^{-179}:\\
\;\;\;\;\frac{1}{B} \cdot \left(\frac{F}{F \cdot \left(-1 + \frac{-1 - t\_0}{F \cdot F}\right)} - x\right)\\
\mathbf{elif}\;B \leq 4 \cdot 10^{-5}:\\
\;\;\;\;\frac{1}{B} \cdot \left(\frac{F}{F \cdot \left(1 + \frac{1 + t\_0}{F \cdot F}\right)} - x\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{B} - \frac{x}{\tan B}\\
\end{array}
\end{array}
if B < 2.95000000000000015e-179Initial program 72.2%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6459.4%
Simplified59.4%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
Applied egg-rr59.3%
Taylor expanded in F around -inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-rgt-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6450.9%
Simplified50.9%
if 2.95000000000000015e-179 < B < 4.00000000000000033e-5Initial program 77.6%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6481.1%
Simplified81.1%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
Applied egg-rr80.9%
Taylor expanded in F around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-rgt-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6481.3%
Simplified81.3%
if 4.00000000000000033e-5 < B Initial program 90.4%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified90.4%
Taylor expanded in B around 0
*-commutativeN/A
cancel-sign-sub-invN/A
metadata-evalN/A
associate-+r+N/A
+-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f6452.3%
Simplified52.3%
Taylor expanded in F around inf
/-lowering-/.f6449.1%
Simplified49.1%
Final simplification54.1%
(FPCore (F B x)
:precision binary64
(if (<= F -8.5e+69)
(/
(+
(*
(* B B)
(+
(* x 0.3333333333333333)
(+
-0.16666666666666666
(*
(* B B)
(+
(+
(* x 0.022222222222222223)
(*
B
(*
B
(+
(* x -0.007407407407407408)
(+ (* x 0.009523809523809525) -0.00205026455026455)))))
-0.019444444444444445)))))
(- -1.0 x))
B)
(if (<= F -1.2e-13)
(/ -1.0 (sin B))
(*
(/ 1.0 B)
(- (/ F (* F (+ 1.0 (/ (+ 1.0 (* (* x 2.0) 0.5)) (* F F))))) x)))))
double code(double F, double B, double x) {
double tmp;
if (F <= -8.5e+69) {
tmp = (((B * B) * ((x * 0.3333333333333333) + (-0.16666666666666666 + ((B * B) * (((x * 0.022222222222222223) + (B * (B * ((x * -0.007407407407407408) + ((x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + (-1.0 - x)) / B;
} else if (F <= -1.2e-13) {
tmp = -1.0 / sin(B);
} else {
tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x);
}
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.5d+69)) then
tmp = (((b * b) * ((x * 0.3333333333333333d0) + ((-0.16666666666666666d0) + ((b * b) * (((x * 0.022222222222222223d0) + (b * (b * ((x * (-0.007407407407407408d0)) + ((x * 0.009523809523809525d0) + (-0.00205026455026455d0)))))) + (-0.019444444444444445d0)))))) + ((-1.0d0) - x)) / b
else if (f <= (-1.2d-13)) then
tmp = (-1.0d0) / sin(b)
else
tmp = (1.0d0 / b) * ((f / (f * (1.0d0 + ((1.0d0 + ((x * 2.0d0) * 0.5d0)) / (f * f))))) - x)
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= -8.5e+69) {
tmp = (((B * B) * ((x * 0.3333333333333333) + (-0.16666666666666666 + ((B * B) * (((x * 0.022222222222222223) + (B * (B * ((x * -0.007407407407407408) + ((x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + (-1.0 - x)) / B;
} else if (F <= -1.2e-13) {
tmp = -1.0 / Math.sin(B);
} else {
tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -8.5e+69: tmp = (((B * B) * ((x * 0.3333333333333333) + (-0.16666666666666666 + ((B * B) * (((x * 0.022222222222222223) + (B * (B * ((x * -0.007407407407407408) + ((x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + (-1.0 - x)) / B elif F <= -1.2e-13: tmp = -1.0 / math.sin(B) else: tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x) return tmp
function code(F, B, x) tmp = 0.0 if (F <= -8.5e+69) tmp = Float64(Float64(Float64(Float64(B * B) * Float64(Float64(x * 0.3333333333333333) + Float64(-0.16666666666666666 + Float64(Float64(B * B) * Float64(Float64(Float64(x * 0.022222222222222223) + Float64(B * Float64(B * Float64(Float64(x * -0.007407407407407408) + Float64(Float64(x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + Float64(-1.0 - x)) / B); elseif (F <= -1.2e-13) tmp = Float64(-1.0 / sin(B)); else tmp = Float64(Float64(1.0 / B) * Float64(Float64(F / Float64(F * Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(x * 2.0) * 0.5)) / Float64(F * F))))) - x)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -8.5e+69) tmp = (((B * B) * ((x * 0.3333333333333333) + (-0.16666666666666666 + ((B * B) * (((x * 0.022222222222222223) + (B * (B * ((x * -0.007407407407407408) + ((x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + (-1.0 - x)) / B; elseif (F <= -1.2e-13) tmp = -1.0 / sin(B); else tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -8.5e+69], N[(N[(N[(N[(B * B), $MachinePrecision] * N[(N[(x * 0.3333333333333333), $MachinePrecision] + N[(-0.16666666666666666 + N[(N[(B * B), $MachinePrecision] * N[(N[(N[(x * 0.022222222222222223), $MachinePrecision] + N[(B * N[(B * N[(N[(x * -0.007407407407407408), $MachinePrecision] + N[(N[(x * 0.009523809523809525), $MachinePrecision] + -0.00205026455026455), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -0.019444444444444445), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-1.0 - x), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision], If[LessEqual[F, -1.2e-13], N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / B), $MachinePrecision] * N[(N[(F / N[(F * N[(1.0 + N[(N[(1.0 + N[(N[(x * 2.0), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -8.5 \cdot 10^{+69}:\\
\;\;\;\;\frac{\left(B \cdot B\right) \cdot \left(x \cdot 0.3333333333333333 + \left(-0.16666666666666666 + \left(B \cdot B\right) \cdot \left(\left(x \cdot 0.022222222222222223 + B \cdot \left(B \cdot \left(x \cdot -0.007407407407407408 + \left(x \cdot 0.009523809523809525 + -0.00205026455026455\right)\right)\right)\right) + -0.019444444444444445\right)\right)\right) + \left(-1 - x\right)}{B}\\
\mathbf{elif}\;F \leq -1.2 \cdot 10^{-13}:\\
\;\;\;\;\frac{-1}{\sin B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{B} \cdot \left(\frac{F}{F \cdot \left(1 + \frac{1 + \left(x \cdot 2\right) \cdot 0.5}{F \cdot F}\right)} - x\right)\\
\end{array}
\end{array}
if F < -8.5000000000000002e69Initial program 56.4%
+-commutativeN/A
div-invN/A
unsub-negN/A
--lowering--.f64N/A
Applied egg-rr56.6%
Taylor expanded in F around -inf
/-lowering-/.f6479.0%
Simplified79.0%
Taylor expanded in B around 0
Simplified61.8%
if -8.5000000000000002e69 < F < -1.1999999999999999e-13Initial program 91.2%
+-commutativeN/A
div-invN/A
unsub-negN/A
--lowering--.f64N/A
Applied egg-rr91.9%
Taylor expanded in F around -inf
/-lowering-/.f6477.4%
Simplified77.4%
Taylor expanded in x around 0
/-lowering-/.f64N/A
sin-lowering-sin.f6458.8%
Simplified58.8%
if -1.1999999999999999e-13 < F Initial program 83.3%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6449.8%
Simplified49.8%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
Applied egg-rr49.7%
Taylor expanded in F around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-rgt-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6445.5%
Simplified45.5%
Final simplification50.5%
(FPCore (F B x)
:precision binary64
(if (<= F -4e-54)
(/
(+
(*
(* B B)
(+
(* x 0.3333333333333333)
(+
-0.16666666666666666
(*
(* B B)
(+
(+
(* x 0.022222222222222223)
(*
B
(*
B
(+
(* x -0.007407407407407408)
(+ (* x 0.009523809523809525) -0.00205026455026455)))))
-0.019444444444444445)))))
(- -1.0 x))
B)
(*
(/ 1.0 B)
(- (/ F (* F (+ 1.0 (/ (+ 1.0 (* (* x 2.0) 0.5)) (* F F))))) x))))
double code(double F, double B, double x) {
double tmp;
if (F <= -4e-54) {
tmp = (((B * B) * ((x * 0.3333333333333333) + (-0.16666666666666666 + ((B * B) * (((x * 0.022222222222222223) + (B * (B * ((x * -0.007407407407407408) + ((x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + (-1.0 - x)) / B;
} else {
tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x);
}
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 <= (-4d-54)) then
tmp = (((b * b) * ((x * 0.3333333333333333d0) + ((-0.16666666666666666d0) + ((b * b) * (((x * 0.022222222222222223d0) + (b * (b * ((x * (-0.007407407407407408d0)) + ((x * 0.009523809523809525d0) + (-0.00205026455026455d0)))))) + (-0.019444444444444445d0)))))) + ((-1.0d0) - x)) / b
else
tmp = (1.0d0 / b) * ((f / (f * (1.0d0 + ((1.0d0 + ((x * 2.0d0) * 0.5d0)) / (f * f))))) - x)
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= -4e-54) {
tmp = (((B * B) * ((x * 0.3333333333333333) + (-0.16666666666666666 + ((B * B) * (((x * 0.022222222222222223) + (B * (B * ((x * -0.007407407407407408) + ((x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + (-1.0 - x)) / B;
} else {
tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -4e-54: tmp = (((B * B) * ((x * 0.3333333333333333) + (-0.16666666666666666 + ((B * B) * (((x * 0.022222222222222223) + (B * (B * ((x * -0.007407407407407408) + ((x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + (-1.0 - x)) / B else: tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x) return tmp
function code(F, B, x) tmp = 0.0 if (F <= -4e-54) tmp = Float64(Float64(Float64(Float64(B * B) * Float64(Float64(x * 0.3333333333333333) + Float64(-0.16666666666666666 + Float64(Float64(B * B) * Float64(Float64(Float64(x * 0.022222222222222223) + Float64(B * Float64(B * Float64(Float64(x * -0.007407407407407408) + Float64(Float64(x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + Float64(-1.0 - x)) / B); else tmp = Float64(Float64(1.0 / B) * Float64(Float64(F / Float64(F * Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(x * 2.0) * 0.5)) / Float64(F * F))))) - x)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -4e-54) tmp = (((B * B) * ((x * 0.3333333333333333) + (-0.16666666666666666 + ((B * B) * (((x * 0.022222222222222223) + (B * (B * ((x * -0.007407407407407408) + ((x * 0.009523809523809525) + -0.00205026455026455))))) + -0.019444444444444445))))) + (-1.0 - x)) / B; else tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -4e-54], N[(N[(N[(N[(B * B), $MachinePrecision] * N[(N[(x * 0.3333333333333333), $MachinePrecision] + N[(-0.16666666666666666 + N[(N[(B * B), $MachinePrecision] * N[(N[(N[(x * 0.022222222222222223), $MachinePrecision] + N[(B * N[(B * N[(N[(x * -0.007407407407407408), $MachinePrecision] + N[(N[(x * 0.009523809523809525), $MachinePrecision] + -0.00205026455026455), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + -0.019444444444444445), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(-1.0 - x), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision], N[(N[(1.0 / B), $MachinePrecision] * N[(N[(F / N[(F * N[(1.0 + N[(N[(1.0 + N[(N[(x * 2.0), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -4 \cdot 10^{-54}:\\
\;\;\;\;\frac{\left(B \cdot B\right) \cdot \left(x \cdot 0.3333333333333333 + \left(-0.16666666666666666 + \left(B \cdot B\right) \cdot \left(\left(x \cdot 0.022222222222222223 + B \cdot \left(B \cdot \left(x \cdot -0.007407407407407408 + \left(x \cdot 0.009523809523809525 + -0.00205026455026455\right)\right)\right)\right) + -0.019444444444444445\right)\right)\right) + \left(-1 - x\right)}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{B} \cdot \left(\frac{F}{F \cdot \left(1 + \frac{1 + \left(x \cdot 2\right) \cdot 0.5}{F \cdot F}\right)} - x\right)\\
\end{array}
\end{array}
if F < -4.0000000000000001e-54Initial program 67.7%
+-commutativeN/A
div-invN/A
unsub-negN/A
--lowering--.f64N/A
Applied egg-rr68.0%
Taylor expanded in F around -inf
/-lowering-/.f6477.7%
Simplified77.7%
Taylor expanded in B around 0
Simplified52.9%
if -4.0000000000000001e-54 < F Initial program 82.9%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6449.4%
Simplified49.4%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
Applied egg-rr49.3%
Taylor expanded in F around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-rgt-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6445.7%
Simplified45.7%
Final simplification48.1%
(FPCore (F B x)
:precision binary64
(if (<= F -6e-57)
(/ (+ (- -1.0 x) (* B (* x (* B 0.3333333333333333)))) B)
(*
(/ 1.0 B)
(- (/ F (* F (+ 1.0 (/ (+ 1.0 (* (* x 2.0) 0.5)) (* F F))))) x))))
double code(double F, double B, double x) {
double tmp;
if (F <= -6e-57) {
tmp = ((-1.0 - x) + (B * (x * (B * 0.3333333333333333)))) / B;
} else {
tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x);
}
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 <= (-6d-57)) then
tmp = (((-1.0d0) - x) + (b * (x * (b * 0.3333333333333333d0)))) / b
else
tmp = (1.0d0 / b) * ((f / (f * (1.0d0 + ((1.0d0 + ((x * 2.0d0) * 0.5d0)) / (f * f))))) - x)
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= -6e-57) {
tmp = ((-1.0 - x) + (B * (x * (B * 0.3333333333333333)))) / B;
} else {
tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -6e-57: tmp = ((-1.0 - x) + (B * (x * (B * 0.3333333333333333)))) / B else: tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x) return tmp
function code(F, B, x) tmp = 0.0 if (F <= -6e-57) tmp = Float64(Float64(Float64(-1.0 - x) + Float64(B * Float64(x * Float64(B * 0.3333333333333333)))) / B); else tmp = Float64(Float64(1.0 / B) * Float64(Float64(F / Float64(F * Float64(1.0 + Float64(Float64(1.0 + Float64(Float64(x * 2.0) * 0.5)) / Float64(F * F))))) - x)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -6e-57) tmp = ((-1.0 - x) + (B * (x * (B * 0.3333333333333333)))) / B; else tmp = (1.0 / B) * ((F / (F * (1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))))) - x); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -6e-57], N[(N[(N[(-1.0 - x), $MachinePrecision] + N[(B * N[(x * N[(B * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision], N[(N[(1.0 / B), $MachinePrecision] * N[(N[(F / N[(F * N[(1.0 + N[(N[(1.0 + N[(N[(x * 2.0), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -6 \cdot 10^{-57}:\\
\;\;\;\;\frac{\left(-1 - x\right) + B \cdot \left(x \cdot \left(B \cdot 0.3333333333333333\right)\right)}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{B} \cdot \left(\frac{F}{F \cdot \left(1 + \frac{1 + \left(x \cdot 2\right) \cdot 0.5}{F \cdot F}\right)} - x\right)\\
\end{array}
\end{array}
if F < -6.00000000000000001e-57Initial program 67.7%
+-commutativeN/A
div-invN/A
unsub-negN/A
--lowering--.f64N/A
Applied egg-rr68.0%
Taylor expanded in F around -inf
/-lowering-/.f6477.7%
Simplified77.7%
Taylor expanded in B around 0
/-lowering-/.f64N/A
sub-negN/A
+-lowering-+.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
--lowering--.f6452.6%
Simplified52.6%
Taylor expanded in x around inf
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6452.8%
Simplified52.8%
if -6.00000000000000001e-57 < F Initial program 82.9%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6449.4%
Simplified49.4%
clear-numN/A
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
Applied egg-rr49.3%
Taylor expanded in F around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-rgt-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6445.7%
Simplified45.7%
Final simplification48.1%
(FPCore (F B x)
:precision binary64
(if (<= F -1.02e-55)
(/ (+ (- -1.0 x) (* B (* x (* B 0.3333333333333333)))) B)
(if (<= F 6.2e-55)
(/ x (- 0.0 B))
(/
(+
1.0
(- (* (* B B) (+ 0.16666666666666666 (* x 0.3333333333333333))) x))
B))))
double code(double F, double B, double x) {
double tmp;
if (F <= -1.02e-55) {
tmp = ((-1.0 - x) + (B * (x * (B * 0.3333333333333333)))) / B;
} else if (F <= 6.2e-55) {
tmp = x / (0.0 - B);
} else {
tmp = (1.0 + (((B * B) * (0.16666666666666666 + (x * 0.3333333333333333))) - 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.02d-55)) then
tmp = (((-1.0d0) - x) + (b * (x * (b * 0.3333333333333333d0)))) / b
else if (f <= 6.2d-55) then
tmp = x / (0.0d0 - b)
else
tmp = (1.0d0 + (((b * b) * (0.16666666666666666d0 + (x * 0.3333333333333333d0))) - x)) / b
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= -1.02e-55) {
tmp = ((-1.0 - x) + (B * (x * (B * 0.3333333333333333)))) / B;
} else if (F <= 6.2e-55) {
tmp = x / (0.0 - B);
} else {
tmp = (1.0 + (((B * B) * (0.16666666666666666 + (x * 0.3333333333333333))) - x)) / B;
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -1.02e-55: tmp = ((-1.0 - x) + (B * (x * (B * 0.3333333333333333)))) / B elif F <= 6.2e-55: tmp = x / (0.0 - B) else: tmp = (1.0 + (((B * B) * (0.16666666666666666 + (x * 0.3333333333333333))) - x)) / B return tmp
function code(F, B, x) tmp = 0.0 if (F <= -1.02e-55) tmp = Float64(Float64(Float64(-1.0 - x) + Float64(B * Float64(x * Float64(B * 0.3333333333333333)))) / B); elseif (F <= 6.2e-55) tmp = Float64(x / Float64(0.0 - B)); else tmp = Float64(Float64(1.0 + Float64(Float64(Float64(B * B) * Float64(0.16666666666666666 + Float64(x * 0.3333333333333333))) - x)) / B); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -1.02e-55) tmp = ((-1.0 - x) + (B * (x * (B * 0.3333333333333333)))) / B; elseif (F <= 6.2e-55) tmp = x / (0.0 - B); else tmp = (1.0 + (((B * B) * (0.16666666666666666 + (x * 0.3333333333333333))) - x)) / B; end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -1.02e-55], N[(N[(N[(-1.0 - x), $MachinePrecision] + N[(B * N[(x * N[(B * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision], If[LessEqual[F, 6.2e-55], N[(x / N[(0.0 - B), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 + N[(N[(N[(B * B), $MachinePrecision] * N[(0.16666666666666666 + N[(x * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -1.02 \cdot 10^{-55}:\\
\;\;\;\;\frac{\left(-1 - x\right) + B \cdot \left(x \cdot \left(B \cdot 0.3333333333333333\right)\right)}{B}\\
\mathbf{elif}\;F \leq 6.2 \cdot 10^{-55}:\\
\;\;\;\;\frac{x}{0 - B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 + \left(\left(B \cdot B\right) \cdot \left(0.16666666666666666 + x \cdot 0.3333333333333333\right) - x\right)}{B}\\
\end{array}
\end{array}
if F < -1.02e-55Initial program 67.7%
+-commutativeN/A
div-invN/A
unsub-negN/A
--lowering--.f64N/A
Applied egg-rr68.0%
Taylor expanded in F around -inf
/-lowering-/.f6477.7%
Simplified77.7%
Taylor expanded in B around 0
/-lowering-/.f64N/A
sub-negN/A
+-lowering-+.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
--lowering--.f6452.6%
Simplified52.6%
Taylor expanded in x around inf
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6452.8%
Simplified52.8%
if -1.02e-55 < F < 6.19999999999999993e-55Initial program 99.6%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6456.8%
Simplified56.8%
Taylor expanded in F around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6445.2%
Simplified45.2%
if 6.19999999999999993e-55 < F Initial program 63.4%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6488.1%
Simplified88.1%
Taylor expanded in B around 0
/-lowering-/.f64N/A
associate--l+N/A
+-lowering-+.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f6446.2%
Simplified46.2%
Final simplification48.1%
(FPCore (F B x) :precision binary64 (if (<= F -1.1e-56) (/ (+ (- -1.0 x) (* B (* x (* B 0.3333333333333333)))) B) (if (<= F 6e-55) (/ x (- 0.0 B)) (/ (- 1.0 x) B))))
double code(double F, double B, double x) {
double tmp;
if (F <= -1.1e-56) {
tmp = ((-1.0 - x) + (B * (x * (B * 0.3333333333333333)))) / B;
} else if (F <= 6e-55) {
tmp = x / (0.0 - 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.1d-56)) then
tmp = (((-1.0d0) - x) + (b * (x * (b * 0.3333333333333333d0)))) / b
else if (f <= 6d-55) then
tmp = x / (0.0d0 - 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.1e-56) {
tmp = ((-1.0 - x) + (B * (x * (B * 0.3333333333333333)))) / B;
} else if (F <= 6e-55) {
tmp = x / (0.0 - B);
} else {
tmp = (1.0 - x) / B;
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -1.1e-56: tmp = ((-1.0 - x) + (B * (x * (B * 0.3333333333333333)))) / B elif F <= 6e-55: tmp = x / (0.0 - B) else: tmp = (1.0 - x) / B return tmp
function code(F, B, x) tmp = 0.0 if (F <= -1.1e-56) tmp = Float64(Float64(Float64(-1.0 - x) + Float64(B * Float64(x * Float64(B * 0.3333333333333333)))) / B); elseif (F <= 6e-55) tmp = Float64(x / Float64(0.0 - 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.1e-56) tmp = ((-1.0 - x) + (B * (x * (B * 0.3333333333333333)))) / B; elseif (F <= 6e-55) tmp = x / (0.0 - B); else tmp = (1.0 - x) / B; end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -1.1e-56], N[(N[(N[(-1.0 - x), $MachinePrecision] + N[(B * N[(x * N[(B * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision], If[LessEqual[F, 6e-55], N[(x / N[(0.0 - B), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 - x), $MachinePrecision] / B), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -1.1 \cdot 10^{-56}:\\
\;\;\;\;\frac{\left(-1 - x\right) + B \cdot \left(x \cdot \left(B \cdot 0.3333333333333333\right)\right)}{B}\\
\mathbf{elif}\;F \leq 6 \cdot 10^{-55}:\\
\;\;\;\;\frac{x}{0 - B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - x}{B}\\
\end{array}
\end{array}
if F < -1.10000000000000002e-56Initial program 67.7%
+-commutativeN/A
div-invN/A
unsub-negN/A
--lowering--.f64N/A
Applied egg-rr68.0%
Taylor expanded in F around -inf
/-lowering-/.f6477.7%
Simplified77.7%
Taylor expanded in B around 0
/-lowering-/.f64N/A
sub-negN/A
+-lowering-+.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
--lowering--.f6452.6%
Simplified52.6%
Taylor expanded in x around inf
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6452.8%
Simplified52.8%
if -1.10000000000000002e-56 < F < 6.00000000000000033e-55Initial program 99.6%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6456.8%
Simplified56.8%
Taylor expanded in F around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6445.2%
Simplified45.2%
if 6.00000000000000033e-55 < F Initial program 63.4%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6440.9%
Simplified40.9%
Taylor expanded in F around inf
/-lowering-/.f64N/A
--lowering--.f6446.2%
Simplified46.2%
Final simplification48.1%
(FPCore (F B x) :precision binary64 (if (<= F -5.5e-45) (/ (+ (- -1.0 x) (* B (* B -0.16666666666666666))) B) (if (<= F 7.2e-56) (/ x (- 0.0 B)) (/ (- 1.0 x) B))))
double code(double F, double B, double x) {
double tmp;
if (F <= -5.5e-45) {
tmp = ((-1.0 - x) + (B * (B * -0.16666666666666666))) / B;
} else if (F <= 7.2e-56) {
tmp = x / (0.0 - 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 <= (-5.5d-45)) then
tmp = (((-1.0d0) - x) + (b * (b * (-0.16666666666666666d0)))) / b
else if (f <= 7.2d-56) then
tmp = x / (0.0d0 - 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 <= -5.5e-45) {
tmp = ((-1.0 - x) + (B * (B * -0.16666666666666666))) / B;
} else if (F <= 7.2e-56) {
tmp = x / (0.0 - B);
} else {
tmp = (1.0 - x) / B;
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -5.5e-45: tmp = ((-1.0 - x) + (B * (B * -0.16666666666666666))) / B elif F <= 7.2e-56: tmp = x / (0.0 - B) else: tmp = (1.0 - x) / B return tmp
function code(F, B, x) tmp = 0.0 if (F <= -5.5e-45) tmp = Float64(Float64(Float64(-1.0 - x) + Float64(B * Float64(B * -0.16666666666666666))) / B); elseif (F <= 7.2e-56) tmp = Float64(x / Float64(0.0 - 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 <= -5.5e-45) tmp = ((-1.0 - x) + (B * (B * -0.16666666666666666))) / B; elseif (F <= 7.2e-56) tmp = x / (0.0 - B); else tmp = (1.0 - x) / B; end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -5.5e-45], N[(N[(N[(-1.0 - x), $MachinePrecision] + N[(B * N[(B * -0.16666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / B), $MachinePrecision], If[LessEqual[F, 7.2e-56], N[(x / N[(0.0 - B), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 - x), $MachinePrecision] / B), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -5.5 \cdot 10^{-45}:\\
\;\;\;\;\frac{\left(-1 - x\right) + B \cdot \left(B \cdot -0.16666666666666666\right)}{B}\\
\mathbf{elif}\;F \leq 7.2 \cdot 10^{-56}:\\
\;\;\;\;\frac{x}{0 - B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - x}{B}\\
\end{array}
\end{array}
if F < -5.5000000000000003e-45Initial program 67.3%
+-commutativeN/A
div-invN/A
unsub-negN/A
--lowering--.f64N/A
Applied egg-rr67.6%
Taylor expanded in F around -inf
/-lowering-/.f6477.5%
Simplified77.5%
Taylor expanded in B around 0
/-lowering-/.f64N/A
sub-negN/A
+-lowering-+.f64N/A
unpow2N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
--lowering--.f6453.1%
Simplified53.1%
Taylor expanded in x around 0
*-commutativeN/A
*-lowering-*.f6453.2%
Simplified53.2%
if -5.5000000000000003e-45 < F < 7.19999999999999956e-56Initial program 99.6%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6456.2%
Simplified56.2%
Taylor expanded in F around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6444.7%
Simplified44.7%
if 7.19999999999999956e-56 < F Initial program 63.4%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6440.9%
Simplified40.9%
Taylor expanded in F around inf
/-lowering-/.f64N/A
--lowering--.f6446.2%
Simplified46.2%
Final simplification48.0%
(FPCore (F B x) :precision binary64 (if (<= F -2.05e-47) (/ (- -1.0 x) B) (if (<= F 6.3e-55) (/ x (- 0.0 B)) (/ (- 1.0 x) B))))
double code(double F, double B, double x) {
double tmp;
if (F <= -2.05e-47) {
tmp = (-1.0 - x) / B;
} else if (F <= 6.3e-55) {
tmp = x / (0.0 - 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 <= (-2.05d-47)) then
tmp = ((-1.0d0) - x) / b
else if (f <= 6.3d-55) then
tmp = x / (0.0d0 - 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 <= -2.05e-47) {
tmp = (-1.0 - x) / B;
} else if (F <= 6.3e-55) {
tmp = x / (0.0 - B);
} else {
tmp = (1.0 - x) / B;
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -2.05e-47: tmp = (-1.0 - x) / B elif F <= 6.3e-55: tmp = x / (0.0 - B) else: tmp = (1.0 - x) / B return tmp
function code(F, B, x) tmp = 0.0 if (F <= -2.05e-47) tmp = Float64(Float64(-1.0 - x) / B); elseif (F <= 6.3e-55) tmp = Float64(x / Float64(0.0 - 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 <= -2.05e-47) tmp = (-1.0 - x) / B; elseif (F <= 6.3e-55) tmp = x / (0.0 - B); else tmp = (1.0 - x) / B; end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -2.05e-47], N[(N[(-1.0 - x), $MachinePrecision] / B), $MachinePrecision], If[LessEqual[F, 6.3e-55], N[(x / N[(0.0 - B), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 - x), $MachinePrecision] / B), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -2.05 \cdot 10^{-47}:\\
\;\;\;\;\frac{-1 - x}{B}\\
\mathbf{elif}\;F \leq 6.3 \cdot 10^{-55}:\\
\;\;\;\;\frac{x}{0 - B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - x}{B}\\
\end{array}
\end{array}
if F < -2.05000000000000001e-47Initial program 67.3%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6444.3%
Simplified44.3%
Taylor expanded in F around -inf
associate-*r/N/A
mul-1-negN/A
/-lowering-/.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
--lowering--.f6452.8%
Simplified52.8%
if -2.05000000000000001e-47 < F < 6.2999999999999997e-55Initial program 99.6%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6456.2%
Simplified56.2%
Taylor expanded in F around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6444.7%
Simplified44.7%
if 6.2999999999999997e-55 < F Initial program 63.4%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6440.9%
Simplified40.9%
Taylor expanded in F around inf
/-lowering-/.f64N/A
--lowering--.f6446.2%
Simplified46.2%
Final simplification47.9%
(FPCore (F B x) :precision binary64 (if (<= F -1.7e-47) (/ (- -1.0 x) B) (if (<= F 3.15e+122) (/ x (- 0.0 B)) (/ 1.0 B))))
double code(double F, double B, double x) {
double tmp;
if (F <= -1.7e-47) {
tmp = (-1.0 - x) / B;
} else if (F <= 3.15e+122) {
tmp = x / (0.0 - B);
} else {
tmp = 1.0 / 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.7d-47)) then
tmp = ((-1.0d0) - x) / b
else if (f <= 3.15d+122) then
tmp = x / (0.0d0 - b)
else
tmp = 1.0d0 / b
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= -1.7e-47) {
tmp = (-1.0 - x) / B;
} else if (F <= 3.15e+122) {
tmp = x / (0.0 - B);
} else {
tmp = 1.0 / B;
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -1.7e-47: tmp = (-1.0 - x) / B elif F <= 3.15e+122: tmp = x / (0.0 - B) else: tmp = 1.0 / B return tmp
function code(F, B, x) tmp = 0.0 if (F <= -1.7e-47) tmp = Float64(Float64(-1.0 - x) / B); elseif (F <= 3.15e+122) tmp = Float64(x / Float64(0.0 - B)); else tmp = Float64(1.0 / B); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -1.7e-47) tmp = (-1.0 - x) / B; elseif (F <= 3.15e+122) tmp = x / (0.0 - B); else tmp = 1.0 / B; end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -1.7e-47], N[(N[(-1.0 - x), $MachinePrecision] / B), $MachinePrecision], If[LessEqual[F, 3.15e+122], N[(x / N[(0.0 - B), $MachinePrecision]), $MachinePrecision], N[(1.0 / B), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -1.7 \cdot 10^{-47}:\\
\;\;\;\;\frac{-1 - x}{B}\\
\mathbf{elif}\;F \leq 3.15 \cdot 10^{+122}:\\
\;\;\;\;\frac{x}{0 - B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{B}\\
\end{array}
\end{array}
if F < -1.7000000000000001e-47Initial program 67.3%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6444.3%
Simplified44.3%
Taylor expanded in F around -inf
associate-*r/N/A
mul-1-negN/A
/-lowering-/.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
--lowering--.f6452.8%
Simplified52.8%
if -1.7000000000000001e-47 < F < 3.1500000000000001e122Initial program 98.1%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6456.4%
Simplified56.4%
Taylor expanded in F around 0
mul-1-negN/A
neg-sub0N/A
--lowering--.f6440.9%
Simplified40.9%
if 3.1500000000000001e122 < F Initial program 36.9%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.7%
Simplified99.7%
Taylor expanded in x around 0
/-lowering-/.f64N/A
sin-lowering-sin.f6455.3%
Simplified55.3%
Taylor expanded in B around 0
/-lowering-/.f6432.1%
Simplified32.1%
Final simplification43.4%
(FPCore (F B x) :precision binary64 (if (<= F 1.85e+122) (/ (- -1.0 x) B) (/ 1.0 B)))
double code(double F, double B, double x) {
double tmp;
if (F <= 1.85e+122) {
tmp = (-1.0 - x) / B;
} else {
tmp = 1.0 / 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.85d+122) then
tmp = ((-1.0d0) - x) / b
else
tmp = 1.0d0 / b
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= 1.85e+122) {
tmp = (-1.0 - x) / B;
} else {
tmp = 1.0 / B;
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= 1.85e+122: tmp = (-1.0 - x) / B else: tmp = 1.0 / B return tmp
function code(F, B, x) tmp = 0.0 if (F <= 1.85e+122) tmp = Float64(Float64(-1.0 - x) / B); else tmp = Float64(1.0 / B); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= 1.85e+122) tmp = (-1.0 - x) / B; else tmp = 1.0 / B; end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, 1.85e+122], N[(N[(-1.0 - x), $MachinePrecision] / B), $MachinePrecision], N[(1.0 / B), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq 1.85 \cdot 10^{+122}:\\
\;\;\;\;\frac{-1 - x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{B}\\
\end{array}
\end{array}
if F < 1.8499999999999998e122Initial program 85.7%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6451.6%
Simplified51.6%
Taylor expanded in F around -inf
associate-*r/N/A
mul-1-negN/A
/-lowering-/.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
--lowering--.f6434.9%
Simplified34.9%
if 1.8499999999999998e122 < F Initial program 36.9%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.7%
Simplified99.7%
Taylor expanded in x around 0
/-lowering-/.f64N/A
sin-lowering-sin.f6455.3%
Simplified55.3%
Taylor expanded in B around 0
/-lowering-/.f6432.1%
Simplified32.1%
(FPCore (F B x) :precision binary64 (if (<= F 2.4e-126) (/ -1.0 B) (/ 1.0 B)))
double code(double F, double B, double x) {
double tmp;
if (F <= 2.4e-126) {
tmp = -1.0 / B;
} else {
tmp = 1.0 / 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 <= 2.4d-126) then
tmp = (-1.0d0) / b
else
tmp = 1.0d0 / b
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= 2.4e-126) {
tmp = -1.0 / B;
} else {
tmp = 1.0 / B;
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= 2.4e-126: tmp = -1.0 / B else: tmp = 1.0 / B return tmp
function code(F, B, x) tmp = 0.0 if (F <= 2.4e-126) tmp = Float64(-1.0 / B); else tmp = Float64(1.0 / B); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= 2.4e-126) tmp = -1.0 / B; else tmp = 1.0 / B; end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, 2.4e-126], N[(-1.0 / B), $MachinePrecision], N[(1.0 / B), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq 2.4 \cdot 10^{-126}:\\
\;\;\;\;\frac{-1}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{B}\\
\end{array}
\end{array}
if F < 2.40000000000000007e-126Initial program 83.1%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6449.5%
Simplified49.5%
Taylor expanded in F around -inf
associate-*r/N/A
mul-1-negN/A
/-lowering-/.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
--lowering--.f6436.7%
Simplified36.7%
Taylor expanded in x around 0
/-lowering-/.f6415.3%
Simplified15.3%
if 2.40000000000000007e-126 < F Initial program 67.1%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6481.6%
Simplified81.6%
Taylor expanded in x around 0
/-lowering-/.f64N/A
sin-lowering-sin.f6439.0%
Simplified39.0%
Taylor expanded in B around 0
/-lowering-/.f6422.0%
Simplified22.0%
(FPCore (F B x) :precision binary64 (/ -1.0 B))
double code(double F, double B, double x) {
return -1.0 / B;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
code = (-1.0d0) / b
end function
public static double code(double F, double B, double x) {
return -1.0 / B;
}
def code(F, B, x): return -1.0 / B
function code(F, B, x) return Float64(-1.0 / B) end
function tmp = code(F, B, x) tmp = -1.0 / B; end
code[F_, B_, x_] := N[(-1.0 / B), $MachinePrecision]
\begin{array}{l}
\\
\frac{-1}{B}
\end{array}
Initial program 77.7%
Taylor expanded in B around 0
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6447.5%
Simplified47.5%
Taylor expanded in F around -inf
associate-*r/N/A
mul-1-negN/A
/-lowering-/.f64N/A
distribute-neg-inN/A
metadata-evalN/A
unsub-negN/A
--lowering--.f6432.3%
Simplified32.3%
Taylor expanded in x around 0
/-lowering-/.f6411.0%
Simplified11.0%
herbie shell --seed 2024288
(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))))))