
(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 27 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 -2e+35)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 5.4e+28)
(- (/ (pow (+ (* F F) (+ 2.0 (* x 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 <= -2e+35) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 5.4e+28) {
tmp = (pow(((F * F) + (2.0 + (x * 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 <= (-2d+35)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 5.4d+28) then
tmp = ((((f * f) + (2.0d0 + (x * 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 <= -2e+35) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 5.4e+28) {
tmp = (Math.pow(((F * F) + (2.0 + (x * 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 <= -2e+35: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 5.4e+28: tmp = (math.pow(((F * F) + (2.0 + (x * 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 <= -2e+35) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 5.4e+28) tmp = Float64(Float64((Float64(Float64(F * F) + Float64(2.0 + Float64(x * 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 <= -2e+35) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 5.4e+28) tmp = ((((F * F) + (2.0 + (x * 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, -2e+35], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 5.4e+28], N[(N[(N[Power[N[(N[(F * F), $MachinePrecision] + N[(2.0 + N[(x * 2.0), $MachinePrecision]), $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 -2 \cdot 10^{+35}:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 5.4 \cdot 10^{+28}:\\
\;\;\;\;\frac{{\left(F \cdot F + \left(2 + x \cdot 2\right)\right)}^{-0.5}}{\frac{\sin B}{F}} - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -1.9999999999999999e35Initial program 54.4%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified74.8%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
if -1.9999999999999999e35 < F < 5.4000000000000003e28Initial program 99.4%
+-commutativeN/A
div-invN/A
sub-negN/A
--lowering--.f64N/A
Applied egg-rr99.7%
if 5.4000000000000003e28 < F Initial program 57.6%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified74.1%
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+152)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 1e+25)
(- (/ (* F (sqrt (/ 1.0 (+ (* F F) 2.0)))) (sin B)) t_0)
(- (/ 1.0 (sin B)) t_0)))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -2e+152) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 1e+25) {
tmp = ((F * sqrt((1.0 / ((F * F) + 2.0)))) / 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 <= (-2d+152)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 1d+25) then
tmp = ((f * sqrt((1.0d0 / ((f * f) + 2.0d0)))) / 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 <= -2e+152) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 1e+25) {
tmp = ((F * Math.sqrt((1.0 / ((F * F) + 2.0)))) / 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 <= -2e+152: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 1e+25: tmp = ((F * math.sqrt((1.0 / ((F * F) + 2.0)))) / 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 <= -2e+152) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 1e+25) 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)) - t_0); end return tmp end
function tmp_2 = code(F, B, x) t_0 = x / tan(B); tmp = 0.0; if (F <= -2e+152) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 1e+25) tmp = ((F * sqrt((1.0 / ((F * F) + 2.0)))) / 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, -2e+152], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 1e+25], 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] - t$95$0), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -2 \cdot 10^{+152}:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 10^{+25}:\\
\;\;\;\;\frac{F \cdot \sqrt{\frac{1}{F \cdot F + 2}}}{\sin B} - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -2.0000000000000001e152Initial program 42.6%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified60.4%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
if -2.0000000000000001e152 < F < 1.00000000000000009e25Initial program 95.6%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.7%
Simplified99.7%
if 1.00000000000000009e25 < F Initial program 58.8%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified74.8%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
Final simplification99.8%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -1.4)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 1.42)
(- (/ (* 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.4) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 1.42) {
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.4d0)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 1.42d0) 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.4) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 1.42) {
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.4: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 1.42: 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.4) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 1.42) 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.4) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 1.42) 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.4], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 1.42], 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.4:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 1.42:\\
\;\;\;\;\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.3999999999999999Initial program 57.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified76.3%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6498.9%
Simplified98.9%
if -1.3999999999999999 < F < 1.4199999999999999Initial program 99.4%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.7%
Simplified99.7%
Taylor expanded in F around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
sin-lowering-sin.f6499.1%
Simplified99.1%
if 1.4199999999999999 < F Initial program 62.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified77.1%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6498.5%
Simplified98.5%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ 1.0 (* (sin B) (/ (sqrt (+ (* F F) 2.0)) F))))
(t_1 (/ x (tan B))))
(if (<= F -310000000000.0)
(- (/ -1.0 (sin B)) t_1)
(if (<= F -3e-103)
t_0
(if (<= F 2.35e-56)
(- 0.0 t_1)
(if (<= F 430000.0) t_0 (- (/ 1.0 (sin B)) t_1)))))))
double code(double F, double B, double x) {
double t_0 = 1.0 / (sin(B) * (sqrt(((F * F) + 2.0)) / F));
double t_1 = x / tan(B);
double tmp;
if (F <= -310000000000.0) {
tmp = (-1.0 / sin(B)) - t_1;
} else if (F <= -3e-103) {
tmp = t_0;
} else if (F <= 2.35e-56) {
tmp = 0.0 - t_1;
} else if (F <= 430000.0) {
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 = 1.0d0 / (sin(b) * (sqrt(((f * f) + 2.0d0)) / f))
t_1 = x / tan(b)
if (f <= (-310000000000.0d0)) then
tmp = ((-1.0d0) / sin(b)) - t_1
else if (f <= (-3d-103)) then
tmp = t_0
else if (f <= 2.35d-56) then
tmp = 0.0d0 - t_1
else if (f <= 430000.0d0) 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 = 1.0 / (Math.sin(B) * (Math.sqrt(((F * F) + 2.0)) / F));
double t_1 = x / Math.tan(B);
double tmp;
if (F <= -310000000000.0) {
tmp = (-1.0 / Math.sin(B)) - t_1;
} else if (F <= -3e-103) {
tmp = t_0;
} else if (F <= 2.35e-56) {
tmp = 0.0 - t_1;
} else if (F <= 430000.0) {
tmp = t_0;
} else {
tmp = (1.0 / Math.sin(B)) - t_1;
}
return tmp;
}
def code(F, B, x): t_0 = 1.0 / (math.sin(B) * (math.sqrt(((F * F) + 2.0)) / F)) t_1 = x / math.tan(B) tmp = 0 if F <= -310000000000.0: tmp = (-1.0 / math.sin(B)) - t_1 elif F <= -3e-103: tmp = t_0 elif F <= 2.35e-56: tmp = 0.0 - t_1 elif F <= 430000.0: tmp = t_0 else: tmp = (1.0 / math.sin(B)) - t_1 return tmp
function code(F, B, x) t_0 = Float64(1.0 / Float64(sin(B) * Float64(sqrt(Float64(Float64(F * F) + 2.0)) / F))) t_1 = Float64(x / tan(B)) tmp = 0.0 if (F <= -310000000000.0) tmp = Float64(Float64(-1.0 / sin(B)) - t_1); elseif (F <= -3e-103) tmp = t_0; elseif (F <= 2.35e-56) tmp = Float64(0.0 - t_1); elseif (F <= 430000.0) 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 = 1.0 / (sin(B) * (sqrt(((F * F) + 2.0)) / F)); t_1 = x / tan(B); tmp = 0.0; if (F <= -310000000000.0) tmp = (-1.0 / sin(B)) - t_1; elseif (F <= -3e-103) tmp = t_0; elseif (F <= 2.35e-56) tmp = 0.0 - t_1; elseif (F <= 430000.0) 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[(1.0 / N[(N[Sin[B], $MachinePrecision] * N[(N[Sqrt[N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision]], $MachinePrecision] / F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -310000000000.0], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[F, -3e-103], t$95$0, If[LessEqual[F, 2.35e-56], N[(0.0 - t$95$1), $MachinePrecision], If[LessEqual[F, 430000.0], 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{1}{\sin B \cdot \frac{\sqrt{F \cdot F + 2}}{F}}\\
t_1 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -310000000000:\\
\;\;\;\;\frac{-1}{\sin B} - t\_1\\
\mathbf{elif}\;F \leq -3 \cdot 10^{-103}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;F \leq 2.35 \cdot 10^{-56}:\\
\;\;\;\;0 - t\_1\\
\mathbf{elif}\;F \leq 430000:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_1\\
\end{array}
\end{array}
if F < -3.1e11Initial program 55.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified75.2%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
if -3.1e11 < F < -3e-103 or 2.35e-56 < F < 4.3e5Initial program 99.2%
Taylor expanded in x around 0
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sin-lowering-sin.f6480.7%
Simplified80.7%
associate-*r/N/A
sqrt-divN/A
metadata-evalN/A
unpow1/2N/A
div-invN/A
clear-numN/A
associate-/l/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f64N/A
unpow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f6480.8%
Applied egg-rr80.8%
if -3e-103 < F < 2.35e-56Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.8%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.8%
Simplified99.8%
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.f6486.3%
Simplified86.3%
distribute-frac-neg2N/A
clear-numN/A
associate-/l/N/A
tan-quotN/A
clear-numN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
tan-lowering-tan.f6486.5%
Applied egg-rr86.5%
if 4.3e5 < F Initial program 61.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified76.2%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
Final simplification93.0%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (* F (/ (sqrt (/ 1.0 (+ (* F F) 2.0))) (sin B))))
(t_1 (/ x (tan B))))
(if (<= F -310000000000.0)
(- (/ -1.0 (sin B)) t_1)
(if (<= F -5.6e-99)
t_0
(if (<= F 6.6e-73)
(- 0.0 t_1)
(if (<= F 430000.0) t_0 (- (/ 1.0 (sin B)) t_1)))))))
double code(double F, double B, double x) {
double t_0 = F * (sqrt((1.0 / ((F * F) + 2.0))) / sin(B));
double t_1 = x / tan(B);
double tmp;
if (F <= -310000000000.0) {
tmp = (-1.0 / sin(B)) - t_1;
} else if (F <= -5.6e-99) {
tmp = t_0;
} else if (F <= 6.6e-73) {
tmp = 0.0 - t_1;
} else if (F <= 430000.0) {
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((1.0d0 / ((f * f) + 2.0d0))) / sin(b))
t_1 = x / tan(b)
if (f <= (-310000000000.0d0)) then
tmp = ((-1.0d0) / sin(b)) - t_1
else if (f <= (-5.6d-99)) then
tmp = t_0
else if (f <= 6.6d-73) then
tmp = 0.0d0 - t_1
else if (f <= 430000.0d0) 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((1.0 / ((F * F) + 2.0))) / Math.sin(B));
double t_1 = x / Math.tan(B);
double tmp;
if (F <= -310000000000.0) {
tmp = (-1.0 / Math.sin(B)) - t_1;
} else if (F <= -5.6e-99) {
tmp = t_0;
} else if (F <= 6.6e-73) {
tmp = 0.0 - t_1;
} else if (F <= 430000.0) {
tmp = t_0;
} else {
tmp = (1.0 / Math.sin(B)) - t_1;
}
return tmp;
}
def code(F, B, x): t_0 = F * (math.sqrt((1.0 / ((F * F) + 2.0))) / math.sin(B)) t_1 = x / math.tan(B) tmp = 0 if F <= -310000000000.0: tmp = (-1.0 / math.sin(B)) - t_1 elif F <= -5.6e-99: tmp = t_0 elif F <= 6.6e-73: tmp = 0.0 - t_1 elif F <= 430000.0: tmp = t_0 else: tmp = (1.0 / math.sin(B)) - t_1 return tmp
function code(F, B, x) t_0 = Float64(F * Float64(sqrt(Float64(1.0 / Float64(Float64(F * F) + 2.0))) / sin(B))) t_1 = Float64(x / tan(B)) tmp = 0.0 if (F <= -310000000000.0) tmp = Float64(Float64(-1.0 / sin(B)) - t_1); elseif (F <= -5.6e-99) tmp = t_0; elseif (F <= 6.6e-73) tmp = Float64(0.0 - t_1); elseif (F <= 430000.0) 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((1.0 / ((F * F) + 2.0))) / sin(B)); t_1 = x / tan(B); tmp = 0.0; if (F <= -310000000000.0) tmp = (-1.0 / sin(B)) - t_1; elseif (F <= -5.6e-99) tmp = t_0; elseif (F <= 6.6e-73) tmp = 0.0 - t_1; elseif (F <= 430000.0) 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[(F * N[(N[Sqrt[N[(1.0 / N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -310000000000.0], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[F, -5.6e-99], t$95$0, If[LessEqual[F, 6.6e-73], N[(0.0 - t$95$1), $MachinePrecision], If[LessEqual[F, 430000.0], t$95$0, N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision]]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := F \cdot \frac{\sqrt{\frac{1}{F \cdot F + 2}}}{\sin B}\\
t_1 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -310000000000:\\
\;\;\;\;\frac{-1}{\sin B} - t\_1\\
\mathbf{elif}\;F \leq -5.6 \cdot 10^{-99}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;F \leq 6.6 \cdot 10^{-73}:\\
\;\;\;\;0 - t\_1\\
\mathbf{elif}\;F \leq 430000:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_1\\
\end{array}
\end{array}
if F < -3.1e11Initial program 55.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified75.2%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
if -3.1e11 < F < -5.6000000000000001e-99 or 6.60000000000000007e-73 < F < 4.3e5Initial program 99.2%
Taylor expanded in x around 0
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sin-lowering-sin.f6479.1%
Simplified79.1%
if -5.6000000000000001e-99 < F < 6.60000000000000007e-73Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.8%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.8%
Simplified99.8%
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.f6487.0%
Simplified87.0%
distribute-frac-neg2N/A
clear-numN/A
associate-/l/N/A
tan-quotN/A
clear-numN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
tan-lowering-tan.f6487.2%
Applied egg-rr87.2%
if 4.3e5 < F Initial program 61.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified76.2%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
Final simplification93.0%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ F (/ (sin B) (pow (+ (* F F) 2.0) -0.5)))) (t_1 (/ x (tan B))))
(if (<= F -310000000000.0)
(- (/ -1.0 (sin B)) t_1)
(if (<= F -4.9e-100)
t_0
(if (<= F 1.25e-69)
(- 0.0 t_1)
(if (<= F 430000.0) t_0 (- (/ 1.0 (sin B)) t_1)))))))
double code(double F, double B, double x) {
double t_0 = F / (sin(B) / pow(((F * F) + 2.0), -0.5));
double t_1 = x / tan(B);
double tmp;
if (F <= -310000000000.0) {
tmp = (-1.0 / sin(B)) - t_1;
} else if (F <= -4.9e-100) {
tmp = t_0;
} else if (F <= 1.25e-69) {
tmp = 0.0 - t_1;
} else if (F <= 430000.0) {
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 / (sin(b) / (((f * f) + 2.0d0) ** (-0.5d0)))
t_1 = x / tan(b)
if (f <= (-310000000000.0d0)) then
tmp = ((-1.0d0) / sin(b)) - t_1
else if (f <= (-4.9d-100)) then
tmp = t_0
else if (f <= 1.25d-69) then
tmp = 0.0d0 - t_1
else if (f <= 430000.0d0) 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.sin(B) / Math.pow(((F * F) + 2.0), -0.5));
double t_1 = x / Math.tan(B);
double tmp;
if (F <= -310000000000.0) {
tmp = (-1.0 / Math.sin(B)) - t_1;
} else if (F <= -4.9e-100) {
tmp = t_0;
} else if (F <= 1.25e-69) {
tmp = 0.0 - t_1;
} else if (F <= 430000.0) {
tmp = t_0;
} else {
tmp = (1.0 / Math.sin(B)) - t_1;
}
return tmp;
}
def code(F, B, x): t_0 = F / (math.sin(B) / math.pow(((F * F) + 2.0), -0.5)) t_1 = x / math.tan(B) tmp = 0 if F <= -310000000000.0: tmp = (-1.0 / math.sin(B)) - t_1 elif F <= -4.9e-100: tmp = t_0 elif F <= 1.25e-69: tmp = 0.0 - t_1 elif F <= 430000.0: tmp = t_0 else: tmp = (1.0 / math.sin(B)) - t_1 return tmp
function code(F, B, x) t_0 = Float64(F / Float64(sin(B) / (Float64(Float64(F * F) + 2.0) ^ -0.5))) t_1 = Float64(x / tan(B)) tmp = 0.0 if (F <= -310000000000.0) tmp = Float64(Float64(-1.0 / sin(B)) - t_1); elseif (F <= -4.9e-100) tmp = t_0; elseif (F <= 1.25e-69) tmp = Float64(0.0 - t_1); elseif (F <= 430000.0) 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 / (sin(B) / (((F * F) + 2.0) ^ -0.5)); t_1 = x / tan(B); tmp = 0.0; if (F <= -310000000000.0) tmp = (-1.0 / sin(B)) - t_1; elseif (F <= -4.9e-100) tmp = t_0; elseif (F <= 1.25e-69) tmp = 0.0 - t_1; elseif (F <= 430000.0) 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[(F / N[(N[Sin[B], $MachinePrecision] / N[Power[N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision], -0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -310000000000.0], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$1), $MachinePrecision], If[LessEqual[F, -4.9e-100], t$95$0, If[LessEqual[F, 1.25e-69], N[(0.0 - t$95$1), $MachinePrecision], If[LessEqual[F, 430000.0], 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{F}{\frac{\sin B}{{\left(F \cdot F + 2\right)}^{-0.5}}}\\
t_1 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -310000000000:\\
\;\;\;\;\frac{-1}{\sin B} - t\_1\\
\mathbf{elif}\;F \leq -4.9 \cdot 10^{-100}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;F \leq 1.25 \cdot 10^{-69}:\\
\;\;\;\;0 - t\_1\\
\mathbf{elif}\;F \leq 430000:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_1\\
\end{array}
\end{array}
if F < -3.1e11Initial program 55.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified75.2%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
if -3.1e11 < F < -4.9000000000000003e-100 or 1.25000000000000008e-69 < F < 4.3e5Initial program 99.2%
Taylor expanded in x around 0
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sin-lowering-sin.f6479.1%
Simplified79.1%
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
pow1/2N/A
inv-powN/A
pow-powN/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
metadata-eval79.0%
Applied egg-rr79.0%
if -4.9000000000000003e-100 < F < 1.25000000000000008e-69Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.8%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.8%
Simplified99.8%
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.f6487.0%
Simplified87.0%
distribute-frac-neg2N/A
clear-numN/A
associate-/l/N/A
tan-quotN/A
clear-numN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
tan-lowering-tan.f6487.2%
Applied egg-rr87.2%
if 4.3e5 < F Initial program 61.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified76.2%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
Final simplification93.0%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -310000000000.0)
(- (/ -1.0 (sin B)) t_0)
(if (<= F -8.5e-106)
(-
(* (/ F (sin B)) (/ 1.0 (sqrt (+ (* F F) (+ 2.0 (* x 2.0))))))
(/ x B))
(if (<= F 18000.0)
(- (* (sqrt (/ 1.0 (+ (* F F) 2.0))) (/ F 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 <= -310000000000.0) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= -8.5e-106) {
tmp = ((F / sin(B)) * (1.0 / sqrt(((F * F) + (2.0 + (x * 2.0)))))) - (x / B);
} else if (F <= 18000.0) {
tmp = (sqrt((1.0 / ((F * F) + 2.0))) * (F / 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 <= (-310000000000.0d0)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= (-8.5d-106)) then
tmp = ((f / sin(b)) * (1.0d0 / sqrt(((f * f) + (2.0d0 + (x * 2.0d0)))))) - (x / b)
else if (f <= 18000.0d0) then
tmp = (sqrt((1.0d0 / ((f * f) + 2.0d0))) * (f / 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 <= -310000000000.0) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= -8.5e-106) {
tmp = ((F / Math.sin(B)) * (1.0 / Math.sqrt(((F * F) + (2.0 + (x * 2.0)))))) - (x / B);
} else if (F <= 18000.0) {
tmp = (Math.sqrt((1.0 / ((F * F) + 2.0))) * (F / 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 <= -310000000000.0: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= -8.5e-106: tmp = ((F / math.sin(B)) * (1.0 / math.sqrt(((F * F) + (2.0 + (x * 2.0)))))) - (x / B) elif F <= 18000.0: tmp = (math.sqrt((1.0 / ((F * F) + 2.0))) * (F / 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 <= -310000000000.0) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= -8.5e-106) tmp = Float64(Float64(Float64(F / sin(B)) * Float64(1.0 / sqrt(Float64(Float64(F * F) + Float64(2.0 + Float64(x * 2.0)))))) - Float64(x / B)); elseif (F <= 18000.0) tmp = Float64(Float64(sqrt(Float64(1.0 / Float64(Float64(F * F) + 2.0))) * Float64(F / 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 <= -310000000000.0) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= -8.5e-106) tmp = ((F / sin(B)) * (1.0 / sqrt(((F * F) + (2.0 + (x * 2.0)))))) - (x / B); elseif (F <= 18000.0) tmp = (sqrt((1.0 / ((F * F) + 2.0))) * (F / 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, -310000000000.0], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, -8.5e-106], N[(N[(N[(F / N[Sin[B], $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[Sqrt[N[(N[(F * F), $MachinePrecision] + N[(2.0 + N[(x * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(x / B), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 18000.0], N[(N[(N[Sqrt[N[(1.0 / N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(F / 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 -310000000000:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq -8.5 \cdot 10^{-106}:\\
\;\;\;\;\frac{F}{\sin B} \cdot \frac{1}{\sqrt{F \cdot F + \left(2 + x \cdot 2\right)}} - \frac{x}{B}\\
\mathbf{elif}\;F \leq 18000:\\
\;\;\;\;\sqrt{\frac{1}{F \cdot F + 2}} \cdot \frac{F}{B} - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -3.1e11Initial program 55.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified75.2%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
if -3.1e11 < F < -8.4999999999999998e-106Initial program 99.2%
Taylor expanded in B around 0
/-lowering-/.f6492.9%
Simplified92.9%
*-commutativeN/A
associate-+r+N/A
pow-flipN/A
metadata-evalN/A
pow1/2N/A
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
associate-+r+N/A
/-lowering-/.f64N/A
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
associate-+r+N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6493.0%
Applied egg-rr93.0%
if -8.4999999999999998e-106 < F < 18000Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in B around 0
*-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6494.0%
Simplified94.0%
if 18000 < F Initial program 62.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified76.8%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.0%
Simplified99.0%
Final simplification96.8%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -1000000000000.0)
(- (/ -1.0 (sin B)) t_0)
(if (<= F -4.6e-105)
(- (/ (* F (pow (+ (* F F) (+ 2.0 (* x 2.0))) -0.5)) (sin B)) (/ x B))
(if (<= F 20000.0)
(- (* (sqrt (/ 1.0 (+ (* F F) 2.0))) (/ F 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 <= -1000000000000.0) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= -4.6e-105) {
tmp = ((F * pow(((F * F) + (2.0 + (x * 2.0))), -0.5)) / sin(B)) - (x / B);
} else if (F <= 20000.0) {
tmp = (sqrt((1.0 / ((F * F) + 2.0))) * (F / 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 <= (-1000000000000.0d0)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= (-4.6d-105)) then
tmp = ((f * (((f * f) + (2.0d0 + (x * 2.0d0))) ** (-0.5d0))) / sin(b)) - (x / b)
else if (f <= 20000.0d0) then
tmp = (sqrt((1.0d0 / ((f * f) + 2.0d0))) * (f / 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 <= -1000000000000.0) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= -4.6e-105) {
tmp = ((F * Math.pow(((F * F) + (2.0 + (x * 2.0))), -0.5)) / Math.sin(B)) - (x / B);
} else if (F <= 20000.0) {
tmp = (Math.sqrt((1.0 / ((F * F) + 2.0))) * (F / 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 <= -1000000000000.0: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= -4.6e-105: tmp = ((F * math.pow(((F * F) + (2.0 + (x * 2.0))), -0.5)) / math.sin(B)) - (x / B) elif F <= 20000.0: tmp = (math.sqrt((1.0 / ((F * F) + 2.0))) * (F / 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 <= -1000000000000.0) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= -4.6e-105) tmp = Float64(Float64(Float64(F * (Float64(Float64(F * F) + Float64(2.0 + Float64(x * 2.0))) ^ -0.5)) / sin(B)) - Float64(x / B)); elseif (F <= 20000.0) tmp = Float64(Float64(sqrt(Float64(1.0 / Float64(Float64(F * F) + 2.0))) * Float64(F / 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 <= -1000000000000.0) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= -4.6e-105) tmp = ((F * (((F * F) + (2.0 + (x * 2.0))) ^ -0.5)) / sin(B)) - (x / B); elseif (F <= 20000.0) tmp = (sqrt((1.0 / ((F * F) + 2.0))) * (F / 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, -1000000000000.0], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, -4.6e-105], 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], If[LessEqual[F, 20000.0], N[(N[(N[Sqrt[N[(1.0 / N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(F / 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 -1000000000000:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq -4.6 \cdot 10^{-105}:\\
\;\;\;\;\frac{F \cdot {\left(F \cdot F + \left(2 + x \cdot 2\right)\right)}^{-0.5}}{\sin B} - \frac{x}{B}\\
\mathbf{elif}\;F \leq 20000:\\
\;\;\;\;\sqrt{\frac{1}{F \cdot F + 2}} \cdot \frac{F}{B} - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -1e12Initial program 55.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified75.2%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
if -1e12 < F < -4.6000000000000002e-105Initial program 99.2%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.5%
Taylor expanded in B around 0
/-lowering-/.f6492.9%
Simplified92.9%
if -4.6000000000000002e-105 < F < 2e4Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.8%
Simplified99.8%
Taylor expanded in B around 0
*-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6494.0%
Simplified94.0%
if 2e4 < F Initial program 62.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified76.8%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.0%
Simplified99.0%
Final simplification96.8%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -3.8e+31)
(- (/ -1.0 (sin B)) t_0)
(if (<= F 17000.0)
(- (* (sqrt (/ 1.0 (+ (* F F) 2.0))) (/ F 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 <= -3.8e+31) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= 17000.0) {
tmp = (sqrt((1.0 / ((F * F) + 2.0))) * (F / 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 <= (-3.8d+31)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= 17000.0d0) then
tmp = (sqrt((1.0d0 / ((f * f) + 2.0d0))) * (f / 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 <= -3.8e+31) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= 17000.0) {
tmp = (Math.sqrt((1.0 / ((F * F) + 2.0))) * (F / 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 <= -3.8e+31: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= 17000.0: tmp = (math.sqrt((1.0 / ((F * F) + 2.0))) * (F / 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 <= -3.8e+31) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= 17000.0) tmp = Float64(Float64(sqrt(Float64(1.0 / Float64(Float64(F * F) + 2.0))) * Float64(F / 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 <= -3.8e+31) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= 17000.0) tmp = (sqrt((1.0 / ((F * F) + 2.0))) * (F / 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, -3.8e+31], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, 17000.0], N[(N[(N[Sqrt[N[(1.0 / N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(F / 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 -3.8 \cdot 10^{+31}:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq 17000:\\
\;\;\;\;\sqrt{\frac{1}{F \cdot F + 2}} \cdot \frac{F}{B} - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -3.8000000000000001e31Initial program 54.4%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified74.8%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.8%
Simplified99.8%
if -3.8000000000000001e31 < F < 17000Initial program 99.4%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.7%
Simplified99.7%
Taylor expanded in B around 0
*-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6488.5%
Simplified88.5%
if 17000 < F Initial program 62.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified76.8%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6499.0%
Simplified99.0%
Final simplification94.3%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -0.035)
(- (/ -1.0 (sin B)) t_0)
(if (<= F -4.45e-100)
(/ (* F (sqrt 0.5)) (sin B))
(if (<= F 9.6e-54) (- 0.0 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 <= -0.035) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= -4.45e-100) {
tmp = (F * sqrt(0.5)) / sin(B);
} else if (F <= 9.6e-54) {
tmp = 0.0 - 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 <= (-0.035d0)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= (-4.45d-100)) then
tmp = (f * sqrt(0.5d0)) / sin(b)
else if (f <= 9.6d-54) then
tmp = 0.0d0 - 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 <= -0.035) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= -4.45e-100) {
tmp = (F * Math.sqrt(0.5)) / Math.sin(B);
} else if (F <= 9.6e-54) {
tmp = 0.0 - 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 <= -0.035: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= -4.45e-100: tmp = (F * math.sqrt(0.5)) / math.sin(B) elif F <= 9.6e-54: tmp = 0.0 - 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 <= -0.035) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= -4.45e-100) tmp = Float64(Float64(F * sqrt(0.5)) / sin(B)); elseif (F <= 9.6e-54) tmp = Float64(0.0 - 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 <= -0.035) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= -4.45e-100) tmp = (F * sqrt(0.5)) / sin(B); elseif (F <= 9.6e-54) tmp = 0.0 - 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, -0.035], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, -4.45e-100], N[(N[(F * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 9.6e-54], N[(0.0 - 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 -0.035:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq -4.45 \cdot 10^{-100}:\\
\;\;\;\;\frac{F \cdot \sqrt{0.5}}{\sin B}\\
\mathbf{elif}\;F \leq 9.6 \cdot 10^{-54}:\\
\;\;\;\;0 - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - t\_0\\
\end{array}
\end{array}
if F < -0.035000000000000003Initial program 57.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified76.3%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6498.9%
Simplified98.9%
if -0.035000000000000003 < F < -4.4500000000000002e-100Initial program 99.1%
Taylor expanded in x around 0
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sin-lowering-sin.f6473.5%
Simplified73.5%
Taylor expanded in F around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
sin-lowering-sin.f6473.4%
Simplified73.4%
if -4.4500000000000002e-100 < F < 9.60000000000000053e-54Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.8%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.8%
Simplified99.8%
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.f6486.3%
Simplified86.3%
distribute-frac-neg2N/A
clear-numN/A
associate-/l/N/A
tan-quotN/A
clear-numN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
tan-lowering-tan.f6486.5%
Applied egg-rr86.5%
if 9.60000000000000053e-54 < F Initial program 65.2%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified78.7%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6493.1%
Simplified93.1%
Final simplification91.0%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (/ x (tan B))))
(if (<= F -0.042)
(- (/ -1.0 (sin B)) t_0)
(if (<= F -3e-100)
(/ (* F (sqrt 0.5)) (sin B))
(if (<= F 1.46e-53) (- 0.0 t_0) (- (/ 1.0 (sin B)) (/ x B)))))))
double code(double F, double B, double x) {
double t_0 = x / tan(B);
double tmp;
if (F <= -0.042) {
tmp = (-1.0 / sin(B)) - t_0;
} else if (F <= -3e-100) {
tmp = (F * sqrt(0.5)) / sin(B);
} else if (F <= 1.46e-53) {
tmp = 0.0 - t_0;
} else {
tmp = (1.0 / sin(B)) - (x / B);
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: t_0
real(8) :: tmp
t_0 = x / tan(b)
if (f <= (-0.042d0)) then
tmp = ((-1.0d0) / sin(b)) - t_0
else if (f <= (-3d-100)) then
tmp = (f * sqrt(0.5d0)) / sin(b)
else if (f <= 1.46d-53) then
tmp = 0.0d0 - t_0
else
tmp = (1.0d0 / sin(b)) - (x / b)
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double t_0 = x / Math.tan(B);
double tmp;
if (F <= -0.042) {
tmp = (-1.0 / Math.sin(B)) - t_0;
} else if (F <= -3e-100) {
tmp = (F * Math.sqrt(0.5)) / Math.sin(B);
} else if (F <= 1.46e-53) {
tmp = 0.0 - t_0;
} else {
tmp = (1.0 / Math.sin(B)) - (x / B);
}
return tmp;
}
def code(F, B, x): t_0 = x / math.tan(B) tmp = 0 if F <= -0.042: tmp = (-1.0 / math.sin(B)) - t_0 elif F <= -3e-100: tmp = (F * math.sqrt(0.5)) / math.sin(B) elif F <= 1.46e-53: tmp = 0.0 - t_0 else: tmp = (1.0 / math.sin(B)) - (x / B) return tmp
function code(F, B, x) t_0 = Float64(x / tan(B)) tmp = 0.0 if (F <= -0.042) tmp = Float64(Float64(-1.0 / sin(B)) - t_0); elseif (F <= -3e-100) tmp = Float64(Float64(F * sqrt(0.5)) / sin(B)); elseif (F <= 1.46e-53) tmp = Float64(0.0 - t_0); else tmp = Float64(Float64(1.0 / sin(B)) - Float64(x / B)); end return tmp end
function tmp_2 = code(F, B, x) t_0 = x / tan(B); tmp = 0.0; if (F <= -0.042) tmp = (-1.0 / sin(B)) - t_0; elseif (F <= -3e-100) tmp = (F * sqrt(0.5)) / sin(B); elseif (F <= 1.46e-53) tmp = 0.0 - t_0; else tmp = (1.0 / sin(B)) - (x / B); end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -0.042], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[F, -3e-100], N[(N[(F * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision] / N[Sin[B], $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 1.46e-53], N[(0.0 - t$95$0), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(x / B), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -0.042:\\
\;\;\;\;\frac{-1}{\sin B} - t\_0\\
\mathbf{elif}\;F \leq -3 \cdot 10^{-100}:\\
\;\;\;\;\frac{F \cdot \sqrt{0.5}}{\sin B}\\
\mathbf{elif}\;F \leq 1.46 \cdot 10^{-53}:\\
\;\;\;\;0 - t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - \frac{x}{B}\\
\end{array}
\end{array}
if F < -0.0420000000000000026Initial program 57.1%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified76.3%
Taylor expanded in F around -inf
/-lowering-/.f64N/A
sin-lowering-sin.f6498.9%
Simplified98.9%
if -0.0420000000000000026 < F < -3.0000000000000001e-100Initial program 99.1%
Taylor expanded in x around 0
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sin-lowering-sin.f6473.5%
Simplified73.5%
Taylor expanded in F around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
sin-lowering-sin.f6473.4%
Simplified73.4%
if -3.0000000000000001e-100 < F < 1.45999999999999989e-53Initial program 99.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.8%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.8%
Simplified99.8%
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.f6486.3%
Simplified86.3%
distribute-frac-neg2N/A
clear-numN/A
associate-/l/N/A
tan-quotN/A
clear-numN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
tan-lowering-tan.f6486.5%
Applied egg-rr86.5%
if 1.45999999999999989e-53 < F Initial program 65.2%
Taylor expanded in B around 0
/-lowering-/.f6444.2%
Simplified44.2%
Taylor expanded in F around inf
--lowering--.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f6471.0%
Simplified71.0%
Final simplification83.9%
(FPCore (F B x)
:precision binary64
(if (<= B 0.0038)
(/
(-
(+
(*
(sqrt (/ 1.0 (+ 2.0 (+ (* F F) (* x 2.0)))))
(+ F (* 0.16666666666666666 (* F (* B B)))))
(* B (* B (* x 0.3333333333333333))))
x)
B)
(- 0.0 (/ x (tan B)))))
double code(double F, double B, double x) {
double tmp;
if (B <= 0.0038) {
tmp = (((sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F + (0.16666666666666666 * (F * (B * B))))) + (B * (B * (x * 0.3333333333333333)))) - x) / B;
} else {
tmp = 0.0 - (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 <= 0.0038d0) then
tmp = (((sqrt((1.0d0 / (2.0d0 + ((f * f) + (x * 2.0d0))))) * (f + (0.16666666666666666d0 * (f * (b * b))))) + (b * (b * (x * 0.3333333333333333d0)))) - x) / b
else
tmp = 0.0d0 - (x / tan(b))
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (B <= 0.0038) {
tmp = (((Math.sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F + (0.16666666666666666 * (F * (B * B))))) + (B * (B * (x * 0.3333333333333333)))) - x) / B;
} else {
tmp = 0.0 - (x / Math.tan(B));
}
return tmp;
}
def code(F, B, x): tmp = 0 if B <= 0.0038: tmp = (((math.sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F + (0.16666666666666666 * (F * (B * B))))) + (B * (B * (x * 0.3333333333333333)))) - x) / B else: tmp = 0.0 - (x / math.tan(B)) return tmp
function code(F, B, x) tmp = 0.0 if (B <= 0.0038) tmp = Float64(Float64(Float64(Float64(sqrt(Float64(1.0 / Float64(2.0 + Float64(Float64(F * F) + Float64(x * 2.0))))) * Float64(F + Float64(0.16666666666666666 * Float64(F * Float64(B * B))))) + Float64(B * Float64(B * Float64(x * 0.3333333333333333)))) - x) / B); else tmp = Float64(0.0 - Float64(x / tan(B))); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (B <= 0.0038) tmp = (((sqrt((1.0 / (2.0 + ((F * F) + (x * 2.0))))) * (F + (0.16666666666666666 * (F * (B * B))))) + (B * (B * (x * 0.3333333333333333)))) - x) / B; else tmp = 0.0 - (x / tan(B)); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[B, 0.0038], 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[(0.16666666666666666 * N[(F * 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[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq 0.0038:\\
\;\;\;\;\frac{\left(\sqrt{\frac{1}{2 + \left(F \cdot F + x \cdot 2\right)}} \cdot \left(F + 0.16666666666666666 \cdot \left(F \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}{\tan B}\\
\end{array}
\end{array}
if B < 0.00379999999999999999Initial program 76.3%
Taylor expanded in B around 0
/-lowering-/.f64N/A
Simplified62.2%
if 0.00379999999999999999 < B Initial program 80.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified80.6%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6480.6%
Simplified80.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.f6460.2%
Simplified60.2%
distribute-frac-neg2N/A
clear-numN/A
associate-/l/N/A
tan-quotN/A
clear-numN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
tan-lowering-tan.f6460.3%
Applied egg-rr60.3%
Final simplification61.7%
(FPCore (F B x)
:precision binary64
(if (<= F -3.2e+153)
(/ -1.0 (/ (tan B) x))
(if (<= F -1.4e-45)
(/ (- (+ -1.0 (/ (+ 1.0 (* (* x 2.0) 0.5)) (* F F))) x) B)
(if (<= F 2.55e+88) (- 0.0 (/ x (tan B))) (/ 1.0 (sin B))))))
double code(double F, double B, double x) {
double tmp;
if (F <= -3.2e+153) {
tmp = -1.0 / (tan(B) / x);
} else if (F <= -1.4e-45) {
tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B;
} else if (F <= 2.55e+88) {
tmp = 0.0 - (x / tan(B));
} 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.2d+153)) then
tmp = (-1.0d0) / (tan(b) / x)
else if (f <= (-1.4d-45)) then
tmp = (((-1.0d0) + ((1.0d0 + ((x * 2.0d0) * 0.5d0)) / (f * f))) - x) / b
else if (f <= 2.55d+88) then
tmp = 0.0d0 - (x / tan(b))
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.2e+153) {
tmp = -1.0 / (Math.tan(B) / x);
} else if (F <= -1.4e-45) {
tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B;
} else if (F <= 2.55e+88) {
tmp = 0.0 - (x / Math.tan(B));
} else {
tmp = 1.0 / Math.sin(B);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -3.2e+153: tmp = -1.0 / (math.tan(B) / x) elif F <= -1.4e-45: tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B elif F <= 2.55e+88: tmp = 0.0 - (x / math.tan(B)) else: tmp = 1.0 / math.sin(B) return tmp
function code(F, B, x) tmp = 0.0 if (F <= -3.2e+153) tmp = Float64(-1.0 / Float64(tan(B) / x)); elseif (F <= -1.4e-45) tmp = Float64(Float64(Float64(-1.0 + Float64(Float64(1.0 + Float64(Float64(x * 2.0) * 0.5)) / Float64(F * F))) - x) / B); elseif (F <= 2.55e+88) tmp = Float64(0.0 - Float64(x / tan(B))); else tmp = Float64(1.0 / sin(B)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -3.2e+153) tmp = -1.0 / (tan(B) / x); elseif (F <= -1.4e-45) tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B; elseif (F <= 2.55e+88) tmp = 0.0 - (x / tan(B)); else tmp = 1.0 / sin(B); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -3.2e+153], N[(-1.0 / N[(N[Tan[B], $MachinePrecision] / x), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, -1.4e-45], N[(N[(N[(-1.0 + N[(N[(1.0 + N[(N[(x * 2.0), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision], If[LessEqual[F, 2.55e+88], N[(0.0 - N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -3.2 \cdot 10^{+153}:\\
\;\;\;\;\frac{-1}{\frac{\tan B}{x}}\\
\mathbf{elif}\;F \leq -1.4 \cdot 10^{-45}:\\
\;\;\;\;\frac{\left(-1 + \frac{1 + \left(x \cdot 2\right) \cdot 0.5}{F \cdot F}\right) - x}{B}\\
\mathbf{elif}\;F \leq 2.55 \cdot 10^{+88}:\\
\;\;\;\;0 - \frac{x}{\tan B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B}\\
\end{array}
\end{array}
if F < -3.2000000000000001e153Initial program 42.6%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified60.4%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6460.4%
Simplified60.4%
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.f6460.4%
Simplified60.4%
distribute-frac-neg2N/A
clear-numN/A
associate-/l/N/A
tan-quotN/A
distribute-neg-fracN/A
metadata-evalN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
tan-lowering-tan.f6460.5%
Applied egg-rr60.5%
if -3.2000000000000001e153 < F < -1.4000000000000001e-45Initial program 81.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-*.f6465.0%
Simplified65.0%
Taylor expanded in F around -inf
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-lft-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6461.0%
Simplified61.0%
if -1.4000000000000001e-45 < F < 2.5499999999999999e88Initial program 98.7%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.7%
Simplified99.7%
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.f6472.8%
Simplified72.8%
distribute-frac-neg2N/A
clear-numN/A
associate-/l/N/A
tan-quotN/A
clear-numN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
tan-lowering-tan.f6473.0%
Applied egg-rr73.0%
if 2.5499999999999999e88 < F Initial program 46.4%
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.f6456.0%
Simplified56.0%
Final simplification66.2%
(FPCore (F B x)
:precision binary64
(let* ((t_0 (- 0.0 (/ x (tan B)))))
(if (<= F -1e+151)
t_0
(if (<= F -1.4e-45)
(/ (- (+ -1.0 (/ (+ 1.0 (* (* x 2.0) 0.5)) (* F F))) x) B)
(if (<= F 3.4e+88) t_0 (/ 1.0 (sin B)))))))
double code(double F, double B, double x) {
double t_0 = 0.0 - (x / tan(B));
double tmp;
if (F <= -1e+151) {
tmp = t_0;
} else if (F <= -1.4e-45) {
tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B;
} else if (F <= 3.4e+88) {
tmp = t_0;
} 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) :: t_0
real(8) :: tmp
t_0 = 0.0d0 - (x / tan(b))
if (f <= (-1d+151)) then
tmp = t_0
else if (f <= (-1.4d-45)) then
tmp = (((-1.0d0) + ((1.0d0 + ((x * 2.0d0) * 0.5d0)) / (f * f))) - x) / b
else if (f <= 3.4d+88) then
tmp = t_0
else
tmp = 1.0d0 / sin(b)
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double t_0 = 0.0 - (x / Math.tan(B));
double tmp;
if (F <= -1e+151) {
tmp = t_0;
} else if (F <= -1.4e-45) {
tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B;
} else if (F <= 3.4e+88) {
tmp = t_0;
} else {
tmp = 1.0 / Math.sin(B);
}
return tmp;
}
def code(F, B, x): t_0 = 0.0 - (x / math.tan(B)) tmp = 0 if F <= -1e+151: tmp = t_0 elif F <= -1.4e-45: tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B elif F <= 3.4e+88: tmp = t_0 else: tmp = 1.0 / math.sin(B) return tmp
function code(F, B, x) t_0 = Float64(0.0 - Float64(x / tan(B))) tmp = 0.0 if (F <= -1e+151) tmp = t_0; elseif (F <= -1.4e-45) tmp = Float64(Float64(Float64(-1.0 + Float64(Float64(1.0 + Float64(Float64(x * 2.0) * 0.5)) / Float64(F * F))) - x) / B); elseif (F <= 3.4e+88) tmp = t_0; else tmp = Float64(1.0 / sin(B)); end return tmp end
function tmp_2 = code(F, B, x) t_0 = 0.0 - (x / tan(B)); tmp = 0.0; if (F <= -1e+151) tmp = t_0; elseif (F <= -1.4e-45) tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B; elseif (F <= 3.4e+88) tmp = t_0; else tmp = 1.0 / sin(B); end tmp_2 = tmp; end
code[F_, B_, x_] := Block[{t$95$0 = N[(0.0 - N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[F, -1e+151], t$95$0, If[LessEqual[F, -1.4e-45], N[(N[(N[(-1.0 + N[(N[(1.0 + N[(N[(x * 2.0), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision], If[LessEqual[F, 3.4e+88], t$95$0, N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := 0 - \frac{x}{\tan B}\\
\mathbf{if}\;F \leq -1 \cdot 10^{+151}:\\
\;\;\;\;t\_0\\
\mathbf{elif}\;F \leq -1.4 \cdot 10^{-45}:\\
\;\;\;\;\frac{\left(-1 + \frac{1 + \left(x \cdot 2\right) \cdot 0.5}{F \cdot F}\right) - x}{B}\\
\mathbf{elif}\;F \leq 3.4 \cdot 10^{+88}:\\
\;\;\;\;t\_0\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B}\\
\end{array}
\end{array}
if F < -1.00000000000000002e151 or -1.4000000000000001e-45 < F < 3.40000000000000004e88Initial program 85.8%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified90.7%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6490.7%
Simplified90.7%
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.f6470.0%
Simplified70.0%
distribute-frac-neg2N/A
clear-numN/A
associate-/l/N/A
tan-quotN/A
clear-numN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
tan-lowering-tan.f6470.1%
Applied egg-rr70.1%
if -1.00000000000000002e151 < F < -1.4000000000000001e-45Initial program 81.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-*.f6465.0%
Simplified65.0%
Taylor expanded in F around -inf
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-lft-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6461.0%
Simplified61.0%
if 3.40000000000000004e88 < F Initial program 46.4%
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.f6456.0%
Simplified56.0%
Final simplification66.2%
(FPCore (F B x) :precision binary64 (if (<= B 1.15e-5) (/ (- (/ F (sqrt (+ (* F F) (+ 2.0 (* x 2.0))))) x) B) (- 0.0 (/ x (tan B)))))
double code(double F, double B, double x) {
double tmp;
if (B <= 1.15e-5) {
tmp = ((F / sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B;
} else {
tmp = 0.0 - (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.15d-5) then
tmp = ((f / sqrt(((f * f) + (2.0d0 + (x * 2.0d0))))) - x) / b
else
tmp = 0.0d0 - (x / tan(b))
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (B <= 1.15e-5) {
tmp = ((F / Math.sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B;
} else {
tmp = 0.0 - (x / Math.tan(B));
}
return tmp;
}
def code(F, B, x): tmp = 0 if B <= 1.15e-5: tmp = ((F / math.sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B else: tmp = 0.0 - (x / math.tan(B)) return tmp
function code(F, B, x) tmp = 0.0 if (B <= 1.15e-5) tmp = Float64(Float64(Float64(F / sqrt(Float64(Float64(F * F) + Float64(2.0 + Float64(x * 2.0))))) - x) / B); else tmp = Float64(0.0 - Float64(x / tan(B))); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (B <= 1.15e-5) tmp = ((F / sqrt(((F * F) + (2.0 + (x * 2.0))))) - x) / B; else tmp = 0.0 - (x / tan(B)); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[B, 1.15e-5], 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[(0.0 - N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq 1.15 \cdot 10^{-5}:\\
\;\;\;\;\frac{\frac{F}{\sqrt{F \cdot F + \left(2 + x \cdot 2\right)}} - x}{B}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{x}{\tan B}\\
\end{array}
\end{array}
if B < 1.15e-5Initial program 76.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-*.f6462.6%
Simplified62.6%
sqrt-divN/A
metadata-evalN/A
un-div-invN/A
/-lowering-/.f64N/A
associate-+r+N/A
+-commutativeN/A
*-commutativeN/A
associate-+r+N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f6462.6%
Applied egg-rr62.6%
if 1.15e-5 < B Initial program 80.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified80.6%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6480.6%
Simplified80.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.f6460.2%
Simplified60.2%
distribute-frac-neg2N/A
clear-numN/A
associate-/l/N/A
tan-quotN/A
clear-numN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
tan-lowering-tan.f6460.3%
Applied egg-rr60.3%
Final simplification62.0%
(FPCore (F B x) :precision binary64 (if (<= B 3.6e-6) (/ (- (* F (sqrt (/ 1.0 (+ (* F F) 2.0)))) x) B) (- 0.0 (/ x (tan B)))))
double code(double F, double B, double x) {
double tmp;
if (B <= 3.6e-6) {
tmp = ((F * sqrt((1.0 / ((F * F) + 2.0)))) - x) / B;
} else {
tmp = 0.0 - (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 <= 3.6d-6) then
tmp = ((f * sqrt((1.0d0 / ((f * f) + 2.0d0)))) - x) / b
else
tmp = 0.0d0 - (x / tan(b))
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (B <= 3.6e-6) {
tmp = ((F * Math.sqrt((1.0 / ((F * F) + 2.0)))) - x) / B;
} else {
tmp = 0.0 - (x / Math.tan(B));
}
return tmp;
}
def code(F, B, x): tmp = 0 if B <= 3.6e-6: tmp = ((F * math.sqrt((1.0 / ((F * F) + 2.0)))) - x) / B else: tmp = 0.0 - (x / math.tan(B)) return tmp
function code(F, B, x) tmp = 0.0 if (B <= 3.6e-6) tmp = Float64(Float64(Float64(F * sqrt(Float64(1.0 / Float64(Float64(F * F) + 2.0)))) - x) / B); else tmp = Float64(0.0 - Float64(x / tan(B))); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (B <= 3.6e-6) tmp = ((F * sqrt((1.0 / ((F * F) + 2.0)))) - x) / B; else tmp = 0.0 - (x / tan(B)); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[B, 3.6e-6], N[(N[(N[(F * N[Sqrt[N[(1.0 / N[(N[(F * F), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision], N[(0.0 - N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;B \leq 3.6 \cdot 10^{-6}:\\
\;\;\;\;\frac{F \cdot \sqrt{\frac{1}{F \cdot F + 2}} - x}{B}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{x}{\tan B}\\
\end{array}
\end{array}
if B < 3.59999999999999984e-6Initial program 76.3%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified89.0%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6489.1%
Simplified89.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
unpow2N/A
*-lowering-*.f6462.6%
Simplified62.6%
if 3.59999999999999984e-6 < B Initial program 80.5%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified80.6%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6480.6%
Simplified80.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.f6460.2%
Simplified60.2%
distribute-frac-neg2N/A
clear-numN/A
associate-/l/N/A
tan-quotN/A
clear-numN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
tan-lowering-tan.f6460.3%
Applied egg-rr60.3%
Final simplification62.0%
(FPCore (F B x) :precision binary64 (if (<= F -1.4e-45) (- (/ -1.0 (sin B)) (/ x B)) (if (<= F 1.46e-53) (- 0.0 (/ x (tan B))) (- (/ 1.0 (sin B)) (/ x B)))))
double code(double F, double B, double x) {
double tmp;
if (F <= -1.4e-45) {
tmp = (-1.0 / sin(B)) - (x / B);
} else if (F <= 1.46e-53) {
tmp = 0.0 - (x / tan(B));
} else {
tmp = (1.0 / sin(B)) - (x / B);
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: tmp
if (f <= (-1.4d-45)) then
tmp = ((-1.0d0) / sin(b)) - (x / b)
else if (f <= 1.46d-53) then
tmp = 0.0d0 - (x / tan(b))
else
tmp = (1.0d0 / sin(b)) - (x / b)
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= -1.4e-45) {
tmp = (-1.0 / Math.sin(B)) - (x / B);
} else if (F <= 1.46e-53) {
tmp = 0.0 - (x / Math.tan(B));
} else {
tmp = (1.0 / Math.sin(B)) - (x / B);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -1.4e-45: tmp = (-1.0 / math.sin(B)) - (x / B) elif F <= 1.46e-53: tmp = 0.0 - (x / math.tan(B)) else: tmp = (1.0 / math.sin(B)) - (x / B) return tmp
function code(F, B, x) tmp = 0.0 if (F <= -1.4e-45) tmp = Float64(Float64(-1.0 / sin(B)) - Float64(x / B)); elseif (F <= 1.46e-53) tmp = Float64(0.0 - Float64(x / tan(B))); else tmp = Float64(Float64(1.0 / sin(B)) - Float64(x / B)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -1.4e-45) tmp = (-1.0 / sin(B)) - (x / B); elseif (F <= 1.46e-53) tmp = 0.0 - (x / tan(B)); else tmp = (1.0 / sin(B)) - (x / B); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -1.4e-45], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(x / B), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 1.46e-53], N[(0.0 - N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(x / B), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -1.4 \cdot 10^{-45}:\\
\;\;\;\;\frac{-1}{\sin B} - \frac{x}{B}\\
\mathbf{elif}\;F \leq 1.46 \cdot 10^{-53}:\\
\;\;\;\;0 - \frac{x}{\tan B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B} - \frac{x}{B}\\
\end{array}
\end{array}
if F < -1.4000000000000001e-45Initial program 59.5%
Taylor expanded in B around 0
/-lowering-/.f6436.0%
Simplified36.0%
Taylor expanded in F around -inf
distribute-lft-inN/A
mul-1-negN/A
unsub-negN/A
neg-mul-1N/A
--lowering--.f64N/A
distribute-neg-fracN/A
metadata-evalN/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f6470.1%
Simplified70.1%
if -1.4000000000000001e-45 < F < 1.45999999999999989e-53Initial program 99.4%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.8%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.8%
Simplified99.8%
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.f6479.6%
Simplified79.6%
distribute-frac-neg2N/A
clear-numN/A
associate-/l/N/A
tan-quotN/A
clear-numN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
tan-lowering-tan.f6479.8%
Applied egg-rr79.8%
if 1.45999999999999989e-53 < F Initial program 65.2%
Taylor expanded in B around 0
/-lowering-/.f6444.2%
Simplified44.2%
Taylor expanded in F around inf
--lowering--.f64N/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f6471.0%
Simplified71.0%
Final simplification74.3%
(FPCore (F B x) :precision binary64 (if (<= F -1.4e-45) (- (/ -1.0 (sin B)) (/ x B)) (if (<= F 5.7e+88) (- 0.0 (/ x (tan B))) (/ 1.0 (sin B)))))
double code(double F, double B, double x) {
double tmp;
if (F <= -1.4e-45) {
tmp = (-1.0 / sin(B)) - (x / B);
} else if (F <= 5.7e+88) {
tmp = 0.0 - (x / tan(B));
} 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 <= (-1.4d-45)) then
tmp = ((-1.0d0) / sin(b)) - (x / b)
else if (f <= 5.7d+88) then
tmp = 0.0d0 - (x / tan(b))
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 <= -1.4e-45) {
tmp = (-1.0 / Math.sin(B)) - (x / B);
} else if (F <= 5.7e+88) {
tmp = 0.0 - (x / Math.tan(B));
} else {
tmp = 1.0 / Math.sin(B);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -1.4e-45: tmp = (-1.0 / math.sin(B)) - (x / B) elif F <= 5.7e+88: tmp = 0.0 - (x / math.tan(B)) else: tmp = 1.0 / math.sin(B) return tmp
function code(F, B, x) tmp = 0.0 if (F <= -1.4e-45) tmp = Float64(Float64(-1.0 / sin(B)) - Float64(x / B)); elseif (F <= 5.7e+88) tmp = Float64(0.0 - Float64(x / tan(B))); else tmp = Float64(1.0 / sin(B)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -1.4e-45) tmp = (-1.0 / sin(B)) - (x / B); elseif (F <= 5.7e+88) tmp = 0.0 - (x / tan(B)); else tmp = 1.0 / sin(B); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -1.4e-45], N[(N[(-1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision] - N[(x / B), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 5.7e+88], N[(0.0 - N[(x / N[Tan[B], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -1.4 \cdot 10^{-45}:\\
\;\;\;\;\frac{-1}{\sin B} - \frac{x}{B}\\
\mathbf{elif}\;F \leq 5.7 \cdot 10^{+88}:\\
\;\;\;\;0 - \frac{x}{\tan B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B}\\
\end{array}
\end{array}
if F < -1.4000000000000001e-45Initial program 59.5%
Taylor expanded in B around 0
/-lowering-/.f6436.0%
Simplified36.0%
Taylor expanded in F around -inf
distribute-lft-inN/A
mul-1-negN/A
unsub-negN/A
neg-mul-1N/A
--lowering--.f64N/A
distribute-neg-fracN/A
metadata-evalN/A
/-lowering-/.f64N/A
sin-lowering-sin.f64N/A
/-lowering-/.f6470.1%
Simplified70.1%
if -1.4000000000000001e-45 < F < 5.70000000000000021e88Initial program 98.7%
+-commutativeN/A
unsub-negN/A
--lowering--.f64N/A
Simplified99.7%
Taylor expanded in x around 0
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f6499.7%
Simplified99.7%
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.f6472.8%
Simplified72.8%
distribute-frac-neg2N/A
clear-numN/A
associate-/l/N/A
tan-quotN/A
clear-numN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
tan-lowering-tan.f6473.0%
Applied egg-rr73.0%
if 5.70000000000000021e88 < F Initial program 46.4%
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.f6456.0%
Simplified56.0%
Final simplification68.8%
(FPCore (F B x) :precision binary64 (if (<= F -2.3e-52) (/ (- (+ -1.0 (/ (+ 1.0 (* (* x 2.0) 0.5)) (* F F))) x) B) (if (<= F 2.6e-22) (- 0.0 (/ x B)) (/ 1.0 (sin B)))))
double code(double F, double B, double x) {
double tmp;
if (F <= -2.3e-52) {
tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B;
} else if (F <= 2.6e-22) {
tmp = 0.0 - (x / B);
} 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 <= (-2.3d-52)) then
tmp = (((-1.0d0) + ((1.0d0 + ((x * 2.0d0) * 0.5d0)) / (f * f))) - x) / b
else if (f <= 2.6d-22) then
tmp = 0.0d0 - (x / b)
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 <= -2.3e-52) {
tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B;
} else if (F <= 2.6e-22) {
tmp = 0.0 - (x / B);
} else {
tmp = 1.0 / Math.sin(B);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -2.3e-52: tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B elif F <= 2.6e-22: tmp = 0.0 - (x / B) else: tmp = 1.0 / math.sin(B) return tmp
function code(F, B, x) tmp = 0.0 if (F <= -2.3e-52) tmp = Float64(Float64(Float64(-1.0 + Float64(Float64(1.0 + Float64(Float64(x * 2.0) * 0.5)) / Float64(F * F))) - x) / B); elseif (F <= 2.6e-22) tmp = Float64(0.0 - Float64(x / B)); else tmp = Float64(1.0 / sin(B)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -2.3e-52) tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B; elseif (F <= 2.6e-22) tmp = 0.0 - (x / B); else tmp = 1.0 / sin(B); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -2.3e-52], N[(N[(N[(-1.0 + N[(N[(1.0 + N[(N[(x * 2.0), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision], If[LessEqual[F, 2.6e-22], N[(0.0 - N[(x / B), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[Sin[B], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -2.3 \cdot 10^{-52}:\\
\;\;\;\;\frac{\left(-1 + \frac{1 + \left(x \cdot 2\right) \cdot 0.5}{F \cdot F}\right) - x}{B}\\
\mathbf{elif}\;F \leq 2.6 \cdot 10^{-22}:\\
\;\;\;\;0 - \frac{x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sin B}\\
\end{array}
\end{array}
if F < -2.29999999999999994e-52Initial program 60.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-*.f6444.3%
Simplified44.3%
Taylor expanded in F around -inf
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-lft-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6452.4%
Simplified52.4%
if -2.29999999999999994e-52 < F < 2.6e-22Initial program 99.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-*.f6456.7%
Simplified56.7%
Taylor expanded in F around 0
mul-1-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
neg-lowering-neg.f6444.5%
Simplified44.5%
if 2.6e-22 < F Initial program 63.9%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6495.1%
Simplified95.1%
Taylor expanded in x around 0
/-lowering-/.f64N/A
sin-lowering-sin.f6450.0%
Simplified50.0%
Final simplification48.4%
(FPCore (F B x)
:precision binary64
(if (<= F -2.3e-52)
(/ (- (+ -1.0 (/ (+ 1.0 (* (* x 2.0) 0.5)) (* F F))) x) B)
(if (<= F 2.45e-64)
(- 0.0 (/ x B))
(/ (- (+ 1.0 (/ (+ -1.0 (* (* x 2.0) -0.5)) (* F F))) x) B))))
double code(double F, double B, double x) {
double tmp;
if (F <= -2.3e-52) {
tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B;
} else if (F <= 2.45e-64) {
tmp = 0.0 - (x / B);
} else {
tmp = ((1.0 + ((-1.0 + ((x * 2.0) * -0.5)) / (F * F))) - 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.3d-52)) then
tmp = (((-1.0d0) + ((1.0d0 + ((x * 2.0d0) * 0.5d0)) / (f * f))) - x) / b
else if (f <= 2.45d-64) then
tmp = 0.0d0 - (x / b)
else
tmp = ((1.0d0 + (((-1.0d0) + ((x * 2.0d0) * (-0.5d0))) / (f * f))) - x) / b
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= -2.3e-52) {
tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B;
} else if (F <= 2.45e-64) {
tmp = 0.0 - (x / B);
} else {
tmp = ((1.0 + ((-1.0 + ((x * 2.0) * -0.5)) / (F * F))) - x) / B;
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -2.3e-52: tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B elif F <= 2.45e-64: tmp = 0.0 - (x / B) else: tmp = ((1.0 + ((-1.0 + ((x * 2.0) * -0.5)) / (F * F))) - x) / B return tmp
function code(F, B, x) tmp = 0.0 if (F <= -2.3e-52) tmp = Float64(Float64(Float64(-1.0 + Float64(Float64(1.0 + Float64(Float64(x * 2.0) * 0.5)) / Float64(F * F))) - x) / B); elseif (F <= 2.45e-64) tmp = Float64(0.0 - Float64(x / B)); else tmp = Float64(Float64(Float64(1.0 + Float64(Float64(-1.0 + Float64(Float64(x * 2.0) * -0.5)) / Float64(F * F))) - x) / B); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -2.3e-52) tmp = ((-1.0 + ((1.0 + ((x * 2.0) * 0.5)) / (F * F))) - x) / B; elseif (F <= 2.45e-64) tmp = 0.0 - (x / B); else tmp = ((1.0 + ((-1.0 + ((x * 2.0) * -0.5)) / (F * F))) - x) / B; end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -2.3e-52], N[(N[(N[(-1.0 + N[(N[(1.0 + N[(N[(x * 2.0), $MachinePrecision] * 0.5), $MachinePrecision]), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision], If[LessEqual[F, 2.45e-64], N[(0.0 - N[(x / B), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + N[(N[(-1.0 + N[(N[(x * 2.0), $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -2.3 \cdot 10^{-52}:\\
\;\;\;\;\frac{\left(-1 + \frac{1 + \left(x \cdot 2\right) \cdot 0.5}{F \cdot F}\right) - x}{B}\\
\mathbf{elif}\;F \leq 2.45 \cdot 10^{-64}:\\
\;\;\;\;0 - \frac{x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(1 + \frac{-1 + \left(x \cdot 2\right) \cdot -0.5}{F \cdot F}\right) - x}{B}\\
\end{array}
\end{array}
if F < -2.29999999999999994e-52Initial program 60.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-*.f6444.3%
Simplified44.3%
Taylor expanded in F around -inf
sub-negN/A
metadata-evalN/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-lft-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6452.4%
Simplified52.4%
if -2.29999999999999994e-52 < F < 2.4500000000000001e-64Initial program 99.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-*.f6457.9%
Simplified57.9%
Taylor expanded in F around 0
mul-1-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
neg-lowering-neg.f6445.2%
Simplified45.2%
if 2.4500000000000001e-64 < F Initial program 65.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-*.f6437.6%
Simplified37.6%
Taylor expanded in F around inf
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-lft-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6441.1%
Simplified41.1%
Final simplification45.9%
(FPCore (F B x)
:precision binary64
(if (<= F -5.5e-88)
(/ (- -1.0 x) B)
(if (<= F 2.45e-64)
(- 0.0 (/ x B))
(/ (- (+ 1.0 (/ (+ -1.0 (* (* x 2.0) -0.5)) (* F F))) x) B))))
double code(double F, double B, double x) {
double tmp;
if (F <= -5.5e-88) {
tmp = (-1.0 - x) / B;
} else if (F <= 2.45e-64) {
tmp = 0.0 - (x / B);
} else {
tmp = ((1.0 + ((-1.0 + ((x * 2.0) * -0.5)) / (F * F))) - 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-88)) then
tmp = ((-1.0d0) - x) / b
else if (f <= 2.45d-64) then
tmp = 0.0d0 - (x / b)
else
tmp = ((1.0d0 + (((-1.0d0) + ((x * 2.0d0) * (-0.5d0))) / (f * f))) - x) / b
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= -5.5e-88) {
tmp = (-1.0 - x) / B;
} else if (F <= 2.45e-64) {
tmp = 0.0 - (x / B);
} else {
tmp = ((1.0 + ((-1.0 + ((x * 2.0) * -0.5)) / (F * F))) - x) / B;
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -5.5e-88: tmp = (-1.0 - x) / B elif F <= 2.45e-64: tmp = 0.0 - (x / B) else: tmp = ((1.0 + ((-1.0 + ((x * 2.0) * -0.5)) / (F * F))) - x) / B return tmp
function code(F, B, x) tmp = 0.0 if (F <= -5.5e-88) tmp = Float64(Float64(-1.0 - x) / B); elseif (F <= 2.45e-64) tmp = Float64(0.0 - Float64(x / B)); else tmp = Float64(Float64(Float64(1.0 + Float64(Float64(-1.0 + Float64(Float64(x * 2.0) * -0.5)) / Float64(F * F))) - x) / B); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -5.5e-88) tmp = (-1.0 - x) / B; elseif (F <= 2.45e-64) tmp = 0.0 - (x / B); else tmp = ((1.0 + ((-1.0 + ((x * 2.0) * -0.5)) / (F * F))) - x) / B; end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -5.5e-88], N[(N[(-1.0 - x), $MachinePrecision] / B), $MachinePrecision], If[LessEqual[F, 2.45e-64], N[(0.0 - N[(x / B), $MachinePrecision]), $MachinePrecision], N[(N[(N[(1.0 + N[(N[(-1.0 + N[(N[(x * 2.0), $MachinePrecision] * -0.5), $MachinePrecision]), $MachinePrecision] / N[(F * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - x), $MachinePrecision] / B), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -5.5 \cdot 10^{-88}:\\
\;\;\;\;\frac{-1 - x}{B}\\
\mathbf{elif}\;F \leq 2.45 \cdot 10^{-64}:\\
\;\;\;\;0 - \frac{x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{\left(1 + \frac{-1 + \left(x \cdot 2\right) \cdot -0.5}{F \cdot F}\right) - x}{B}\\
\end{array}
\end{array}
if F < -5.49999999999999971e-88Initial program 64.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-*.f6446.2%
Simplified46.2%
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--.f6449.6%
Simplified49.6%
if -5.49999999999999971e-88 < F < 2.4500000000000001e-64Initial program 99.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-*.f6457.4%
Simplified57.4%
Taylor expanded in F around 0
mul-1-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
neg-lowering-neg.f6446.6%
Simplified46.6%
if 2.4500000000000001e-64 < F Initial program 65.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-*.f6437.6%
Simplified37.6%
Taylor expanded in F around inf
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
distribute-lft-inN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6441.1%
Simplified41.1%
Final simplification45.8%
(FPCore (F B x) :precision binary64 (if (<= F -1e-87) (/ (- -1.0 x) B) (if (<= F 3.2e-22) (- 0.0 (/ x B)) (/ (- 1.0 x) B))))
double code(double F, double B, double x) {
double tmp;
if (F <= -1e-87) {
tmp = (-1.0 - x) / B;
} else if (F <= 3.2e-22) {
tmp = 0.0 - (x / B);
} else {
tmp = (1.0 - x) / B;
}
return tmp;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
real(8) :: tmp
if (f <= (-1d-87)) then
tmp = ((-1.0d0) - x) / b
else if (f <= 3.2d-22) then
tmp = 0.0d0 - (x / b)
else
tmp = (1.0d0 - x) / b
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= -1e-87) {
tmp = (-1.0 - x) / B;
} else if (F <= 3.2e-22) {
tmp = 0.0 - (x / B);
} else {
tmp = (1.0 - x) / B;
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -1e-87: tmp = (-1.0 - x) / B elif F <= 3.2e-22: tmp = 0.0 - (x / B) else: tmp = (1.0 - x) / B return tmp
function code(F, B, x) tmp = 0.0 if (F <= -1e-87) tmp = Float64(Float64(-1.0 - x) / B); elseif (F <= 3.2e-22) tmp = Float64(0.0 - Float64(x / B)); else tmp = Float64(Float64(1.0 - x) / B); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -1e-87) tmp = (-1.0 - x) / B; elseif (F <= 3.2e-22) tmp = 0.0 - (x / B); else tmp = (1.0 - x) / B; end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -1e-87], N[(N[(-1.0 - x), $MachinePrecision] / B), $MachinePrecision], If[LessEqual[F, 3.2e-22], N[(0.0 - N[(x / B), $MachinePrecision]), $MachinePrecision], N[(N[(1.0 - x), $MachinePrecision] / B), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -1 \cdot 10^{-87}:\\
\;\;\;\;\frac{-1 - x}{B}\\
\mathbf{elif}\;F \leq 3.2 \cdot 10^{-22}:\\
\;\;\;\;0 - \frac{x}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1 - x}{B}\\
\end{array}
\end{array}
if F < -1.00000000000000002e-87Initial program 64.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-*.f6446.2%
Simplified46.2%
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--.f6449.6%
Simplified49.6%
if -1.00000000000000002e-87 < F < 3.19999999999999987e-22Initial program 99.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-*.f6455.6%
Simplified55.6%
Taylor expanded in F around 0
mul-1-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
neg-lowering-neg.f6445.4%
Simplified45.4%
if 3.19999999999999987e-22 < F Initial program 63.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-*.f6438.5%
Simplified38.5%
Taylor expanded in F around inf
/-lowering-/.f64N/A
--lowering--.f6441.7%
Simplified41.7%
Final simplification45.6%
(FPCore (F B x) :precision binary64 (if (<= F -6e-90) (/ (- -1.0 x) B) (- 0.0 (/ x B))))
double code(double F, double B, double x) {
double tmp;
if (F <= -6e-90) {
tmp = (-1.0 - x) / B;
} else {
tmp = 0.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 <= (-6d-90)) then
tmp = ((-1.0d0) - x) / b
else
tmp = 0.0d0 - (x / b)
end if
code = tmp
end function
public static double code(double F, double B, double x) {
double tmp;
if (F <= -6e-90) {
tmp = (-1.0 - x) / B;
} else {
tmp = 0.0 - (x / B);
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= -6e-90: tmp = (-1.0 - x) / B else: tmp = 0.0 - (x / B) return tmp
function code(F, B, x) tmp = 0.0 if (F <= -6e-90) tmp = Float64(Float64(-1.0 - x) / B); else tmp = Float64(0.0 - Float64(x / B)); end return tmp end
function tmp_2 = code(F, B, x) tmp = 0.0; if (F <= -6e-90) tmp = (-1.0 - x) / B; else tmp = 0.0 - (x / B); end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, -6e-90], N[(N[(-1.0 - x), $MachinePrecision] / B), $MachinePrecision], N[(0.0 - N[(x / B), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq -6 \cdot 10^{-90}:\\
\;\;\;\;\frac{-1 - x}{B}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{x}{B}\\
\end{array}
\end{array}
if F < -6.00000000000000041e-90Initial program 64.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-*.f6446.2%
Simplified46.2%
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--.f6449.6%
Simplified49.6%
if -6.00000000000000041e-90 < F Initial program 83.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-*.f6448.1%
Simplified48.1%
Taylor expanded in F around 0
mul-1-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
neg-lowering-neg.f6436.8%
Simplified36.8%
Final simplification40.8%
(FPCore (F B x) :precision binary64 (if (<= F 3.1e-79) (/ -1.0 B) (/ 1.0 B)))
double code(double F, double B, double x) {
double tmp;
if (F <= 3.1e-79) {
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 <= 3.1d-79) 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 <= 3.1e-79) {
tmp = -1.0 / B;
} else {
tmp = 1.0 / B;
}
return tmp;
}
def code(F, B, x): tmp = 0 if F <= 3.1e-79: tmp = -1.0 / B else: tmp = 1.0 / B return tmp
function code(F, B, x) tmp = 0.0 if (F <= 3.1e-79) 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 <= 3.1e-79) tmp = -1.0 / B; else tmp = 1.0 / B; end tmp_2 = tmp; end
code[F_, B_, x_] := If[LessEqual[F, 3.1e-79], N[(-1.0 / B), $MachinePrecision], N[(1.0 / B), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;F \leq 3.1 \cdot 10^{-79}:\\
\;\;\;\;\frac{-1}{B}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{B}\\
\end{array}
\end{array}
if F < 3.0999999999999999e-79Initial program 82.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-*.f6452.5%
Simplified52.5%
Taylor expanded in x around 0
*-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6414.6%
Simplified14.6%
Taylor expanded in F around -inf
/-lowering-/.f6414.5%
Simplified14.5%
if 3.0999999999999999e-79 < F Initial program 66.8%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6490.1%
Simplified90.1%
Taylor expanded in x around 0
/-lowering-/.f64N/A
sin-lowering-sin.f6446.3%
Simplified46.3%
Taylor expanded in B around 0
/-lowering-/.f6417.7%
Simplified17.7%
(FPCore (F B x) :precision binary64 (- 0.0 (/ x B)))
double code(double F, double B, double x) {
return 0.0 - (x / B);
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
code = 0.0d0 - (x / b)
end function
public static double code(double F, double B, double x) {
return 0.0 - (x / B);
}
def code(F, B, x): return 0.0 - (x / B)
function code(F, B, x) return Float64(0.0 - Float64(x / B)) end
function tmp = code(F, B, x) tmp = 0.0 - (x / B); end
code[F_, B_, x_] := N[(0.0 - N[(x / B), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0 - \frac{x}{B}
\end{array}
Initial program 77.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-*.f6447.5%
Simplified47.5%
Taylor expanded in F around 0
mul-1-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
neg-lowering-neg.f6433.5%
Simplified33.5%
Final simplification33.5%
(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.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-*.f6447.5%
Simplified47.5%
Taylor expanded in x around 0
*-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f6414.3%
Simplified14.3%
Taylor expanded in F around -inf
/-lowering-/.f6410.6%
Simplified10.6%
(FPCore (F B x) :precision binary64 (* B 0.16666666666666666))
double code(double F, double B, double x) {
return B * 0.16666666666666666;
}
real(8) function code(f, b, x)
real(8), intent (in) :: f
real(8), intent (in) :: b
real(8), intent (in) :: x
code = b * 0.16666666666666666d0
end function
public static double code(double F, double B, double x) {
return B * 0.16666666666666666;
}
def code(F, B, x): return B * 0.16666666666666666
function code(F, B, x) return Float64(B * 0.16666666666666666) end
function tmp = code(F, B, x) tmp = B * 0.16666666666666666; end
code[F_, B_, x_] := N[(B * 0.16666666666666666), $MachinePrecision]
\begin{array}{l}
\\
B \cdot 0.16666666666666666
\end{array}
Initial program 77.4%
Taylor expanded in F around inf
/-lowering-/.f64N/A
sin-lowering-sin.f6457.0%
Simplified57.0%
Taylor expanded in B around 0
/-lowering-/.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6435.7%
Simplified35.7%
Taylor expanded in B around inf
*-commutativeN/A
*-lowering-*.f642.9%
Simplified2.9%
herbie shell --seed 2024138
(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))))))