
(FPCore (A B C F)
:precision binary64
(let* ((t_0 (- (pow B 2.0) (* (* 4.0 A) C))))
(/
(-
(sqrt
(*
(* 2.0 (* t_0 F))
(+ (+ A C) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0)))))))
t_0)))
double code(double A, double B, double C, double F) {
double t_0 = pow(B, 2.0) - ((4.0 * A) * C);
return -sqrt(((2.0 * (t_0 * F)) * ((A + C) + sqrt((pow((A - C), 2.0) + pow(B, 2.0)))))) / t_0;
}
real(8) function code(a, b, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: t_0
t_0 = (b ** 2.0d0) - ((4.0d0 * a) * c)
code = -sqrt(((2.0d0 * (t_0 * f)) * ((a + c) + sqrt((((a - c) ** 2.0d0) + (b ** 2.0d0)))))) / t_0
end function
public static double code(double A, double B, double C, double F) {
double t_0 = Math.pow(B, 2.0) - ((4.0 * A) * C);
return -Math.sqrt(((2.0 * (t_0 * F)) * ((A + C) + Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0)))))) / t_0;
}
def code(A, B, C, F): t_0 = math.pow(B, 2.0) - ((4.0 * A) * C) return -math.sqrt(((2.0 * (t_0 * F)) * ((A + C) + math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))))) / t_0
function code(A, B, C, F) t_0 = Float64((B ^ 2.0) - Float64(Float64(4.0 * A) * C)) return Float64(Float64(-sqrt(Float64(Float64(2.0 * Float64(t_0 * F)) * Float64(Float64(A + C) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B ^ 2.0))))))) / t_0) end
function tmp = code(A, B, C, F) t_0 = (B ^ 2.0) - ((4.0 * A) * C); tmp = -sqrt(((2.0 * (t_0 * F)) * ((A + C) + sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))))) / t_0; end
code[A_, B_, C_, F_] := Block[{t$95$0 = N[(N[Power[B, 2.0], $MachinePrecision] - N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]), $MachinePrecision]}, N[((-N[Sqrt[N[(N[(2.0 * N[(t$95$0 * F), $MachinePrecision]), $MachinePrecision] * N[(N[(A + C), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]) / t$95$0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {B}^{2} - \left(4 \cdot A\right) \cdot C\\
\frac{-\sqrt{\left(2 \cdot \left(t\_0 \cdot F\right)\right) \cdot \left(\left(A + C\right) + \sqrt{{\left(A - C\right)}^{2} + {B}^{2}}\right)}}{t\_0}
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 27 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (A B C F)
:precision binary64
(let* ((t_0 (- (pow B 2.0) (* (* 4.0 A) C))))
(/
(-
(sqrt
(*
(* 2.0 (* t_0 F))
(+ (+ A C) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0)))))))
t_0)))
double code(double A, double B, double C, double F) {
double t_0 = pow(B, 2.0) - ((4.0 * A) * C);
return -sqrt(((2.0 * (t_0 * F)) * ((A + C) + sqrt((pow((A - C), 2.0) + pow(B, 2.0)))))) / t_0;
}
real(8) function code(a, b, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: t_0
t_0 = (b ** 2.0d0) - ((4.0d0 * a) * c)
code = -sqrt(((2.0d0 * (t_0 * f)) * ((a + c) + sqrt((((a - c) ** 2.0d0) + (b ** 2.0d0)))))) / t_0
end function
public static double code(double A, double B, double C, double F) {
double t_0 = Math.pow(B, 2.0) - ((4.0 * A) * C);
return -Math.sqrt(((2.0 * (t_0 * F)) * ((A + C) + Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0)))))) / t_0;
}
def code(A, B, C, F): t_0 = math.pow(B, 2.0) - ((4.0 * A) * C) return -math.sqrt(((2.0 * (t_0 * F)) * ((A + C) + math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))))) / t_0
function code(A, B, C, F) t_0 = Float64((B ^ 2.0) - Float64(Float64(4.0 * A) * C)) return Float64(Float64(-sqrt(Float64(Float64(2.0 * Float64(t_0 * F)) * Float64(Float64(A + C) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B ^ 2.0))))))) / t_0) end
function tmp = code(A, B, C, F) t_0 = (B ^ 2.0) - ((4.0 * A) * C); tmp = -sqrt(((2.0 * (t_0 * F)) * ((A + C) + sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))))) / t_0; end
code[A_, B_, C_, F_] := Block[{t$95$0 = N[(N[Power[B, 2.0], $MachinePrecision] - N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]), $MachinePrecision]}, N[((-N[Sqrt[N[(N[(2.0 * N[(t$95$0 * F), $MachinePrecision]), $MachinePrecision] * N[(N[(A + C), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]) / t$95$0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {B}^{2} - \left(4 \cdot A\right) \cdot C\\
\frac{-\sqrt{\left(2 \cdot \left(t\_0 \cdot F\right)\right) \cdot \left(\left(A + C\right) + \sqrt{{\left(A - C\right)}^{2} + {B}^{2}}\right)}}{t\_0}
\end{array}
\end{array}
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (hypot B_m (- A C)))
(t_1 (+ (* B_m B_m) (* A A)))
(t_2 (sqrt (/ 1.0 t_1)))
(t_3 (- 1.0 (* A t_2)))
(t_4 (+ (* B_m B_m) (* -4.0 (* A C))))
(t_5 (+ A (hypot B_m A)))
(t_6 (* (* 4.0 A) C))
(t_7 (- t_6 (* B_m B_m)))
(t_8
(/
(sqrt
(*
(* 2.0 (* (- (pow B_m 2.0) t_6) F))
(+ (+ A C) (sqrt (+ (pow B_m 2.0) (pow (- A C) 2.0))))))
(- t_6 (pow B_m 2.0))))
(t_9 (pow (+ A (+ C t_0)) 0.5)))
(if (<= t_8 -2e-114)
(/ (* t_9 (* (sqrt (* 2.0 t_4)) (sqrt F))) t_7)
(if (<= t_8 4e-143)
(/
(sqrt
(+
(* 2.0 (* (* F (* B_m B_m)) t_5))
(*
C
(*
2.0
(+
(*
(* C F)
(+
(* (* A -4.0) t_3)
(* 0.5 (* (* B_m B_m) (* (- 1.0 (/ (* A A) t_1)) t_2)))))
(* F (+ (* t_5 (* A -4.0)) (* (* B_m B_m) t_3))))))))
t_7)
(if (<= t_8 INFINITY)
(/ (* t_9 (sqrt (* t_4 (* 2.0 F)))) t_7)
(*
(sqrt F)
(* (sqrt (+ C (+ A t_0))) (/ (sqrt 2.0) (- 0.0 B_m)))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = hypot(B_m, (A - C));
double t_1 = (B_m * B_m) + (A * A);
double t_2 = sqrt((1.0 / t_1));
double t_3 = 1.0 - (A * t_2);
double t_4 = (B_m * B_m) + (-4.0 * (A * C));
double t_5 = A + hypot(B_m, A);
double t_6 = (4.0 * A) * C;
double t_7 = t_6 - (B_m * B_m);
double t_8 = sqrt(((2.0 * ((pow(B_m, 2.0) - t_6) * F)) * ((A + C) + sqrt((pow(B_m, 2.0) + pow((A - C), 2.0)))))) / (t_6 - pow(B_m, 2.0));
double t_9 = pow((A + (C + t_0)), 0.5);
double tmp;
if (t_8 <= -2e-114) {
tmp = (t_9 * (sqrt((2.0 * t_4)) * sqrt(F))) / t_7;
} else if (t_8 <= 4e-143) {
tmp = sqrt(((2.0 * ((F * (B_m * B_m)) * t_5)) + (C * (2.0 * (((C * F) * (((A * -4.0) * t_3) + (0.5 * ((B_m * B_m) * ((1.0 - ((A * A) / t_1)) * t_2))))) + (F * ((t_5 * (A * -4.0)) + ((B_m * B_m) * t_3)))))))) / t_7;
} else if (t_8 <= ((double) INFINITY)) {
tmp = (t_9 * sqrt((t_4 * (2.0 * F)))) / t_7;
} else {
tmp = sqrt(F) * (sqrt((C + (A + t_0))) * (sqrt(2.0) / (0.0 - B_m)));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = Math.hypot(B_m, (A - C));
double t_1 = (B_m * B_m) + (A * A);
double t_2 = Math.sqrt((1.0 / t_1));
double t_3 = 1.0 - (A * t_2);
double t_4 = (B_m * B_m) + (-4.0 * (A * C));
double t_5 = A + Math.hypot(B_m, A);
double t_6 = (4.0 * A) * C;
double t_7 = t_6 - (B_m * B_m);
double t_8 = Math.sqrt(((2.0 * ((Math.pow(B_m, 2.0) - t_6) * F)) * ((A + C) + Math.sqrt((Math.pow(B_m, 2.0) + Math.pow((A - C), 2.0)))))) / (t_6 - Math.pow(B_m, 2.0));
double t_9 = Math.pow((A + (C + t_0)), 0.5);
double tmp;
if (t_8 <= -2e-114) {
tmp = (t_9 * (Math.sqrt((2.0 * t_4)) * Math.sqrt(F))) / t_7;
} else if (t_8 <= 4e-143) {
tmp = Math.sqrt(((2.0 * ((F * (B_m * B_m)) * t_5)) + (C * (2.0 * (((C * F) * (((A * -4.0) * t_3) + (0.5 * ((B_m * B_m) * ((1.0 - ((A * A) / t_1)) * t_2))))) + (F * ((t_5 * (A * -4.0)) + ((B_m * B_m) * t_3)))))))) / t_7;
} else if (t_8 <= Double.POSITIVE_INFINITY) {
tmp = (t_9 * Math.sqrt((t_4 * (2.0 * F)))) / t_7;
} else {
tmp = Math.sqrt(F) * (Math.sqrt((C + (A + t_0))) * (Math.sqrt(2.0) / (0.0 - B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = math.hypot(B_m, (A - C)) t_1 = (B_m * B_m) + (A * A) t_2 = math.sqrt((1.0 / t_1)) t_3 = 1.0 - (A * t_2) t_4 = (B_m * B_m) + (-4.0 * (A * C)) t_5 = A + math.hypot(B_m, A) t_6 = (4.0 * A) * C t_7 = t_6 - (B_m * B_m) t_8 = math.sqrt(((2.0 * ((math.pow(B_m, 2.0) - t_6) * F)) * ((A + C) + math.sqrt((math.pow(B_m, 2.0) + math.pow((A - C), 2.0)))))) / (t_6 - math.pow(B_m, 2.0)) t_9 = math.pow((A + (C + t_0)), 0.5) tmp = 0 if t_8 <= -2e-114: tmp = (t_9 * (math.sqrt((2.0 * t_4)) * math.sqrt(F))) / t_7 elif t_8 <= 4e-143: tmp = math.sqrt(((2.0 * ((F * (B_m * B_m)) * t_5)) + (C * (2.0 * (((C * F) * (((A * -4.0) * t_3) + (0.5 * ((B_m * B_m) * ((1.0 - ((A * A) / t_1)) * t_2))))) + (F * ((t_5 * (A * -4.0)) + ((B_m * B_m) * t_3)))))))) / t_7 elif t_8 <= math.inf: tmp = (t_9 * math.sqrt((t_4 * (2.0 * F)))) / t_7 else: tmp = math.sqrt(F) * (math.sqrt((C + (A + t_0))) * (math.sqrt(2.0) / (0.0 - B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = hypot(B_m, Float64(A - C)) t_1 = Float64(Float64(B_m * B_m) + Float64(A * A)) t_2 = sqrt(Float64(1.0 / t_1)) t_3 = Float64(1.0 - Float64(A * t_2)) t_4 = Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C))) t_5 = Float64(A + hypot(B_m, A)) t_6 = Float64(Float64(4.0 * A) * C) t_7 = Float64(t_6 - Float64(B_m * B_m)) t_8 = Float64(sqrt(Float64(Float64(2.0 * Float64(Float64((B_m ^ 2.0) - t_6) * F)) * Float64(Float64(A + C) + sqrt(Float64((B_m ^ 2.0) + (Float64(A - C) ^ 2.0)))))) / Float64(t_6 - (B_m ^ 2.0))) t_9 = Float64(A + Float64(C + t_0)) ^ 0.5 tmp = 0.0 if (t_8 <= -2e-114) tmp = Float64(Float64(t_9 * Float64(sqrt(Float64(2.0 * t_4)) * sqrt(F))) / t_7); elseif (t_8 <= 4e-143) tmp = Float64(sqrt(Float64(Float64(2.0 * Float64(Float64(F * Float64(B_m * B_m)) * t_5)) + Float64(C * Float64(2.0 * Float64(Float64(Float64(C * F) * Float64(Float64(Float64(A * -4.0) * t_3) + Float64(0.5 * Float64(Float64(B_m * B_m) * Float64(Float64(1.0 - Float64(Float64(A * A) / t_1)) * t_2))))) + Float64(F * Float64(Float64(t_5 * Float64(A * -4.0)) + Float64(Float64(B_m * B_m) * t_3)))))))) / t_7); elseif (t_8 <= Inf) tmp = Float64(Float64(t_9 * sqrt(Float64(t_4 * Float64(2.0 * F)))) / t_7); else tmp = Float64(sqrt(F) * Float64(sqrt(Float64(C + Float64(A + t_0))) * Float64(sqrt(2.0) / Float64(0.0 - B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = hypot(B_m, (A - C)); t_1 = (B_m * B_m) + (A * A); t_2 = sqrt((1.0 / t_1)); t_3 = 1.0 - (A * t_2); t_4 = (B_m * B_m) + (-4.0 * (A * C)); t_5 = A + hypot(B_m, A); t_6 = (4.0 * A) * C; t_7 = t_6 - (B_m * B_m); t_8 = sqrt(((2.0 * (((B_m ^ 2.0) - t_6) * F)) * ((A + C) + sqrt(((B_m ^ 2.0) + ((A - C) ^ 2.0)))))) / (t_6 - (B_m ^ 2.0)); t_9 = (A + (C + t_0)) ^ 0.5; tmp = 0.0; if (t_8 <= -2e-114) tmp = (t_9 * (sqrt((2.0 * t_4)) * sqrt(F))) / t_7; elseif (t_8 <= 4e-143) tmp = sqrt(((2.0 * ((F * (B_m * B_m)) * t_5)) + (C * (2.0 * (((C * F) * (((A * -4.0) * t_3) + (0.5 * ((B_m * B_m) * ((1.0 - ((A * A) / t_1)) * t_2))))) + (F * ((t_5 * (A * -4.0)) + ((B_m * B_m) * t_3)))))))) / t_7; elseif (t_8 <= Inf) tmp = (t_9 * sqrt((t_4 * (2.0 * F)))) / t_7; else tmp = sqrt(F) * (sqrt((C + (A + t_0))) * (sqrt(2.0) / (0.0 - B_m))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, Block[{t$95$1 = N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(A * A), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[N[(1.0 / t$95$1), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(1.0 - N[(A * t$95$2), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(A + N[Sqrt[B$95$m ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$6 = N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]}, Block[{t$95$7 = N[(t$95$6 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$8 = N[(N[Sqrt[N[(N[(2.0 * N[(N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$6), $MachinePrecision] * F), $MachinePrecision]), $MachinePrecision] * N[(N[(A + C), $MachinePrecision] + N[Sqrt[N[(N[Power[B$95$m, 2.0], $MachinePrecision] + N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$6 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$9 = N[Power[N[(A + N[(C + t$95$0), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]}, If[LessEqual[t$95$8, -2e-114], N[(N[(t$95$9 * N[(N[Sqrt[N[(2.0 * t$95$4), $MachinePrecision]], $MachinePrecision] * N[Sqrt[F], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$7), $MachinePrecision], If[LessEqual[t$95$8, 4e-143], N[(N[Sqrt[N[(N[(2.0 * N[(N[(F * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] * t$95$5), $MachinePrecision]), $MachinePrecision] + N[(C * N[(2.0 * N[(N[(N[(C * F), $MachinePrecision] * N[(N[(N[(A * -4.0), $MachinePrecision] * t$95$3), $MachinePrecision] + N[(0.5 * N[(N[(B$95$m * B$95$m), $MachinePrecision] * N[(N[(1.0 - N[(N[(A * A), $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(F * N[(N[(t$95$5 * N[(A * -4.0), $MachinePrecision]), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] * t$95$3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$7), $MachinePrecision], If[LessEqual[t$95$8, Infinity], N[(N[(t$95$9 * N[Sqrt[N[(t$95$4 * N[(2.0 * F), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$7), $MachinePrecision], N[(N[Sqrt[F], $MachinePrecision] * N[(N[Sqrt[N[(C + N[(A + t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \mathsf{hypot}\left(B\_m, A - C\right)\\
t_1 := B\_m \cdot B\_m + A \cdot A\\
t_2 := \sqrt{\frac{1}{t\_1}}\\
t_3 := 1 - A \cdot t\_2\\
t_4 := B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\\
t_5 := A + \mathsf{hypot}\left(B\_m, A\right)\\
t_6 := \left(4 \cdot A\right) \cdot C\\
t_7 := t\_6 - B\_m \cdot B\_m\\
t_8 := \frac{\sqrt{\left(2 \cdot \left(\left({B\_m}^{2} - t\_6\right) \cdot F\right)\right) \cdot \left(\left(A + C\right) + \sqrt{{B\_m}^{2} + {\left(A - C\right)}^{2}}\right)}}{t\_6 - {B\_m}^{2}}\\
t_9 := {\left(A + \left(C + t\_0\right)\right)}^{0.5}\\
\mathbf{if}\;t\_8 \leq -2 \cdot 10^{-114}:\\
\;\;\;\;\frac{t\_9 \cdot \left(\sqrt{2 \cdot t\_4} \cdot \sqrt{F}\right)}{t\_7}\\
\mathbf{elif}\;t\_8 \leq 4 \cdot 10^{-143}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(\left(F \cdot \left(B\_m \cdot B\_m\right)\right) \cdot t\_5\right) + C \cdot \left(2 \cdot \left(\left(C \cdot F\right) \cdot \left(\left(A \cdot -4\right) \cdot t\_3 + 0.5 \cdot \left(\left(B\_m \cdot B\_m\right) \cdot \left(\left(1 - \frac{A \cdot A}{t\_1}\right) \cdot t\_2\right)\right)\right) + F \cdot \left(t\_5 \cdot \left(A \cdot -4\right) + \left(B\_m \cdot B\_m\right) \cdot t\_3\right)\right)\right)}}{t\_7}\\
\mathbf{elif}\;t\_8 \leq \infty:\\
\;\;\;\;\frac{t\_9 \cdot \sqrt{t\_4 \cdot \left(2 \cdot F\right)}}{t\_7}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(\sqrt{C + \left(A + t\_0\right)} \cdot \frac{\sqrt{2}}{0 - B\_m}\right)\\
\end{array}
\end{array}
if (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < -2.0000000000000001e-114Initial program 39.0%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified48.7%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr69.2%
pow1/2N/A
associate-*r*N/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr77.5%
if -2.0000000000000001e-114 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < 3.9999999999999998e-143Initial program 19.7%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified19.7%
Taylor expanded in C around 0
Simplified42.9%
if 3.9999999999999998e-143 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 22.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified55.0%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr87.0%
if +inf.0 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) Initial program 0.0%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified0.4%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr0.0%
Applied egg-rr0.0%
Taylor expanded in B around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f6424.4%
Simplified24.4%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr29.9%
Final simplification51.2%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (hypot B_m (- A C)))
(t_1 (+ (* B_m B_m) (* -4.0 (* A C))))
(t_2 (* (* 4.0 A) C))
(t_3
(/
(sqrt
(*
(* 2.0 (* (- (pow B_m 2.0) t_2) F))
(+ (+ A C) (sqrt (+ (pow B_m 2.0) (pow (- A C) 2.0))))))
(- t_2 (pow B_m 2.0))))
(t_4 (- t_2 (* B_m B_m)))
(t_5 (pow (+ A (+ C t_0)) 0.5)))
(if (<= t_3 -1e-166)
(/ (* t_5 (* (sqrt (* 2.0 t_1)) (sqrt F))) t_4)
(if (<= t_3 4e-143)
(/
(* (sqrt F) (pow (* t_1 (+ (* 4.0 A) (/ (* B_m B_m) (- A C)))) 0.5))
t_4)
(if (<= t_3 INFINITY)
(/ (* t_5 (sqrt (* t_1 (* 2.0 F)))) t_4)
(*
(sqrt F)
(* (sqrt (+ C (+ A t_0))) (/ (sqrt 2.0) (- 0.0 B_m)))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = hypot(B_m, (A - C));
double t_1 = (B_m * B_m) + (-4.0 * (A * C));
double t_2 = (4.0 * A) * C;
double t_3 = sqrt(((2.0 * ((pow(B_m, 2.0) - t_2) * F)) * ((A + C) + sqrt((pow(B_m, 2.0) + pow((A - C), 2.0)))))) / (t_2 - pow(B_m, 2.0));
double t_4 = t_2 - (B_m * B_m);
double t_5 = pow((A + (C + t_0)), 0.5);
double tmp;
if (t_3 <= -1e-166) {
tmp = (t_5 * (sqrt((2.0 * t_1)) * sqrt(F))) / t_4;
} else if (t_3 <= 4e-143) {
tmp = (sqrt(F) * pow((t_1 * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_4;
} else if (t_3 <= ((double) INFINITY)) {
tmp = (t_5 * sqrt((t_1 * (2.0 * F)))) / t_4;
} else {
tmp = sqrt(F) * (sqrt((C + (A + t_0))) * (sqrt(2.0) / (0.0 - B_m)));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = Math.hypot(B_m, (A - C));
double t_1 = (B_m * B_m) + (-4.0 * (A * C));
double t_2 = (4.0 * A) * C;
double t_3 = Math.sqrt(((2.0 * ((Math.pow(B_m, 2.0) - t_2) * F)) * ((A + C) + Math.sqrt((Math.pow(B_m, 2.0) + Math.pow((A - C), 2.0)))))) / (t_2 - Math.pow(B_m, 2.0));
double t_4 = t_2 - (B_m * B_m);
double t_5 = Math.pow((A + (C + t_0)), 0.5);
double tmp;
if (t_3 <= -1e-166) {
tmp = (t_5 * (Math.sqrt((2.0 * t_1)) * Math.sqrt(F))) / t_4;
} else if (t_3 <= 4e-143) {
tmp = (Math.sqrt(F) * Math.pow((t_1 * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_4;
} else if (t_3 <= Double.POSITIVE_INFINITY) {
tmp = (t_5 * Math.sqrt((t_1 * (2.0 * F)))) / t_4;
} else {
tmp = Math.sqrt(F) * (Math.sqrt((C + (A + t_0))) * (Math.sqrt(2.0) / (0.0 - B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = math.hypot(B_m, (A - C)) t_1 = (B_m * B_m) + (-4.0 * (A * C)) t_2 = (4.0 * A) * C t_3 = math.sqrt(((2.0 * ((math.pow(B_m, 2.0) - t_2) * F)) * ((A + C) + math.sqrt((math.pow(B_m, 2.0) + math.pow((A - C), 2.0)))))) / (t_2 - math.pow(B_m, 2.0)) t_4 = t_2 - (B_m * B_m) t_5 = math.pow((A + (C + t_0)), 0.5) tmp = 0 if t_3 <= -1e-166: tmp = (t_5 * (math.sqrt((2.0 * t_1)) * math.sqrt(F))) / t_4 elif t_3 <= 4e-143: tmp = (math.sqrt(F) * math.pow((t_1 * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_4 elif t_3 <= math.inf: tmp = (t_5 * math.sqrt((t_1 * (2.0 * F)))) / t_4 else: tmp = math.sqrt(F) * (math.sqrt((C + (A + t_0))) * (math.sqrt(2.0) / (0.0 - B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = hypot(B_m, Float64(A - C)) t_1 = Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C))) t_2 = Float64(Float64(4.0 * A) * C) t_3 = Float64(sqrt(Float64(Float64(2.0 * Float64(Float64((B_m ^ 2.0) - t_2) * F)) * Float64(Float64(A + C) + sqrt(Float64((B_m ^ 2.0) + (Float64(A - C) ^ 2.0)))))) / Float64(t_2 - (B_m ^ 2.0))) t_4 = Float64(t_2 - Float64(B_m * B_m)) t_5 = Float64(A + Float64(C + t_0)) ^ 0.5 tmp = 0.0 if (t_3 <= -1e-166) tmp = Float64(Float64(t_5 * Float64(sqrt(Float64(2.0 * t_1)) * sqrt(F))) / t_4); elseif (t_3 <= 4e-143) tmp = Float64(Float64(sqrt(F) * (Float64(t_1 * Float64(Float64(4.0 * A) + Float64(Float64(B_m * B_m) / Float64(A - C)))) ^ 0.5)) / t_4); elseif (t_3 <= Inf) tmp = Float64(Float64(t_5 * sqrt(Float64(t_1 * Float64(2.0 * F)))) / t_4); else tmp = Float64(sqrt(F) * Float64(sqrt(Float64(C + Float64(A + t_0))) * Float64(sqrt(2.0) / Float64(0.0 - B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = hypot(B_m, (A - C)); t_1 = (B_m * B_m) + (-4.0 * (A * C)); t_2 = (4.0 * A) * C; t_3 = sqrt(((2.0 * (((B_m ^ 2.0) - t_2) * F)) * ((A + C) + sqrt(((B_m ^ 2.0) + ((A - C) ^ 2.0)))))) / (t_2 - (B_m ^ 2.0)); t_4 = t_2 - (B_m * B_m); t_5 = (A + (C + t_0)) ^ 0.5; tmp = 0.0; if (t_3 <= -1e-166) tmp = (t_5 * (sqrt((2.0 * t_1)) * sqrt(F))) / t_4; elseif (t_3 <= 4e-143) tmp = (sqrt(F) * ((t_1 * ((4.0 * A) + ((B_m * B_m) / (A - C)))) ^ 0.5)) / t_4; elseif (t_3 <= Inf) tmp = (t_5 * sqrt((t_1 * (2.0 * F)))) / t_4; else tmp = sqrt(F) * (sqrt((C + (A + t_0))) * (sqrt(2.0) / (0.0 - B_m))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, Block[{t$95$1 = N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(N[(2.0 * N[(N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$2), $MachinePrecision] * F), $MachinePrecision]), $MachinePrecision] * N[(N[(A + C), $MachinePrecision] + N[Sqrt[N[(N[Power[B$95$m, 2.0], $MachinePrecision] + N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$2 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(t$95$2 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[Power[N[(A + N[(C + t$95$0), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]}, If[LessEqual[t$95$3, -1e-166], N[(N[(t$95$5 * N[(N[Sqrt[N[(2.0 * t$95$1), $MachinePrecision]], $MachinePrecision] * N[Sqrt[F], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$4), $MachinePrecision], If[LessEqual[t$95$3, 4e-143], N[(N[(N[Sqrt[F], $MachinePrecision] * N[Power[N[(t$95$1 * N[(N[(4.0 * A), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision] / t$95$4), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[(t$95$5 * N[Sqrt[N[(t$95$1 * N[(2.0 * F), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$4), $MachinePrecision], N[(N[Sqrt[F], $MachinePrecision] * N[(N[Sqrt[N[(C + N[(A + t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \mathsf{hypot}\left(B\_m, A - C\right)\\
t_1 := B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\\
t_2 := \left(4 \cdot A\right) \cdot C\\
t_3 := \frac{\sqrt{\left(2 \cdot \left(\left({B\_m}^{2} - t\_2\right) \cdot F\right)\right) \cdot \left(\left(A + C\right) + \sqrt{{B\_m}^{2} + {\left(A - C\right)}^{2}}\right)}}{t\_2 - {B\_m}^{2}}\\
t_4 := t\_2 - B\_m \cdot B\_m\\
t_5 := {\left(A + \left(C + t\_0\right)\right)}^{0.5}\\
\mathbf{if}\;t\_3 \leq -1 \cdot 10^{-166}:\\
\;\;\;\;\frac{t\_5 \cdot \left(\sqrt{2 \cdot t\_1} \cdot \sqrt{F}\right)}{t\_4}\\
\mathbf{elif}\;t\_3 \leq 4 \cdot 10^{-143}:\\
\;\;\;\;\frac{\sqrt{F} \cdot {\left(t\_1 \cdot \left(4 \cdot A + \frac{B\_m \cdot B\_m}{A - C}\right)\right)}^{0.5}}{t\_4}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\frac{t\_5 \cdot \sqrt{t\_1 \cdot \left(2 \cdot F\right)}}{t\_4}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(\sqrt{C + \left(A + t\_0\right)} \cdot \frac{\sqrt{2}}{0 - B\_m}\right)\\
\end{array}
\end{array}
if (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < -1.00000000000000004e-166Initial program 44.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified53.2%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr71.9%
pow1/2N/A
associate-*r*N/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr79.4%
if -1.00000000000000004e-166 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < 3.9999999999999998e-143Initial program 4.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified4.1%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr8.9%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6413.8%
Simplified13.8%
*-commutativeN/A
sqrt-prodN/A
pow1/2N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr28.9%
if 3.9999999999999998e-143 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 22.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified55.0%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr87.0%
if +inf.0 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) Initial program 0.0%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified0.4%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr0.0%
Applied egg-rr0.0%
Taylor expanded in B around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f6424.4%
Simplified24.4%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr29.9%
Final simplification50.7%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (hypot B_m (- A C)))
(t_1 (+ (* B_m B_m) (* -4.0 (* A C))))
(t_2 (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= (pow B_m 2.0) 2e-193)
(/ (* (sqrt (* 2.0 (+ A (+ C t_0)))) (sqrt (* F t_1))) t_2)
(if (<= (pow B_m 2.0) 5e-45)
(/
(* (sqrt F) (pow (* t_1 (+ (* 4.0 A) (/ (* B_m B_m) (- A C)))) 0.5))
t_2)
(if (<= (pow B_m 2.0) 1e+289)
(* (sqrt t_1) (* (sqrt F) (/ (sqrt (* 2.0 (+ (+ A C) t_0))) t_2)))
(*
(sqrt F)
(* (sqrt (+ C (+ A t_0))) (/ (sqrt 2.0) (- 0.0 B_m)))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = hypot(B_m, (A - C));
double t_1 = (B_m * B_m) + (-4.0 * (A * C));
double t_2 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (pow(B_m, 2.0) <= 2e-193) {
tmp = (sqrt((2.0 * (A + (C + t_0)))) * sqrt((F * t_1))) / t_2;
} else if (pow(B_m, 2.0) <= 5e-45) {
tmp = (sqrt(F) * pow((t_1 * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_2;
} else if (pow(B_m, 2.0) <= 1e+289) {
tmp = sqrt(t_1) * (sqrt(F) * (sqrt((2.0 * ((A + C) + t_0))) / t_2));
} else {
tmp = sqrt(F) * (sqrt((C + (A + t_0))) * (sqrt(2.0) / (0.0 - B_m)));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = Math.hypot(B_m, (A - C));
double t_1 = (B_m * B_m) + (-4.0 * (A * C));
double t_2 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (Math.pow(B_m, 2.0) <= 2e-193) {
tmp = (Math.sqrt((2.0 * (A + (C + t_0)))) * Math.sqrt((F * t_1))) / t_2;
} else if (Math.pow(B_m, 2.0) <= 5e-45) {
tmp = (Math.sqrt(F) * Math.pow((t_1 * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_2;
} else if (Math.pow(B_m, 2.0) <= 1e+289) {
tmp = Math.sqrt(t_1) * (Math.sqrt(F) * (Math.sqrt((2.0 * ((A + C) + t_0))) / t_2));
} else {
tmp = Math.sqrt(F) * (Math.sqrt((C + (A + t_0))) * (Math.sqrt(2.0) / (0.0 - B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = math.hypot(B_m, (A - C)) t_1 = (B_m * B_m) + (-4.0 * (A * C)) t_2 = ((4.0 * A) * C) - (B_m * B_m) tmp = 0 if math.pow(B_m, 2.0) <= 2e-193: tmp = (math.sqrt((2.0 * (A + (C + t_0)))) * math.sqrt((F * t_1))) / t_2 elif math.pow(B_m, 2.0) <= 5e-45: tmp = (math.sqrt(F) * math.pow((t_1 * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_2 elif math.pow(B_m, 2.0) <= 1e+289: tmp = math.sqrt(t_1) * (math.sqrt(F) * (math.sqrt((2.0 * ((A + C) + t_0))) / t_2)) else: tmp = math.sqrt(F) * (math.sqrt((C + (A + t_0))) * (math.sqrt(2.0) / (0.0 - B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = hypot(B_m, Float64(A - C)) t_1 = Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C))) t_2 = Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)) tmp = 0.0 if ((B_m ^ 2.0) <= 2e-193) tmp = Float64(Float64(sqrt(Float64(2.0 * Float64(A + Float64(C + t_0)))) * sqrt(Float64(F * t_1))) / t_2); elseif ((B_m ^ 2.0) <= 5e-45) tmp = Float64(Float64(sqrt(F) * (Float64(t_1 * Float64(Float64(4.0 * A) + Float64(Float64(B_m * B_m) / Float64(A - C)))) ^ 0.5)) / t_2); elseif ((B_m ^ 2.0) <= 1e+289) tmp = Float64(sqrt(t_1) * Float64(sqrt(F) * Float64(sqrt(Float64(2.0 * Float64(Float64(A + C) + t_0))) / t_2))); else tmp = Float64(sqrt(F) * Float64(sqrt(Float64(C + Float64(A + t_0))) * Float64(sqrt(2.0) / Float64(0.0 - B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = hypot(B_m, (A - C)); t_1 = (B_m * B_m) + (-4.0 * (A * C)); t_2 = ((4.0 * A) * C) - (B_m * B_m); tmp = 0.0; if ((B_m ^ 2.0) <= 2e-193) tmp = (sqrt((2.0 * (A + (C + t_0)))) * sqrt((F * t_1))) / t_2; elseif ((B_m ^ 2.0) <= 5e-45) tmp = (sqrt(F) * ((t_1 * ((4.0 * A) + ((B_m * B_m) / (A - C)))) ^ 0.5)) / t_2; elseif ((B_m ^ 2.0) <= 1e+289) tmp = sqrt(t_1) * (sqrt(F) * (sqrt((2.0 * ((A + C) + t_0))) / t_2)); else tmp = sqrt(F) * (sqrt((C + (A + t_0))) * (sqrt(2.0) / (0.0 - B_m))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, Block[{t$95$1 = N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 2e-193], N[(N[(N[Sqrt[N[(2.0 * N[(A + N[(C + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(F * t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e-45], N[(N[(N[Sqrt[F], $MachinePrecision] * N[Power[N[(t$95$1 * N[(N[(4.0 * A), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 1e+289], N[(N[Sqrt[t$95$1], $MachinePrecision] * N[(N[Sqrt[F], $MachinePrecision] * N[(N[Sqrt[N[(2.0 * N[(N[(A + C), $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[F], $MachinePrecision] * N[(N[Sqrt[N[(C + N[(A + t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \mathsf{hypot}\left(B\_m, A - C\right)\\
t_1 := B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\\
t_2 := \left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m\\
\mathbf{if}\;{B\_m}^{2} \leq 2 \cdot 10^{-193}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(A + \left(C + t\_0\right)\right)} \cdot \sqrt{F \cdot t\_1}}{t\_2}\\
\mathbf{elif}\;{B\_m}^{2} \leq 5 \cdot 10^{-45}:\\
\;\;\;\;\frac{\sqrt{F} \cdot {\left(t\_1 \cdot \left(4 \cdot A + \frac{B\_m \cdot B\_m}{A - C}\right)\right)}^{0.5}}{t\_2}\\
\mathbf{elif}\;{B\_m}^{2} \leq 10^{+289}:\\
\;\;\;\;\sqrt{t\_1} \cdot \left(\sqrt{F} \cdot \frac{\sqrt{2 \cdot \left(\left(A + C\right) + t\_0\right)}}{t\_2}\right)\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(\sqrt{C + \left(A + t\_0\right)} \cdot \frac{\sqrt{2}}{0 - B\_m}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 2.0000000000000001e-193Initial program 19.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified26.9%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr36.2%
if 2.0000000000000001e-193 < (pow.f64 B #s(literal 2 binary64)) < 4.99999999999999976e-45Initial program 12.4%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified16.6%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr21.5%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6415.2%
Simplified15.2%
*-commutativeN/A
sqrt-prodN/A
pow1/2N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr47.0%
if 4.99999999999999976e-45 < (pow.f64 B #s(literal 2 binary64)) < 1.0000000000000001e289Initial program 31.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified37.9%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr56.0%
Applied egg-rr64.9%
if 1.0000000000000001e289 < (pow.f64 B #s(literal 2 binary64)) Initial program 1.6%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified1.7%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr1.6%
Applied egg-rr1.6%
Taylor expanded in B around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f6439.6%
Simplified39.6%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr50.0%
Final simplification49.0%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (hypot B_m (- A C))))
(if (<= (pow B_m 2.0) 1e+80)
(*
(sqrt (* (+ (* B_m B_m) (* -4.0 (* A C))) (* 2.0 F)))
(/ (pow (+ A (+ C t_0)) 0.5) (- (* (* 4.0 A) C) (* B_m B_m))))
(* (sqrt F) (* (sqrt (+ C (+ A t_0))) (/ (sqrt 2.0) (- 0.0 B_m)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = hypot(B_m, (A - C));
double tmp;
if (pow(B_m, 2.0) <= 1e+80) {
tmp = sqrt((((B_m * B_m) + (-4.0 * (A * C))) * (2.0 * F))) * (pow((A + (C + t_0)), 0.5) / (((4.0 * A) * C) - (B_m * B_m)));
} else {
tmp = sqrt(F) * (sqrt((C + (A + t_0))) * (sqrt(2.0) / (0.0 - B_m)));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = Math.hypot(B_m, (A - C));
double tmp;
if (Math.pow(B_m, 2.0) <= 1e+80) {
tmp = Math.sqrt((((B_m * B_m) + (-4.0 * (A * C))) * (2.0 * F))) * (Math.pow((A + (C + t_0)), 0.5) / (((4.0 * A) * C) - (B_m * B_m)));
} else {
tmp = Math.sqrt(F) * (Math.sqrt((C + (A + t_0))) * (Math.sqrt(2.0) / (0.0 - B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = math.hypot(B_m, (A - C)) tmp = 0 if math.pow(B_m, 2.0) <= 1e+80: tmp = math.sqrt((((B_m * B_m) + (-4.0 * (A * C))) * (2.0 * F))) * (math.pow((A + (C + t_0)), 0.5) / (((4.0 * A) * C) - (B_m * B_m))) else: tmp = math.sqrt(F) * (math.sqrt((C + (A + t_0))) * (math.sqrt(2.0) / (0.0 - B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = hypot(B_m, Float64(A - C)) tmp = 0.0 if ((B_m ^ 2.0) <= 1e+80) tmp = Float64(sqrt(Float64(Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C))) * Float64(2.0 * F))) * Float64((Float64(A + Float64(C + t_0)) ^ 0.5) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)))); else tmp = Float64(sqrt(F) * Float64(sqrt(Float64(C + Float64(A + t_0))) * Float64(sqrt(2.0) / Float64(0.0 - B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = hypot(B_m, (A - C)); tmp = 0.0; if ((B_m ^ 2.0) <= 1e+80) tmp = sqrt((((B_m * B_m) + (-4.0 * (A * C))) * (2.0 * F))) * (((A + (C + t_0)) ^ 0.5) / (((4.0 * A) * C) - (B_m * B_m))); else tmp = sqrt(F) * (sqrt((C + (A + t_0))) * (sqrt(2.0) / (0.0 - B_m))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 1e+80], N[(N[Sqrt[N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(2.0 * F), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Power[N[(A + N[(C + t$95$0), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[F], $MachinePrecision] * N[(N[Sqrt[N[(C + N[(A + t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \mathsf{hypot}\left(B\_m, A - C\right)\\
\mathbf{if}\;{B\_m}^{2} \leq 10^{+80}:\\
\;\;\;\;\sqrt{\left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right) \cdot \left(2 \cdot F\right)} \cdot \frac{{\left(A + \left(C + t\_0\right)\right)}^{0.5}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(\sqrt{C + \left(A + t\_0\right)} \cdot \frac{\sqrt{2}}{0 - B\_m}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 1e80Initial program 22.8%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified30.3%
pow1/2N/A
unpow-prod-downN/A
associate-/l*N/A
*-lowering-*.f64N/A
Applied egg-rr39.0%
if 1e80 < (pow.f64 B #s(literal 2 binary64)) Initial program 10.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified12.9%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr22.6%
Applied egg-rr22.6%
Taylor expanded in B around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f6434.2%
Simplified34.2%
*-commutativeN/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr40.0%
Final simplification39.4%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (hypot B_m (- A C))))
(if (<= B_m 3.4e+46)
(*
(sqrt (* (+ (* B_m B_m) (* -4.0 (* A C))) (* 2.0 F)))
(/ (pow (+ A (+ C t_0)) 0.5) (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= B_m 8e+214)
(* (sqrt (+ C (+ A t_0))) (/ (pow (* 2.0 F) 0.5) (- 0.0 B_m)))
(*
(sqrt F)
(* (/ (sqrt 2.0) (- 0.0 B_m)) (sqrt (+ C (hypot B_m C)))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = hypot(B_m, (A - C));
double tmp;
if (B_m <= 3.4e+46) {
tmp = sqrt((((B_m * B_m) + (-4.0 * (A * C))) * (2.0 * F))) * (pow((A + (C + t_0)), 0.5) / (((4.0 * A) * C) - (B_m * B_m)));
} else if (B_m <= 8e+214) {
tmp = sqrt((C + (A + t_0))) * (pow((2.0 * F), 0.5) / (0.0 - B_m));
} else {
tmp = sqrt(F) * ((sqrt(2.0) / (0.0 - B_m)) * sqrt((C + hypot(B_m, C))));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = Math.hypot(B_m, (A - C));
double tmp;
if (B_m <= 3.4e+46) {
tmp = Math.sqrt((((B_m * B_m) + (-4.0 * (A * C))) * (2.0 * F))) * (Math.pow((A + (C + t_0)), 0.5) / (((4.0 * A) * C) - (B_m * B_m)));
} else if (B_m <= 8e+214) {
tmp = Math.sqrt((C + (A + t_0))) * (Math.pow((2.0 * F), 0.5) / (0.0 - B_m));
} else {
tmp = Math.sqrt(F) * ((Math.sqrt(2.0) / (0.0 - B_m)) * Math.sqrt((C + Math.hypot(B_m, C))));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = math.hypot(B_m, (A - C)) tmp = 0 if B_m <= 3.4e+46: tmp = math.sqrt((((B_m * B_m) + (-4.0 * (A * C))) * (2.0 * F))) * (math.pow((A + (C + t_0)), 0.5) / (((4.0 * A) * C) - (B_m * B_m))) elif B_m <= 8e+214: tmp = math.sqrt((C + (A + t_0))) * (math.pow((2.0 * F), 0.5) / (0.0 - B_m)) else: tmp = math.sqrt(F) * ((math.sqrt(2.0) / (0.0 - B_m)) * math.sqrt((C + math.hypot(B_m, C)))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = hypot(B_m, Float64(A - C)) tmp = 0.0 if (B_m <= 3.4e+46) tmp = Float64(sqrt(Float64(Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C))) * Float64(2.0 * F))) * Float64((Float64(A + Float64(C + t_0)) ^ 0.5) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)))); elseif (B_m <= 8e+214) tmp = Float64(sqrt(Float64(C + Float64(A + t_0))) * Float64((Float64(2.0 * F) ^ 0.5) / Float64(0.0 - B_m))); else tmp = Float64(sqrt(F) * Float64(Float64(sqrt(2.0) / Float64(0.0 - B_m)) * sqrt(Float64(C + hypot(B_m, C))))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = hypot(B_m, (A - C)); tmp = 0.0; if (B_m <= 3.4e+46) tmp = sqrt((((B_m * B_m) + (-4.0 * (A * C))) * (2.0 * F))) * (((A + (C + t_0)) ^ 0.5) / (((4.0 * A) * C) - (B_m * B_m))); elseif (B_m <= 8e+214) tmp = sqrt((C + (A + t_0))) * (((2.0 * F) ^ 0.5) / (0.0 - B_m)); else tmp = sqrt(F) * ((sqrt(2.0) / (0.0 - B_m)) * sqrt((C + hypot(B_m, C)))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, If[LessEqual[B$95$m, 3.4e+46], N[(N[Sqrt[N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(2.0 * F), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Power[N[(A + N[(C + t$95$0), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 8e+214], N[(N[Sqrt[N[(C + N[(A + t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Power[N[(2.0 * F), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[F], $MachinePrecision] * N[(N[(N[Sqrt[2.0], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(C + N[Sqrt[B$95$m ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \mathsf{hypot}\left(B\_m, A - C\right)\\
\mathbf{if}\;B\_m \leq 3.4 \cdot 10^{+46}:\\
\;\;\;\;\sqrt{\left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right) \cdot \left(2 \cdot F\right)} \cdot \frac{{\left(A + \left(C + t\_0\right)\right)}^{0.5}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;B\_m \leq 8 \cdot 10^{+214}:\\
\;\;\;\;\sqrt{C + \left(A + t\_0\right)} \cdot \frac{{\left(2 \cdot F\right)}^{0.5}}{0 - B\_m}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(\frac{\sqrt{2}}{0 - B\_m} \cdot \sqrt{C + \mathsf{hypot}\left(B\_m, C\right)}\right)\\
\end{array}
\end{array}
if B < 3.3999999999999998e46Initial program 20.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified25.7%
pow1/2N/A
unpow-prod-downN/A
associate-/l*N/A
*-lowering-*.f64N/A
Applied egg-rr37.0%
if 3.3999999999999998e46 < B < 7.9999999999999996e214Initial program 16.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified22.7%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr25.2%
Applied egg-rr25.3%
Taylor expanded in B around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f6459.8%
Simplified59.8%
*-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f64N/A
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
Applied egg-rr60.0%
if 7.9999999999999996e214 < B Initial program 0.0%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6449.9%
Simplified49.9%
*-commutativeN/A
sqrt-prodN/A
pow1/2N/A
associate-*l*N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
mul-1-negN/A
neg-sub0N/A
Applied egg-rr90.1%
Final simplification44.9%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (pow (* 2.0 F) 0.5)) (t_1 (hypot B_m (- A C))))
(if (<= B_m 1.9e+41)
(*
(sqrt (* (+ (* B_m B_m) (* -4.0 (* A C))) (* 2.0 F)))
(/ (pow (+ A (+ C t_1)) 0.5) (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= B_m 7.2e+219)
(* (sqrt (+ C (+ A t_1))) (/ t_0 (- 0.0 B_m)))
(/ t_0 (- 0.0 (sqrt B_m)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = pow((2.0 * F), 0.5);
double t_1 = hypot(B_m, (A - C));
double tmp;
if (B_m <= 1.9e+41) {
tmp = sqrt((((B_m * B_m) + (-4.0 * (A * C))) * (2.0 * F))) * (pow((A + (C + t_1)), 0.5) / (((4.0 * A) * C) - (B_m * B_m)));
} else if (B_m <= 7.2e+219) {
tmp = sqrt((C + (A + t_1))) * (t_0 / (0.0 - B_m));
} else {
tmp = t_0 / (0.0 - sqrt(B_m));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = Math.pow((2.0 * F), 0.5);
double t_1 = Math.hypot(B_m, (A - C));
double tmp;
if (B_m <= 1.9e+41) {
tmp = Math.sqrt((((B_m * B_m) + (-4.0 * (A * C))) * (2.0 * F))) * (Math.pow((A + (C + t_1)), 0.5) / (((4.0 * A) * C) - (B_m * B_m)));
} else if (B_m <= 7.2e+219) {
tmp = Math.sqrt((C + (A + t_1))) * (t_0 / (0.0 - B_m));
} else {
tmp = t_0 / (0.0 - Math.sqrt(B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = math.pow((2.0 * F), 0.5) t_1 = math.hypot(B_m, (A - C)) tmp = 0 if B_m <= 1.9e+41: tmp = math.sqrt((((B_m * B_m) + (-4.0 * (A * C))) * (2.0 * F))) * (math.pow((A + (C + t_1)), 0.5) / (((4.0 * A) * C) - (B_m * B_m))) elif B_m <= 7.2e+219: tmp = math.sqrt((C + (A + t_1))) * (t_0 / (0.0 - B_m)) else: tmp = t_0 / (0.0 - math.sqrt(B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(2.0 * F) ^ 0.5 t_1 = hypot(B_m, Float64(A - C)) tmp = 0.0 if (B_m <= 1.9e+41) tmp = Float64(sqrt(Float64(Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C))) * Float64(2.0 * F))) * Float64((Float64(A + Float64(C + t_1)) ^ 0.5) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)))); elseif (B_m <= 7.2e+219) tmp = Float64(sqrt(Float64(C + Float64(A + t_1))) * Float64(t_0 / Float64(0.0 - B_m))); else tmp = Float64(t_0 / Float64(0.0 - sqrt(B_m))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = (2.0 * F) ^ 0.5; t_1 = hypot(B_m, (A - C)); tmp = 0.0; if (B_m <= 1.9e+41) tmp = sqrt((((B_m * B_m) + (-4.0 * (A * C))) * (2.0 * F))) * (((A + (C + t_1)) ^ 0.5) / (((4.0 * A) * C) - (B_m * B_m))); elseif (B_m <= 7.2e+219) tmp = sqrt((C + (A + t_1))) * (t_0 / (0.0 - B_m)); else tmp = t_0 / (0.0 - sqrt(B_m)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[Power[N[(2.0 * F), $MachinePrecision], 0.5], $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, If[LessEqual[B$95$m, 1.9e+41], N[(N[Sqrt[N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(2.0 * F), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Power[N[(A + N[(C + t$95$1), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 7.2e+219], N[(N[Sqrt[N[(C + N[(A + t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(t$95$0 / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 / N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := {\left(2 \cdot F\right)}^{0.5}\\
t_1 := \mathsf{hypot}\left(B\_m, A - C\right)\\
\mathbf{if}\;B\_m \leq 1.9 \cdot 10^{+41}:\\
\;\;\;\;\sqrt{\left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right) \cdot \left(2 \cdot F\right)} \cdot \frac{{\left(A + \left(C + t\_1\right)\right)}^{0.5}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;B\_m \leq 7.2 \cdot 10^{+219}:\\
\;\;\;\;\sqrt{C + \left(A + t\_1\right)} \cdot \frac{t\_0}{0 - B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_0}{0 - \sqrt{B\_m}}\\
\end{array}
\end{array}
if B < 1.9000000000000001e41Initial program 20.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified25.7%
pow1/2N/A
unpow-prod-downN/A
associate-/l*N/A
*-lowering-*.f64N/A
Applied egg-rr37.0%
if 1.9000000000000001e41 < B < 7.20000000000000012e219Initial program 16.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified22.7%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr25.2%
Applied egg-rr25.3%
Taylor expanded in B around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f6459.8%
Simplified59.8%
*-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f64N/A
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
Applied egg-rr60.0%
if 7.20000000000000012e219 < B Initial program 0.0%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6461.1%
Simplified61.1%
*-commutativeN/A
sqrt-divN/A
pow1/2N/A
associate-*r/N/A
pow1/2N/A
unpow-prod-downN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6487.2%
Applied egg-rr87.2%
Final simplification44.6%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (hypot B_m (- A C))) (t_1 (pow (* 2.0 F) 0.5)))
(if (<= B_m 1.2e+40)
(/
(*
(sqrt (* 2.0 (+ A (+ C t_0))))
(sqrt (* F (+ (* B_m B_m) (* -4.0 (* A C))))))
(- (* (* 4.0 A) C) (* B_m B_m)))
(if (<= B_m 2.25e+216)
(* (sqrt (+ C (+ A t_0))) (/ t_1 (- 0.0 B_m)))
(/ t_1 (- 0.0 (sqrt B_m)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = hypot(B_m, (A - C));
double t_1 = pow((2.0 * F), 0.5);
double tmp;
if (B_m <= 1.2e+40) {
tmp = (sqrt((2.0 * (A + (C + t_0)))) * sqrt((F * ((B_m * B_m) + (-4.0 * (A * C)))))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (B_m <= 2.25e+216) {
tmp = sqrt((C + (A + t_0))) * (t_1 / (0.0 - B_m));
} else {
tmp = t_1 / (0.0 - sqrt(B_m));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = Math.hypot(B_m, (A - C));
double t_1 = Math.pow((2.0 * F), 0.5);
double tmp;
if (B_m <= 1.2e+40) {
tmp = (Math.sqrt((2.0 * (A + (C + t_0)))) * Math.sqrt((F * ((B_m * B_m) + (-4.0 * (A * C)))))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (B_m <= 2.25e+216) {
tmp = Math.sqrt((C + (A + t_0))) * (t_1 / (0.0 - B_m));
} else {
tmp = t_1 / (0.0 - Math.sqrt(B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = math.hypot(B_m, (A - C)) t_1 = math.pow((2.0 * F), 0.5) tmp = 0 if B_m <= 1.2e+40: tmp = (math.sqrt((2.0 * (A + (C + t_0)))) * math.sqrt((F * ((B_m * B_m) + (-4.0 * (A * C)))))) / (((4.0 * A) * C) - (B_m * B_m)) elif B_m <= 2.25e+216: tmp = math.sqrt((C + (A + t_0))) * (t_1 / (0.0 - B_m)) else: tmp = t_1 / (0.0 - math.sqrt(B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = hypot(B_m, Float64(A - C)) t_1 = Float64(2.0 * F) ^ 0.5 tmp = 0.0 if (B_m <= 1.2e+40) tmp = Float64(Float64(sqrt(Float64(2.0 * Float64(A + Float64(C + t_0)))) * sqrt(Float64(F * Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C)))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); elseif (B_m <= 2.25e+216) tmp = Float64(sqrt(Float64(C + Float64(A + t_0))) * Float64(t_1 / Float64(0.0 - B_m))); else tmp = Float64(t_1 / Float64(0.0 - sqrt(B_m))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = hypot(B_m, (A - C)); t_1 = (2.0 * F) ^ 0.5; tmp = 0.0; if (B_m <= 1.2e+40) tmp = (sqrt((2.0 * (A + (C + t_0)))) * sqrt((F * ((B_m * B_m) + (-4.0 * (A * C)))))) / (((4.0 * A) * C) - (B_m * B_m)); elseif (B_m <= 2.25e+216) tmp = sqrt((C + (A + t_0))) * (t_1 / (0.0 - B_m)); else tmp = t_1 / (0.0 - sqrt(B_m)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, Block[{t$95$1 = N[Power[N[(2.0 * F), $MachinePrecision], 0.5], $MachinePrecision]}, If[LessEqual[B$95$m, 1.2e+40], N[(N[(N[Sqrt[N[(2.0 * N[(A + N[(C + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 2.25e+216], N[(N[Sqrt[N[(C + N[(A + t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(t$95$1 / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 / N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \mathsf{hypot}\left(B\_m, A - C\right)\\
t_1 := {\left(2 \cdot F\right)}^{0.5}\\
\mathbf{if}\;B\_m \leq 1.2 \cdot 10^{+40}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(A + \left(C + t\_0\right)\right)} \cdot \sqrt{F \cdot \left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;B\_m \leq 2.25 \cdot 10^{+216}:\\
\;\;\;\;\sqrt{C + \left(A + t\_0\right)} \cdot \frac{t\_1}{0 - B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_1}{0 - \sqrt{B\_m}}\\
\end{array}
\end{array}
if B < 1.2e40Initial program 20.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified25.7%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr37.0%
if 1.2e40 < B < 2.25000000000000012e216Initial program 16.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified22.7%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr25.2%
Applied egg-rr25.3%
Taylor expanded in B around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f6459.8%
Simplified59.8%
*-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f64N/A
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
Applied egg-rr60.0%
if 2.25000000000000012e216 < B Initial program 0.0%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6461.1%
Simplified61.1%
*-commutativeN/A
sqrt-divN/A
pow1/2N/A
associate-*r/N/A
pow1/2N/A
unpow-prod-downN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6487.2%
Applied egg-rr87.2%
Final simplification44.6%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (pow (* 2.0 F) 0.5))
(t_1 (- (* (* 4.0 A) C) (* B_m B_m)))
(t_2 (hypot B_m (- A C)))
(t_3 (+ (* B_m B_m) (* -4.0 (* A C)))))
(if (<= B_m 2.6e-96)
(* (/ (sqrt (* 2.0 (* F t_3))) t_1) (sqrt (+ (+ A C) t_2)))
(if (<= B_m 7.5e-9)
(/
(* (sqrt F) (pow (* t_3 (+ (* 4.0 A) (/ (* B_m B_m) (- A C)))) 0.5))
t_1)
(if (<= B_m 3.9e+215)
(* (sqrt (+ C (+ A t_2))) (/ t_0 (- 0.0 B_m)))
(/ t_0 (- 0.0 (sqrt B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = pow((2.0 * F), 0.5);
double t_1 = ((4.0 * A) * C) - (B_m * B_m);
double t_2 = hypot(B_m, (A - C));
double t_3 = (B_m * B_m) + (-4.0 * (A * C));
double tmp;
if (B_m <= 2.6e-96) {
tmp = (sqrt((2.0 * (F * t_3))) / t_1) * sqrt(((A + C) + t_2));
} else if (B_m <= 7.5e-9) {
tmp = (sqrt(F) * pow((t_3 * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_1;
} else if (B_m <= 3.9e+215) {
tmp = sqrt((C + (A + t_2))) * (t_0 / (0.0 - B_m));
} else {
tmp = t_0 / (0.0 - sqrt(B_m));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = Math.pow((2.0 * F), 0.5);
double t_1 = ((4.0 * A) * C) - (B_m * B_m);
double t_2 = Math.hypot(B_m, (A - C));
double t_3 = (B_m * B_m) + (-4.0 * (A * C));
double tmp;
if (B_m <= 2.6e-96) {
tmp = (Math.sqrt((2.0 * (F * t_3))) / t_1) * Math.sqrt(((A + C) + t_2));
} else if (B_m <= 7.5e-9) {
tmp = (Math.sqrt(F) * Math.pow((t_3 * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_1;
} else if (B_m <= 3.9e+215) {
tmp = Math.sqrt((C + (A + t_2))) * (t_0 / (0.0 - B_m));
} else {
tmp = t_0 / (0.0 - Math.sqrt(B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = math.pow((2.0 * F), 0.5) t_1 = ((4.0 * A) * C) - (B_m * B_m) t_2 = math.hypot(B_m, (A - C)) t_3 = (B_m * B_m) + (-4.0 * (A * C)) tmp = 0 if B_m <= 2.6e-96: tmp = (math.sqrt((2.0 * (F * t_3))) / t_1) * math.sqrt(((A + C) + t_2)) elif B_m <= 7.5e-9: tmp = (math.sqrt(F) * math.pow((t_3 * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_1 elif B_m <= 3.9e+215: tmp = math.sqrt((C + (A + t_2))) * (t_0 / (0.0 - B_m)) else: tmp = t_0 / (0.0 - math.sqrt(B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(2.0 * F) ^ 0.5 t_1 = Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)) t_2 = hypot(B_m, Float64(A - C)) t_3 = Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C))) tmp = 0.0 if (B_m <= 2.6e-96) tmp = Float64(Float64(sqrt(Float64(2.0 * Float64(F * t_3))) / t_1) * sqrt(Float64(Float64(A + C) + t_2))); elseif (B_m <= 7.5e-9) tmp = Float64(Float64(sqrt(F) * (Float64(t_3 * Float64(Float64(4.0 * A) + Float64(Float64(B_m * B_m) / Float64(A - C)))) ^ 0.5)) / t_1); elseif (B_m <= 3.9e+215) tmp = Float64(sqrt(Float64(C + Float64(A + t_2))) * Float64(t_0 / Float64(0.0 - B_m))); else tmp = Float64(t_0 / Float64(0.0 - sqrt(B_m))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = (2.0 * F) ^ 0.5; t_1 = ((4.0 * A) * C) - (B_m * B_m); t_2 = hypot(B_m, (A - C)); t_3 = (B_m * B_m) + (-4.0 * (A * C)); tmp = 0.0; if (B_m <= 2.6e-96) tmp = (sqrt((2.0 * (F * t_3))) / t_1) * sqrt(((A + C) + t_2)); elseif (B_m <= 7.5e-9) tmp = (sqrt(F) * ((t_3 * ((4.0 * A) + ((B_m * B_m) / (A - C)))) ^ 0.5)) / t_1; elseif (B_m <= 3.9e+215) tmp = sqrt((C + (A + t_2))) * (t_0 / (0.0 - B_m)); else tmp = t_0 / (0.0 - sqrt(B_m)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[Power[N[(2.0 * F), $MachinePrecision], 0.5], $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, Block[{t$95$3 = N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 2.6e-96], N[(N[(N[Sqrt[N[(2.0 * N[(F * t$95$3), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision] * N[Sqrt[N[(N[(A + C), $MachinePrecision] + t$95$2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 7.5e-9], N[(N[(N[Sqrt[F], $MachinePrecision] * N[Power[N[(t$95$3 * N[(N[(4.0 * A), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[B$95$m, 3.9e+215], N[(N[Sqrt[N[(C + N[(A + t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(t$95$0 / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 / N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := {\left(2 \cdot F\right)}^{0.5}\\
t_1 := \left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m\\
t_2 := \mathsf{hypot}\left(B\_m, A - C\right)\\
t_3 := B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\\
\mathbf{if}\;B\_m \leq 2.6 \cdot 10^{-96}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot t\_3\right)}}{t\_1} \cdot \sqrt{\left(A + C\right) + t\_2}\\
\mathbf{elif}\;B\_m \leq 7.5 \cdot 10^{-9}:\\
\;\;\;\;\frac{\sqrt{F} \cdot {\left(t\_3 \cdot \left(4 \cdot A + \frac{B\_m \cdot B\_m}{A - C}\right)\right)}^{0.5}}{t\_1}\\
\mathbf{elif}\;B\_m \leq 3.9 \cdot 10^{+215}:\\
\;\;\;\;\sqrt{C + \left(A + t\_2\right)} \cdot \frac{t\_0}{0 - B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_0}{0 - \sqrt{B\_m}}\\
\end{array}
\end{array}
if B < 2.6000000000000002e-96Initial program 19.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified24.6%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr37.2%
Applied egg-rr36.5%
if 2.6000000000000002e-96 < B < 7.49999999999999933e-9Initial program 15.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified20.0%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr24.5%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6414.2%
Simplified14.2%
*-commutativeN/A
sqrt-prodN/A
pow1/2N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr45.8%
if 7.49999999999999933e-9 < B < 3.89999999999999965e215Initial program 23.6%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified31.3%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr33.5%
Applied egg-rr33.4%
Taylor expanded in B around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f6461.9%
Simplified61.9%
*-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f64N/A
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
Applied egg-rr62.2%
if 3.89999999999999965e215 < B Initial program 0.0%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6461.1%
Simplified61.1%
*-commutativeN/A
sqrt-divN/A
pow1/2N/A
associate-*r/N/A
pow1/2N/A
unpow-prod-downN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6487.2%
Applied egg-rr87.2%
Final simplification46.0%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (pow (* 2.0 F) 0.5))
(t_1 (* (* 4.0 A) C))
(t_2 (- t_1 (* B_m B_m)))
(t_3 (hypot B_m (- A C))))
(if (<= B_m 3.5e-96)
(/ (sqrt (* (+ (+ A C) t_3) (* (* 2.0 F) (- (* B_m B_m) t_1)))) t_2)
(if (<= B_m 5.1e-7)
(/
(*
(sqrt F)
(pow
(*
(+ (* B_m B_m) (* -4.0 (* A C)))
(+ (* 4.0 A) (/ (* B_m B_m) (- A C))))
0.5))
t_2)
(if (<= B_m 1.35e+218)
(* (sqrt (+ C (+ A t_3))) (/ t_0 (- 0.0 B_m)))
(/ t_0 (- 0.0 (sqrt B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = pow((2.0 * F), 0.5);
double t_1 = (4.0 * A) * C;
double t_2 = t_1 - (B_m * B_m);
double t_3 = hypot(B_m, (A - C));
double tmp;
if (B_m <= 3.5e-96) {
tmp = sqrt((((A + C) + t_3) * ((2.0 * F) * ((B_m * B_m) - t_1)))) / t_2;
} else if (B_m <= 5.1e-7) {
tmp = (sqrt(F) * pow((((B_m * B_m) + (-4.0 * (A * C))) * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_2;
} else if (B_m <= 1.35e+218) {
tmp = sqrt((C + (A + t_3))) * (t_0 / (0.0 - B_m));
} else {
tmp = t_0 / (0.0 - sqrt(B_m));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = Math.pow((2.0 * F), 0.5);
double t_1 = (4.0 * A) * C;
double t_2 = t_1 - (B_m * B_m);
double t_3 = Math.hypot(B_m, (A - C));
double tmp;
if (B_m <= 3.5e-96) {
tmp = Math.sqrt((((A + C) + t_3) * ((2.0 * F) * ((B_m * B_m) - t_1)))) / t_2;
} else if (B_m <= 5.1e-7) {
tmp = (Math.sqrt(F) * Math.pow((((B_m * B_m) + (-4.0 * (A * C))) * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_2;
} else if (B_m <= 1.35e+218) {
tmp = Math.sqrt((C + (A + t_3))) * (t_0 / (0.0 - B_m));
} else {
tmp = t_0 / (0.0 - Math.sqrt(B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = math.pow((2.0 * F), 0.5) t_1 = (4.0 * A) * C t_2 = t_1 - (B_m * B_m) t_3 = math.hypot(B_m, (A - C)) tmp = 0 if B_m <= 3.5e-96: tmp = math.sqrt((((A + C) + t_3) * ((2.0 * F) * ((B_m * B_m) - t_1)))) / t_2 elif B_m <= 5.1e-7: tmp = (math.sqrt(F) * math.pow((((B_m * B_m) + (-4.0 * (A * C))) * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_2 elif B_m <= 1.35e+218: tmp = math.sqrt((C + (A + t_3))) * (t_0 / (0.0 - B_m)) else: tmp = t_0 / (0.0 - math.sqrt(B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(2.0 * F) ^ 0.5 t_1 = Float64(Float64(4.0 * A) * C) t_2 = Float64(t_1 - Float64(B_m * B_m)) t_3 = hypot(B_m, Float64(A - C)) tmp = 0.0 if (B_m <= 3.5e-96) tmp = Float64(sqrt(Float64(Float64(Float64(A + C) + t_3) * Float64(Float64(2.0 * F) * Float64(Float64(B_m * B_m) - t_1)))) / t_2); elseif (B_m <= 5.1e-7) tmp = Float64(Float64(sqrt(F) * (Float64(Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C))) * Float64(Float64(4.0 * A) + Float64(Float64(B_m * B_m) / Float64(A - C)))) ^ 0.5)) / t_2); elseif (B_m <= 1.35e+218) tmp = Float64(sqrt(Float64(C + Float64(A + t_3))) * Float64(t_0 / Float64(0.0 - B_m))); else tmp = Float64(t_0 / Float64(0.0 - sqrt(B_m))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = (2.0 * F) ^ 0.5; t_1 = (4.0 * A) * C; t_2 = t_1 - (B_m * B_m); t_3 = hypot(B_m, (A - C)); tmp = 0.0; if (B_m <= 3.5e-96) tmp = sqrt((((A + C) + t_3) * ((2.0 * F) * ((B_m * B_m) - t_1)))) / t_2; elseif (B_m <= 5.1e-7) tmp = (sqrt(F) * ((((B_m * B_m) + (-4.0 * (A * C))) * ((4.0 * A) + ((B_m * B_m) / (A - C)))) ^ 0.5)) / t_2; elseif (B_m <= 1.35e+218) tmp = sqrt((C + (A + t_3))) * (t_0 / (0.0 - B_m)); else tmp = t_0 / (0.0 - sqrt(B_m)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[Power[N[(2.0 * F), $MachinePrecision], 0.5], $MachinePrecision]}, Block[{t$95$1 = N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, If[LessEqual[B$95$m, 3.5e-96], N[(N[Sqrt[N[(N[(N[(A + C), $MachinePrecision] + t$95$3), $MachinePrecision] * N[(N[(2.0 * F), $MachinePrecision] * N[(N[(B$95$m * B$95$m), $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[B$95$m, 5.1e-7], N[(N[(N[Sqrt[F], $MachinePrecision] * N[Power[N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(4.0 * A), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[B$95$m, 1.35e+218], N[(N[Sqrt[N[(C + N[(A + t$95$3), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(t$95$0 / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$0 / N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := {\left(2 \cdot F\right)}^{0.5}\\
t_1 := \left(4 \cdot A\right) \cdot C\\
t_2 := t\_1 - B\_m \cdot B\_m\\
t_3 := \mathsf{hypot}\left(B\_m, A - C\right)\\
\mathbf{if}\;B\_m \leq 3.5 \cdot 10^{-96}:\\
\;\;\;\;\frac{\sqrt{\left(\left(A + C\right) + t\_3\right) \cdot \left(\left(2 \cdot F\right) \cdot \left(B\_m \cdot B\_m - t\_1\right)\right)}}{t\_2}\\
\mathbf{elif}\;B\_m \leq 5.1 \cdot 10^{-7}:\\
\;\;\;\;\frac{\sqrt{F} \cdot {\left(\left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right) \cdot \left(4 \cdot A + \frac{B\_m \cdot B\_m}{A - C}\right)\right)}^{0.5}}{t\_2}\\
\mathbf{elif}\;B\_m \leq 1.35 \cdot 10^{+218}:\\
\;\;\;\;\sqrt{C + \left(A + t\_3\right)} \cdot \frac{t\_0}{0 - B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_0}{0 - \sqrt{B\_m}}\\
\end{array}
\end{array}
if B < 3.4999999999999999e-96Initial program 19.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified24.6%
if 3.4999999999999999e-96 < B < 5.0999999999999999e-7Initial program 15.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified20.0%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr24.5%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6414.2%
Simplified14.2%
*-commutativeN/A
sqrt-prodN/A
pow1/2N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr45.8%
if 5.0999999999999999e-7 < B < 1.35000000000000006e218Initial program 23.6%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified31.3%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr33.5%
Applied egg-rr33.4%
Taylor expanded in B around inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f6461.9%
Simplified61.9%
*-commutativeN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
associate-+r+N/A
+-commutativeN/A
+-lowering-+.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f64N/A
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
Applied egg-rr62.2%
if 1.35000000000000006e218 < B Initial program 0.0%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6461.1%
Simplified61.1%
*-commutativeN/A
sqrt-divN/A
pow1/2N/A
associate-*r/N/A
pow1/2N/A
unpow-prod-downN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6487.2%
Applied egg-rr87.2%
Final simplification38.0%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (* (* 4.0 A) C))
(t_1 (- t_0 (* B_m B_m)))
(t_2 (pow (* 2.0 F) 0.5)))
(if (<= B_m 3.8e-97)
(/
(sqrt
(* (+ (+ A C) (hypot B_m (- A C))) (* (* 2.0 F) (- (* B_m B_m) t_0))))
t_1)
(if (<= B_m 0.00022)
(/
(*
(sqrt F)
(pow
(*
(+ (* B_m B_m) (* -4.0 (* A C)))
(+ (* 4.0 A) (/ (* B_m B_m) (- A C))))
0.5))
t_1)
(if (<= B_m 8.1e+214)
(* (/ t_2 (- 0.0 B_m)) (sqrt (+ C (hypot B_m C))))
(/ t_2 (- 0.0 (sqrt B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = (4.0 * A) * C;
double t_1 = t_0 - (B_m * B_m);
double t_2 = pow((2.0 * F), 0.5);
double tmp;
if (B_m <= 3.8e-97) {
tmp = sqrt((((A + C) + hypot(B_m, (A - C))) * ((2.0 * F) * ((B_m * B_m) - t_0)))) / t_1;
} else if (B_m <= 0.00022) {
tmp = (sqrt(F) * pow((((B_m * B_m) + (-4.0 * (A * C))) * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_1;
} else if (B_m <= 8.1e+214) {
tmp = (t_2 / (0.0 - B_m)) * sqrt((C + hypot(B_m, C)));
} else {
tmp = t_2 / (0.0 - sqrt(B_m));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = (4.0 * A) * C;
double t_1 = t_0 - (B_m * B_m);
double t_2 = Math.pow((2.0 * F), 0.5);
double tmp;
if (B_m <= 3.8e-97) {
tmp = Math.sqrt((((A + C) + Math.hypot(B_m, (A - C))) * ((2.0 * F) * ((B_m * B_m) - t_0)))) / t_1;
} else if (B_m <= 0.00022) {
tmp = (Math.sqrt(F) * Math.pow((((B_m * B_m) + (-4.0 * (A * C))) * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_1;
} else if (B_m <= 8.1e+214) {
tmp = (t_2 / (0.0 - B_m)) * Math.sqrt((C + Math.hypot(B_m, C)));
} else {
tmp = t_2 / (0.0 - Math.sqrt(B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = (4.0 * A) * C t_1 = t_0 - (B_m * B_m) t_2 = math.pow((2.0 * F), 0.5) tmp = 0 if B_m <= 3.8e-97: tmp = math.sqrt((((A + C) + math.hypot(B_m, (A - C))) * ((2.0 * F) * ((B_m * B_m) - t_0)))) / t_1 elif B_m <= 0.00022: tmp = (math.sqrt(F) * math.pow((((B_m * B_m) + (-4.0 * (A * C))) * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_1 elif B_m <= 8.1e+214: tmp = (t_2 / (0.0 - B_m)) * math.sqrt((C + math.hypot(B_m, C))) else: tmp = t_2 / (0.0 - math.sqrt(B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(4.0 * A) * C) t_1 = Float64(t_0 - Float64(B_m * B_m)) t_2 = Float64(2.0 * F) ^ 0.5 tmp = 0.0 if (B_m <= 3.8e-97) tmp = Float64(sqrt(Float64(Float64(Float64(A + C) + hypot(B_m, Float64(A - C))) * Float64(Float64(2.0 * F) * Float64(Float64(B_m * B_m) - t_0)))) / t_1); elseif (B_m <= 0.00022) tmp = Float64(Float64(sqrt(F) * (Float64(Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C))) * Float64(Float64(4.0 * A) + Float64(Float64(B_m * B_m) / Float64(A - C)))) ^ 0.5)) / t_1); elseif (B_m <= 8.1e+214) tmp = Float64(Float64(t_2 / Float64(0.0 - B_m)) * sqrt(Float64(C + hypot(B_m, C)))); else tmp = Float64(t_2 / Float64(0.0 - sqrt(B_m))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = (4.0 * A) * C; t_1 = t_0 - (B_m * B_m); t_2 = (2.0 * F) ^ 0.5; tmp = 0.0; if (B_m <= 3.8e-97) tmp = sqrt((((A + C) + hypot(B_m, (A - C))) * ((2.0 * F) * ((B_m * B_m) - t_0)))) / t_1; elseif (B_m <= 0.00022) tmp = (sqrt(F) * ((((B_m * B_m) + (-4.0 * (A * C))) * ((4.0 * A) + ((B_m * B_m) / (A - C)))) ^ 0.5)) / t_1; elseif (B_m <= 8.1e+214) tmp = (t_2 / (0.0 - B_m)) * sqrt((C + hypot(B_m, C))); else tmp = t_2 / (0.0 - sqrt(B_m)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[Power[N[(2.0 * F), $MachinePrecision], 0.5], $MachinePrecision]}, If[LessEqual[B$95$m, 3.8e-97], N[(N[Sqrt[N[(N[(N[(A + C), $MachinePrecision] + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 * F), $MachinePrecision] * N[(N[(B$95$m * B$95$m), $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[B$95$m, 0.00022], N[(N[(N[Sqrt[F], $MachinePrecision] * N[Power[N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(4.0 * A), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[B$95$m, 8.1e+214], N[(N[(t$95$2 / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(C + N[Sqrt[B$95$m ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(t$95$2 / N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \left(4 \cdot A\right) \cdot C\\
t_1 := t\_0 - B\_m \cdot B\_m\\
t_2 := {\left(2 \cdot F\right)}^{0.5}\\
\mathbf{if}\;B\_m \leq 3.8 \cdot 10^{-97}:\\
\;\;\;\;\frac{\sqrt{\left(\left(A + C\right) + \mathsf{hypot}\left(B\_m, A - C\right)\right) \cdot \left(\left(2 \cdot F\right) \cdot \left(B\_m \cdot B\_m - t\_0\right)\right)}}{t\_1}\\
\mathbf{elif}\;B\_m \leq 0.00022:\\
\;\;\;\;\frac{\sqrt{F} \cdot {\left(\left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right) \cdot \left(4 \cdot A + \frac{B\_m \cdot B\_m}{A - C}\right)\right)}^{0.5}}{t\_1}\\
\mathbf{elif}\;B\_m \leq 8.1 \cdot 10^{+214}:\\
\;\;\;\;\frac{t\_2}{0 - B\_m} \cdot \sqrt{C + \mathsf{hypot}\left(B\_m, C\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_2}{0 - \sqrt{B\_m}}\\
\end{array}
\end{array}
if B < 3.8000000000000001e-97Initial program 19.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified24.6%
if 3.8000000000000001e-97 < B < 2.20000000000000008e-4Initial program 14.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified22.5%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr26.6%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6417.1%
Simplified17.1%
*-commutativeN/A
sqrt-prodN/A
pow1/2N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr46.1%
if 2.20000000000000008e-4 < B < 8.0999999999999998e214Initial program 24.8%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6445.3%
Simplified45.3%
sqrt-prodN/A
pow1/2N/A
associate-*r*N/A
*-lowering-*.f64N/A
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
pow1/2N/A
pow1/2N/A
pow-prod-downN/A
pow1/2N/A
/-lowering-/.f64N/A
pow1/2N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
pow1/2N/A
Applied egg-rr53.2%
if 8.0999999999999998e214 < B Initial program 0.0%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6461.1%
Simplified61.1%
*-commutativeN/A
sqrt-divN/A
pow1/2N/A
associate-*r/N/A
pow1/2N/A
unpow-prod-downN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6487.2%
Applied egg-rr87.2%
Final simplification36.6%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (* (* 4.0 A) C))
(t_1 (- t_0 (* B_m B_m)))
(t_2 (+ (+ A C) (hypot B_m (- A C)))))
(if (<= B_m 1.1e-96)
(/ (sqrt (* t_2 (* (* 2.0 F) (- (* B_m B_m) t_0)))) t_1)
(if (<= B_m 1.28e-8)
(/
(*
(sqrt F)
(pow
(*
(+ (* B_m B_m) (* -4.0 (* A C)))
(+ (* 4.0 A) (/ (* B_m B_m) (- A C))))
0.5))
t_1)
(if (<= B_m 1.8e+129)
(* B_m (/ (sqrt (* F (* 2.0 t_2))) t_1))
(/ (pow (* 2.0 F) 0.5) (- 0.0 (sqrt B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = (4.0 * A) * C;
double t_1 = t_0 - (B_m * B_m);
double t_2 = (A + C) + hypot(B_m, (A - C));
double tmp;
if (B_m <= 1.1e-96) {
tmp = sqrt((t_2 * ((2.0 * F) * ((B_m * B_m) - t_0)))) / t_1;
} else if (B_m <= 1.28e-8) {
tmp = (sqrt(F) * pow((((B_m * B_m) + (-4.0 * (A * C))) * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_1;
} else if (B_m <= 1.8e+129) {
tmp = B_m * (sqrt((F * (2.0 * t_2))) / t_1);
} else {
tmp = pow((2.0 * F), 0.5) / (0.0 - sqrt(B_m));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = (4.0 * A) * C;
double t_1 = t_0 - (B_m * B_m);
double t_2 = (A + C) + Math.hypot(B_m, (A - C));
double tmp;
if (B_m <= 1.1e-96) {
tmp = Math.sqrt((t_2 * ((2.0 * F) * ((B_m * B_m) - t_0)))) / t_1;
} else if (B_m <= 1.28e-8) {
tmp = (Math.sqrt(F) * Math.pow((((B_m * B_m) + (-4.0 * (A * C))) * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_1;
} else if (B_m <= 1.8e+129) {
tmp = B_m * (Math.sqrt((F * (2.0 * t_2))) / t_1);
} else {
tmp = Math.pow((2.0 * F), 0.5) / (0.0 - Math.sqrt(B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = (4.0 * A) * C t_1 = t_0 - (B_m * B_m) t_2 = (A + C) + math.hypot(B_m, (A - C)) tmp = 0 if B_m <= 1.1e-96: tmp = math.sqrt((t_2 * ((2.0 * F) * ((B_m * B_m) - t_0)))) / t_1 elif B_m <= 1.28e-8: tmp = (math.sqrt(F) * math.pow((((B_m * B_m) + (-4.0 * (A * C))) * ((4.0 * A) + ((B_m * B_m) / (A - C)))), 0.5)) / t_1 elif B_m <= 1.8e+129: tmp = B_m * (math.sqrt((F * (2.0 * t_2))) / t_1) else: tmp = math.pow((2.0 * F), 0.5) / (0.0 - math.sqrt(B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(4.0 * A) * C) t_1 = Float64(t_0 - Float64(B_m * B_m)) t_2 = Float64(Float64(A + C) + hypot(B_m, Float64(A - C))) tmp = 0.0 if (B_m <= 1.1e-96) tmp = Float64(sqrt(Float64(t_2 * Float64(Float64(2.0 * F) * Float64(Float64(B_m * B_m) - t_0)))) / t_1); elseif (B_m <= 1.28e-8) tmp = Float64(Float64(sqrt(F) * (Float64(Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C))) * Float64(Float64(4.0 * A) + Float64(Float64(B_m * B_m) / Float64(A - C)))) ^ 0.5)) / t_1); elseif (B_m <= 1.8e+129) tmp = Float64(B_m * Float64(sqrt(Float64(F * Float64(2.0 * t_2))) / t_1)); else tmp = Float64((Float64(2.0 * F) ^ 0.5) / Float64(0.0 - sqrt(B_m))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = (4.0 * A) * C; t_1 = t_0 - (B_m * B_m); t_2 = (A + C) + hypot(B_m, (A - C)); tmp = 0.0; if (B_m <= 1.1e-96) tmp = sqrt((t_2 * ((2.0 * F) * ((B_m * B_m) - t_0)))) / t_1; elseif (B_m <= 1.28e-8) tmp = (sqrt(F) * ((((B_m * B_m) + (-4.0 * (A * C))) * ((4.0 * A) + ((B_m * B_m) / (A - C)))) ^ 0.5)) / t_1; elseif (B_m <= 1.8e+129) tmp = B_m * (sqrt((F * (2.0 * t_2))) / t_1); else tmp = ((2.0 * F) ^ 0.5) / (0.0 - sqrt(B_m)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(A + C), $MachinePrecision] + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 1.1e-96], N[(N[Sqrt[N[(t$95$2 * N[(N[(2.0 * F), $MachinePrecision] * N[(N[(B$95$m * B$95$m), $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[B$95$m, 1.28e-8], N[(N[(N[Sqrt[F], $MachinePrecision] * N[Power[N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(4.0 * A), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[B$95$m, 1.8e+129], N[(B$95$m * N[(N[Sqrt[N[(F * N[(2.0 * t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(2.0 * F), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \left(4 \cdot A\right) \cdot C\\
t_1 := t\_0 - B\_m \cdot B\_m\\
t_2 := \left(A + C\right) + \mathsf{hypot}\left(B\_m, A - C\right)\\
\mathbf{if}\;B\_m \leq 1.1 \cdot 10^{-96}:\\
\;\;\;\;\frac{\sqrt{t\_2 \cdot \left(\left(2 \cdot F\right) \cdot \left(B\_m \cdot B\_m - t\_0\right)\right)}}{t\_1}\\
\mathbf{elif}\;B\_m \leq 1.28 \cdot 10^{-8}:\\
\;\;\;\;\frac{\sqrt{F} \cdot {\left(\left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right) \cdot \left(4 \cdot A + \frac{B\_m \cdot B\_m}{A - C}\right)\right)}^{0.5}}{t\_1}\\
\mathbf{elif}\;B\_m \leq 1.8 \cdot 10^{+129}:\\
\;\;\;\;B\_m \cdot \frac{\sqrt{F \cdot \left(2 \cdot t\_2\right)}}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(2 \cdot F\right)}^{0.5}}{0 - \sqrt{B\_m}}\\
\end{array}
\end{array}
if B < 1.0999999999999999e-96Initial program 19.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified24.6%
if 1.0999999999999999e-96 < B < 1.28000000000000005e-8Initial program 15.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified20.0%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr24.5%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6414.2%
Simplified14.2%
*-commutativeN/A
sqrt-prodN/A
pow1/2N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr45.8%
if 1.28000000000000005e-8 < B < 1.8000000000000001e129Initial program 38.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified50.5%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr54.1%
Taylor expanded in B around inf
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6462.9%
Simplified62.9%
associate-*l*N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
Applied egg-rr59.5%
if 1.8000000000000001e129 < B Initial program 0.1%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6447.5%
Simplified47.5%
*-commutativeN/A
sqrt-divN/A
pow1/2N/A
associate-*r/N/A
pow1/2N/A
unpow-prod-downN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6463.8%
Applied egg-rr63.8%
Final simplification35.7%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (* (* 4.0 A) C))
(t_1 (- t_0 (* B_m B_m)))
(t_2 (+ (+ A C) (hypot B_m (- A C)))))
(if (<= B_m 3.9e-112)
(/ (sqrt (* t_2 (* (* 2.0 F) (- (* B_m B_m) t_0)))) (* 4.0 (* A C)))
(if (<= B_m 9.6e-9)
(/
(sqrt
(*
(* F (+ (* B_m B_m) (* -4.0 (* A C))))
(+ (* 4.0 A) (/ (* B_m B_m) (- A C)))))
t_1)
(if (<= B_m 3.4e+129)
(* B_m (/ (sqrt (* F (* 2.0 t_2))) t_1))
(/ (pow (* 2.0 F) 0.5) (- 0.0 (sqrt B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = (4.0 * A) * C;
double t_1 = t_0 - (B_m * B_m);
double t_2 = (A + C) + hypot(B_m, (A - C));
double tmp;
if (B_m <= 3.9e-112) {
tmp = sqrt((t_2 * ((2.0 * F) * ((B_m * B_m) - t_0)))) / (4.0 * (A * C));
} else if (B_m <= 9.6e-9) {
tmp = sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_1;
} else if (B_m <= 3.4e+129) {
tmp = B_m * (sqrt((F * (2.0 * t_2))) / t_1);
} else {
tmp = pow((2.0 * F), 0.5) / (0.0 - sqrt(B_m));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = (4.0 * A) * C;
double t_1 = t_0 - (B_m * B_m);
double t_2 = (A + C) + Math.hypot(B_m, (A - C));
double tmp;
if (B_m <= 3.9e-112) {
tmp = Math.sqrt((t_2 * ((2.0 * F) * ((B_m * B_m) - t_0)))) / (4.0 * (A * C));
} else if (B_m <= 9.6e-9) {
tmp = Math.sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_1;
} else if (B_m <= 3.4e+129) {
tmp = B_m * (Math.sqrt((F * (2.0 * t_2))) / t_1);
} else {
tmp = Math.pow((2.0 * F), 0.5) / (0.0 - Math.sqrt(B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = (4.0 * A) * C t_1 = t_0 - (B_m * B_m) t_2 = (A + C) + math.hypot(B_m, (A - C)) tmp = 0 if B_m <= 3.9e-112: tmp = math.sqrt((t_2 * ((2.0 * F) * ((B_m * B_m) - t_0)))) / (4.0 * (A * C)) elif B_m <= 9.6e-9: tmp = math.sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_1 elif B_m <= 3.4e+129: tmp = B_m * (math.sqrt((F * (2.0 * t_2))) / t_1) else: tmp = math.pow((2.0 * F), 0.5) / (0.0 - math.sqrt(B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(4.0 * A) * C) t_1 = Float64(t_0 - Float64(B_m * B_m)) t_2 = Float64(Float64(A + C) + hypot(B_m, Float64(A - C))) tmp = 0.0 if (B_m <= 3.9e-112) tmp = Float64(sqrt(Float64(t_2 * Float64(Float64(2.0 * F) * Float64(Float64(B_m * B_m) - t_0)))) / Float64(4.0 * Float64(A * C))); elseif (B_m <= 9.6e-9) tmp = Float64(sqrt(Float64(Float64(F * Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C)))) * Float64(Float64(4.0 * A) + Float64(Float64(B_m * B_m) / Float64(A - C))))) / t_1); elseif (B_m <= 3.4e+129) tmp = Float64(B_m * Float64(sqrt(Float64(F * Float64(2.0 * t_2))) / t_1)); else tmp = Float64((Float64(2.0 * F) ^ 0.5) / Float64(0.0 - sqrt(B_m))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = (4.0 * A) * C; t_1 = t_0 - (B_m * B_m); t_2 = (A + C) + hypot(B_m, (A - C)); tmp = 0.0; if (B_m <= 3.9e-112) tmp = sqrt((t_2 * ((2.0 * F) * ((B_m * B_m) - t_0)))) / (4.0 * (A * C)); elseif (B_m <= 9.6e-9) tmp = sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_1; elseif (B_m <= 3.4e+129) tmp = B_m * (sqrt((F * (2.0 * t_2))) / t_1); else tmp = ((2.0 * F) ^ 0.5) / (0.0 - sqrt(B_m)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(A + C), $MachinePrecision] + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 3.9e-112], N[(N[Sqrt[N[(t$95$2 * N[(N[(2.0 * F), $MachinePrecision] * N[(N[(B$95$m * B$95$m), $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 9.6e-9], N[(N[Sqrt[N[(N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(4.0 * A), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[B$95$m, 3.4e+129], N[(B$95$m * N[(N[Sqrt[N[(F * N[(2.0 * t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(2.0 * F), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \left(4 \cdot A\right) \cdot C\\
t_1 := t\_0 - B\_m \cdot B\_m\\
t_2 := \left(A + C\right) + \mathsf{hypot}\left(B\_m, A - C\right)\\
\mathbf{if}\;B\_m \leq 3.9 \cdot 10^{-112}:\\
\;\;\;\;\frac{\sqrt{t\_2 \cdot \left(\left(2 \cdot F\right) \cdot \left(B\_m \cdot B\_m - t\_0\right)\right)}}{4 \cdot \left(A \cdot C\right)}\\
\mathbf{elif}\;B\_m \leq 9.6 \cdot 10^{-9}:\\
\;\;\;\;\frac{\sqrt{\left(F \cdot \left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right)\right) \cdot \left(4 \cdot A + \frac{B\_m \cdot B\_m}{A - C}\right)}}{t\_1}\\
\mathbf{elif}\;B\_m \leq 3.4 \cdot 10^{+129}:\\
\;\;\;\;B\_m \cdot \frac{\sqrt{F \cdot \left(2 \cdot t\_2\right)}}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(2 \cdot F\right)}^{0.5}}{0 - \sqrt{B\_m}}\\
\end{array}
\end{array}
if B < 3.9000000000000001e-112Initial program 19.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified24.7%
Taylor expanded in A around inf
*-lowering-*.f64N/A
*-lowering-*.f6416.6%
Simplified16.6%
if 3.9000000000000001e-112 < B < 9.5999999999999999e-9Initial program 16.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified20.3%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr24.1%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6419.0%
Simplified19.0%
Taylor expanded in F around 0
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f6430.8%
Simplified30.8%
if 9.5999999999999999e-9 < B < 3.40000000000000018e129Initial program 38.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified50.5%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr54.1%
Taylor expanded in B around inf
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6462.9%
Simplified62.9%
associate-*l*N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
Applied egg-rr59.5%
if 3.40000000000000018e129 < B Initial program 0.1%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6447.5%
Simplified47.5%
*-commutativeN/A
sqrt-divN/A
pow1/2N/A
associate-*r/N/A
pow1/2N/A
unpow-prod-downN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6463.8%
Applied egg-rr63.8%
Final simplification29.3%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (hypot B_m (- A C))) (t_1 (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= B_m 1.7e+28)
(/
(sqrt (* (+ (* B_m B_m) (* -4.0 (* A C))) (* (+ A (+ C t_0)) (* 2.0 F))))
t_1)
(if (<= B_m 5e+128)
(* B_m (/ (sqrt (* F (* 2.0 (+ (+ A C) t_0)))) t_1))
(/ (pow (* 2.0 F) 0.5) (- 0.0 (sqrt B_m)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = hypot(B_m, (A - C));
double t_1 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 1.7e+28) {
tmp = sqrt((((B_m * B_m) + (-4.0 * (A * C))) * ((A + (C + t_0)) * (2.0 * F)))) / t_1;
} else if (B_m <= 5e+128) {
tmp = B_m * (sqrt((F * (2.0 * ((A + C) + t_0)))) / t_1);
} else {
tmp = pow((2.0 * F), 0.5) / (0.0 - sqrt(B_m));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = Math.hypot(B_m, (A - C));
double t_1 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 1.7e+28) {
tmp = Math.sqrt((((B_m * B_m) + (-4.0 * (A * C))) * ((A + (C + t_0)) * (2.0 * F)))) / t_1;
} else if (B_m <= 5e+128) {
tmp = B_m * (Math.sqrt((F * (2.0 * ((A + C) + t_0)))) / t_1);
} else {
tmp = Math.pow((2.0 * F), 0.5) / (0.0 - Math.sqrt(B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = math.hypot(B_m, (A - C)) t_1 = ((4.0 * A) * C) - (B_m * B_m) tmp = 0 if B_m <= 1.7e+28: tmp = math.sqrt((((B_m * B_m) + (-4.0 * (A * C))) * ((A + (C + t_0)) * (2.0 * F)))) / t_1 elif B_m <= 5e+128: tmp = B_m * (math.sqrt((F * (2.0 * ((A + C) + t_0)))) / t_1) else: tmp = math.pow((2.0 * F), 0.5) / (0.0 - math.sqrt(B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = hypot(B_m, Float64(A - C)) t_1 = Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)) tmp = 0.0 if (B_m <= 1.7e+28) tmp = Float64(sqrt(Float64(Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C))) * Float64(Float64(A + Float64(C + t_0)) * Float64(2.0 * F)))) / t_1); elseif (B_m <= 5e+128) tmp = Float64(B_m * Float64(sqrt(Float64(F * Float64(2.0 * Float64(Float64(A + C) + t_0)))) / t_1)); else tmp = Float64((Float64(2.0 * F) ^ 0.5) / Float64(0.0 - sqrt(B_m))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = hypot(B_m, (A - C)); t_1 = ((4.0 * A) * C) - (B_m * B_m); tmp = 0.0; if (B_m <= 1.7e+28) tmp = sqrt((((B_m * B_m) + (-4.0 * (A * C))) * ((A + (C + t_0)) * (2.0 * F)))) / t_1; elseif (B_m <= 5e+128) tmp = B_m * (sqrt((F * (2.0 * ((A + C) + t_0)))) / t_1); else tmp = ((2.0 * F) ^ 0.5) / (0.0 - sqrt(B_m)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 1.7e+28], N[(N[Sqrt[N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(A + N[(C + t$95$0), $MachinePrecision]), $MachinePrecision] * N[(2.0 * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[B$95$m, 5e+128], N[(B$95$m * N[(N[Sqrt[N[(F * N[(2.0 * N[(N[(A + C), $MachinePrecision] + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(2.0 * F), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \mathsf{hypot}\left(B\_m, A - C\right)\\
t_1 := \left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m\\
\mathbf{if}\;B\_m \leq 1.7 \cdot 10^{+28}:\\
\;\;\;\;\frac{\sqrt{\left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right) \cdot \left(\left(A + \left(C + t\_0\right)\right) \cdot \left(2 \cdot F\right)\right)}}{t\_1}\\
\mathbf{elif}\;B\_m \leq 5 \cdot 10^{+128}:\\
\;\;\;\;B\_m \cdot \frac{\sqrt{F \cdot \left(2 \cdot \left(\left(A + C\right) + t\_0\right)\right)}}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(2 \cdot F\right)}^{0.5}}{0 - \sqrt{B\_m}}\\
\end{array}
\end{array}
if B < 1.7e28Initial program 19.0%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified24.7%
Applied egg-rr25.5%
if 1.7e28 < B < 5e128Initial program 38.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified48.3%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr52.4%
Taylor expanded in B around inf
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6462.2%
Simplified62.2%
associate-*l*N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
Applied egg-rr58.4%
if 5e128 < B Initial program 0.1%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6447.5%
Simplified47.5%
*-commutativeN/A
sqrt-divN/A
pow1/2N/A
associate-*r/N/A
pow1/2N/A
unpow-prod-downN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6463.8%
Applied egg-rr63.8%
Final simplification34.1%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (* (* 4.0 A) C))
(t_1 (- t_0 (* B_m B_m)))
(t_2 (+ (+ A C) (hypot B_m (- A C)))))
(if (<= B_m 1.2e+32)
(/ (sqrt (* t_2 (* (* 2.0 F) (- (* B_m B_m) t_0)))) t_1)
(if (<= B_m 7.4e+128)
(* B_m (/ (sqrt (* F (* 2.0 t_2))) t_1))
(/ (pow (* 2.0 F) 0.5) (- 0.0 (sqrt B_m)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = (4.0 * A) * C;
double t_1 = t_0 - (B_m * B_m);
double t_2 = (A + C) + hypot(B_m, (A - C));
double tmp;
if (B_m <= 1.2e+32) {
tmp = sqrt((t_2 * ((2.0 * F) * ((B_m * B_m) - t_0)))) / t_1;
} else if (B_m <= 7.4e+128) {
tmp = B_m * (sqrt((F * (2.0 * t_2))) / t_1);
} else {
tmp = pow((2.0 * F), 0.5) / (0.0 - sqrt(B_m));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = (4.0 * A) * C;
double t_1 = t_0 - (B_m * B_m);
double t_2 = (A + C) + Math.hypot(B_m, (A - C));
double tmp;
if (B_m <= 1.2e+32) {
tmp = Math.sqrt((t_2 * ((2.0 * F) * ((B_m * B_m) - t_0)))) / t_1;
} else if (B_m <= 7.4e+128) {
tmp = B_m * (Math.sqrt((F * (2.0 * t_2))) / t_1);
} else {
tmp = Math.pow((2.0 * F), 0.5) / (0.0 - Math.sqrt(B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = (4.0 * A) * C t_1 = t_0 - (B_m * B_m) t_2 = (A + C) + math.hypot(B_m, (A - C)) tmp = 0 if B_m <= 1.2e+32: tmp = math.sqrt((t_2 * ((2.0 * F) * ((B_m * B_m) - t_0)))) / t_1 elif B_m <= 7.4e+128: tmp = B_m * (math.sqrt((F * (2.0 * t_2))) / t_1) else: tmp = math.pow((2.0 * F), 0.5) / (0.0 - math.sqrt(B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(4.0 * A) * C) t_1 = Float64(t_0 - Float64(B_m * B_m)) t_2 = Float64(Float64(A + C) + hypot(B_m, Float64(A - C))) tmp = 0.0 if (B_m <= 1.2e+32) tmp = Float64(sqrt(Float64(t_2 * Float64(Float64(2.0 * F) * Float64(Float64(B_m * B_m) - t_0)))) / t_1); elseif (B_m <= 7.4e+128) tmp = Float64(B_m * Float64(sqrt(Float64(F * Float64(2.0 * t_2))) / t_1)); else tmp = Float64((Float64(2.0 * F) ^ 0.5) / Float64(0.0 - sqrt(B_m))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = (4.0 * A) * C; t_1 = t_0 - (B_m * B_m); t_2 = (A + C) + hypot(B_m, (A - C)); tmp = 0.0; if (B_m <= 1.2e+32) tmp = sqrt((t_2 * ((2.0 * F) * ((B_m * B_m) - t_0)))) / t_1; elseif (B_m <= 7.4e+128) tmp = B_m * (sqrt((F * (2.0 * t_2))) / t_1); else tmp = ((2.0 * F) ^ 0.5) / (0.0 - sqrt(B_m)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(A + C), $MachinePrecision] + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 1.2e+32], N[(N[Sqrt[N[(t$95$2 * N[(N[(2.0 * F), $MachinePrecision] * N[(N[(B$95$m * B$95$m), $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[B$95$m, 7.4e+128], N[(B$95$m * N[(N[Sqrt[N[(F * N[(2.0 * t$95$2), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(2.0 * F), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \left(4 \cdot A\right) \cdot C\\
t_1 := t\_0 - B\_m \cdot B\_m\\
t_2 := \left(A + C\right) + \mathsf{hypot}\left(B\_m, A - C\right)\\
\mathbf{if}\;B\_m \leq 1.2 \cdot 10^{+32}:\\
\;\;\;\;\frac{\sqrt{t\_2 \cdot \left(\left(2 \cdot F\right) \cdot \left(B\_m \cdot B\_m - t\_0\right)\right)}}{t\_1}\\
\mathbf{elif}\;B\_m \leq 7.4 \cdot 10^{+128}:\\
\;\;\;\;B\_m \cdot \frac{\sqrt{F \cdot \left(2 \cdot t\_2\right)}}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(2 \cdot F\right)}^{0.5}}{0 - \sqrt{B\_m}}\\
\end{array}
\end{array}
if B < 1.19999999999999996e32Initial program 20.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified25.9%
if 1.19999999999999996e32 < B < 7.4000000000000002e128Initial program 28.8%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified39.8%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr44.6%
Taylor expanded in B around inf
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6456.2%
Simplified56.2%
associate-*l*N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
Applied egg-rr51.6%
if 7.4000000000000002e128 < B Initial program 0.1%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6447.5%
Simplified47.5%
*-commutativeN/A
sqrt-divN/A
pow1/2N/A
associate-*r/N/A
pow1/2N/A
unpow-prod-downN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6463.8%
Applied egg-rr63.8%
Final simplification33.5%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 1.25e-80)
(*
(* 0.5 (* (sqrt (/ 1.0 A)) (/ 1.0 C)))
(sqrt (* F (+ (* B_m B_m) (* -4.0 (* A C))))))
(if (<= B_m 1.7e+130)
(*
B_m
(/
(sqrt (* F (* 2.0 (+ (+ A C) (hypot B_m (- A C))))))
(- (* (* 4.0 A) C) (* B_m B_m))))
(/ (pow (* 2.0 F) 0.5) (- 0.0 (sqrt B_m))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.25e-80) {
tmp = (0.5 * (sqrt((1.0 / A)) * (1.0 / C))) * sqrt((F * ((B_m * B_m) + (-4.0 * (A * C)))));
} else if (B_m <= 1.7e+130) {
tmp = B_m * (sqrt((F * (2.0 * ((A + C) + hypot(B_m, (A - C)))))) / (((4.0 * A) * C) - (B_m * B_m)));
} else {
tmp = pow((2.0 * F), 0.5) / (0.0 - sqrt(B_m));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.25e-80) {
tmp = (0.5 * (Math.sqrt((1.0 / A)) * (1.0 / C))) * Math.sqrt((F * ((B_m * B_m) + (-4.0 * (A * C)))));
} else if (B_m <= 1.7e+130) {
tmp = B_m * (Math.sqrt((F * (2.0 * ((A + C) + Math.hypot(B_m, (A - C)))))) / (((4.0 * A) * C) - (B_m * B_m)));
} else {
tmp = Math.pow((2.0 * F), 0.5) / (0.0 - Math.sqrt(B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 1.25e-80: tmp = (0.5 * (math.sqrt((1.0 / A)) * (1.0 / C))) * math.sqrt((F * ((B_m * B_m) + (-4.0 * (A * C))))) elif B_m <= 1.7e+130: tmp = B_m * (math.sqrt((F * (2.0 * ((A + C) + math.hypot(B_m, (A - C)))))) / (((4.0 * A) * C) - (B_m * B_m))) else: tmp = math.pow((2.0 * F), 0.5) / (0.0 - math.sqrt(B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 1.25e-80) tmp = Float64(Float64(0.5 * Float64(sqrt(Float64(1.0 / A)) * Float64(1.0 / C))) * sqrt(Float64(F * Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C)))))); elseif (B_m <= 1.7e+130) tmp = Float64(B_m * Float64(sqrt(Float64(F * Float64(2.0 * Float64(Float64(A + C) + hypot(B_m, Float64(A - C)))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)))); else tmp = Float64((Float64(2.0 * F) ^ 0.5) / Float64(0.0 - sqrt(B_m))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (B_m <= 1.25e-80) tmp = (0.5 * (sqrt((1.0 / A)) * (1.0 / C))) * sqrt((F * ((B_m * B_m) + (-4.0 * (A * C))))); elseif (B_m <= 1.7e+130) tmp = B_m * (sqrt((F * (2.0 * ((A + C) + hypot(B_m, (A - C)))))) / (((4.0 * A) * C) - (B_m * B_m))); else tmp = ((2.0 * F) ^ 0.5) / (0.0 - sqrt(B_m)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 1.25e-80], N[(N[(0.5 * N[(N[Sqrt[N[(1.0 / A), $MachinePrecision]], $MachinePrecision] * N[(1.0 / C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 1.7e+130], N[(B$95$m * N[(N[Sqrt[N[(F * N[(2.0 * N[(N[(A + C), $MachinePrecision] + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(2.0 * F), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 1.25 \cdot 10^{-80}:\\
\;\;\;\;\left(0.5 \cdot \left(\sqrt{\frac{1}{A}} \cdot \frac{1}{C}\right)\right) \cdot \sqrt{F \cdot \left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right)}\\
\mathbf{elif}\;B\_m \leq 1.7 \cdot 10^{+130}:\\
\;\;\;\;B\_m \cdot \frac{\sqrt{F \cdot \left(2 \cdot \left(\left(A + C\right) + \mathsf{hypot}\left(B\_m, A - C\right)\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(2 \cdot F\right)}^{0.5}}{0 - \sqrt{B\_m}}\\
\end{array}
\end{array}
if B < 1.25e-80Initial program 18.8%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified24.1%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr36.5%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6421.4%
Simplified21.4%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr21.5%
Taylor expanded in B around 0
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6416.4%
Simplified16.4%
if 1.25e-80 < B < 1.7e130Initial program 29.7%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified39.1%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr43.2%
Taylor expanded in B around inf
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6446.3%
Simplified46.3%
associate-*l*N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
Applied egg-rr42.6%
if 1.7e130 < B Initial program 0.1%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6447.5%
Simplified47.5%
*-commutativeN/A
sqrt-divN/A
pow1/2N/A
associate-*r/N/A
pow1/2N/A
unpow-prod-downN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6463.8%
Applied egg-rr63.8%
Final simplification28.0%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (+ (* B_m B_m) (* -4.0 (* A C)))))
(if (<= B_m 2e-71)
(* (* 0.5 (* (sqrt (/ 1.0 A)) (/ 1.0 C))) (sqrt (* F t_0)))
(if (<= B_m 0.00028)
(/
-1.0
(/
(- (* B_m B_m) (* (* 4.0 A) C))
(sqrt (* F (* t_0 (+ (* 4.0 A) (/ (* B_m B_m) (- A C))))))))
(if (<= B_m 8.5e+207)
(- 0.0 (/ (pow (* 2.0 (* F (+ C (hypot B_m C)))) 0.5) B_m))
(/ (pow (* 2.0 F) 0.5) (- 0.0 (sqrt B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = (B_m * B_m) + (-4.0 * (A * C));
double tmp;
if (B_m <= 2e-71) {
tmp = (0.5 * (sqrt((1.0 / A)) * (1.0 / C))) * sqrt((F * t_0));
} else if (B_m <= 0.00028) {
tmp = -1.0 / (((B_m * B_m) - ((4.0 * A) * C)) / sqrt((F * (t_0 * ((4.0 * A) + ((B_m * B_m) / (A - C)))))));
} else if (B_m <= 8.5e+207) {
tmp = 0.0 - (pow((2.0 * (F * (C + hypot(B_m, C)))), 0.5) / B_m);
} else {
tmp = pow((2.0 * F), 0.5) / (0.0 - sqrt(B_m));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = (B_m * B_m) + (-4.0 * (A * C));
double tmp;
if (B_m <= 2e-71) {
tmp = (0.5 * (Math.sqrt((1.0 / A)) * (1.0 / C))) * Math.sqrt((F * t_0));
} else if (B_m <= 0.00028) {
tmp = -1.0 / (((B_m * B_m) - ((4.0 * A) * C)) / Math.sqrt((F * (t_0 * ((4.0 * A) + ((B_m * B_m) / (A - C)))))));
} else if (B_m <= 8.5e+207) {
tmp = 0.0 - (Math.pow((2.0 * (F * (C + Math.hypot(B_m, C)))), 0.5) / B_m);
} else {
tmp = Math.pow((2.0 * F), 0.5) / (0.0 - Math.sqrt(B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = (B_m * B_m) + (-4.0 * (A * C)) tmp = 0 if B_m <= 2e-71: tmp = (0.5 * (math.sqrt((1.0 / A)) * (1.0 / C))) * math.sqrt((F * t_0)) elif B_m <= 0.00028: tmp = -1.0 / (((B_m * B_m) - ((4.0 * A) * C)) / math.sqrt((F * (t_0 * ((4.0 * A) + ((B_m * B_m) / (A - C))))))) elif B_m <= 8.5e+207: tmp = 0.0 - (math.pow((2.0 * (F * (C + math.hypot(B_m, C)))), 0.5) / B_m) else: tmp = math.pow((2.0 * F), 0.5) / (0.0 - math.sqrt(B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C))) tmp = 0.0 if (B_m <= 2e-71) tmp = Float64(Float64(0.5 * Float64(sqrt(Float64(1.0 / A)) * Float64(1.0 / C))) * sqrt(Float64(F * t_0))); elseif (B_m <= 0.00028) tmp = Float64(-1.0 / Float64(Float64(Float64(B_m * B_m) - Float64(Float64(4.0 * A) * C)) / sqrt(Float64(F * Float64(t_0 * Float64(Float64(4.0 * A) + Float64(Float64(B_m * B_m) / Float64(A - C)))))))); elseif (B_m <= 8.5e+207) tmp = Float64(0.0 - Float64((Float64(2.0 * Float64(F * Float64(C + hypot(B_m, C)))) ^ 0.5) / B_m)); else tmp = Float64((Float64(2.0 * F) ^ 0.5) / Float64(0.0 - sqrt(B_m))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = (B_m * B_m) + (-4.0 * (A * C)); tmp = 0.0; if (B_m <= 2e-71) tmp = (0.5 * (sqrt((1.0 / A)) * (1.0 / C))) * sqrt((F * t_0)); elseif (B_m <= 0.00028) tmp = -1.0 / (((B_m * B_m) - ((4.0 * A) * C)) / sqrt((F * (t_0 * ((4.0 * A) + ((B_m * B_m) / (A - C))))))); elseif (B_m <= 8.5e+207) tmp = 0.0 - (((2.0 * (F * (C + hypot(B_m, C)))) ^ 0.5) / B_m); else tmp = ((2.0 * F) ^ 0.5) / (0.0 - sqrt(B_m)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 2e-71], N[(N[(0.5 * N[(N[Sqrt[N[(1.0 / A), $MachinePrecision]], $MachinePrecision] * N[(1.0 / C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(F * t$95$0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 0.00028], N[(-1.0 / N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] - N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]), $MachinePrecision] / N[Sqrt[N[(F * N[(t$95$0 * N[(N[(4.0 * A), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 8.5e+207], N[(0.0 - N[(N[Power[N[(2.0 * N[(F * N[(C + N[Sqrt[B$95$m ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / B$95$m), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(2.0 * F), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\\
\mathbf{if}\;B\_m \leq 2 \cdot 10^{-71}:\\
\;\;\;\;\left(0.5 \cdot \left(\sqrt{\frac{1}{A}} \cdot \frac{1}{C}\right)\right) \cdot \sqrt{F \cdot t\_0}\\
\mathbf{elif}\;B\_m \leq 0.00028:\\
\;\;\;\;\frac{-1}{\frac{B\_m \cdot B\_m - \left(4 \cdot A\right) \cdot C}{\sqrt{F \cdot \left(t\_0 \cdot \left(4 \cdot A + \frac{B\_m \cdot B\_m}{A - C}\right)\right)}}}\\
\mathbf{elif}\;B\_m \leq 8.5 \cdot 10^{+207}:\\
\;\;\;\;0 - \frac{{\left(2 \cdot \left(F \cdot \left(C + \mathsf{hypot}\left(B\_m, C\right)\right)\right)\right)}^{0.5}}{B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(2 \cdot F\right)}^{0.5}}{0 - \sqrt{B\_m}}\\
\end{array}
\end{array}
if B < 1.9999999999999998e-71Initial program 18.6%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified23.8%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr36.1%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6421.2%
Simplified21.2%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr21.2%
Taylor expanded in B around 0
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6416.3%
Simplified16.3%
if 1.9999999999999998e-71 < B < 2.7999999999999998e-4Initial program 18.4%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified29.5%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr34.0%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6417.1%
Simplified17.1%
clear-numN/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
sqrt-unprodN/A
sqrt-lowering-sqrt.f64N/A
Applied egg-rr34.6%
if 2.7999999999999998e-4 < B < 8.4999999999999996e207Initial program 25.5%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6446.5%
Simplified46.5%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr46.7%
if 8.4999999999999996e207 < B Initial program 0.0%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6460.2%
Simplified60.2%
*-commutativeN/A
sqrt-divN/A
pow1/2N/A
associate-*r/N/A
pow1/2N/A
unpow-prod-downN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6485.3%
Applied egg-rr85.3%
Final simplification28.6%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= B_m 3.1e-115)
(/ (sqrt (* C (+ (* -16.0 (* A (* C F))) (* 4.0 (* F (* B_m B_m)))))) t_0)
(if (<= B_m 0.000235)
(/
(sqrt
(*
(* F (+ (* B_m B_m) (* -4.0 (* A C))))
(+ (* 4.0 A) (/ (* B_m B_m) (- A C)))))
t_0)
(if (<= B_m 8.5e+207)
(- 0.0 (/ (pow (* 2.0 (* F (+ C (hypot B_m C)))) 0.5) B_m))
(/ (pow (* 2.0 F) 0.5) (- 0.0 (sqrt B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 3.1e-115) {
tmp = sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0;
} else if (B_m <= 0.000235) {
tmp = sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0;
} else if (B_m <= 8.5e+207) {
tmp = 0.0 - (pow((2.0 * (F * (C + hypot(B_m, C)))), 0.5) / B_m);
} else {
tmp = pow((2.0 * F), 0.5) / (0.0 - sqrt(B_m));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 3.1e-115) {
tmp = Math.sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0;
} else if (B_m <= 0.000235) {
tmp = Math.sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0;
} else if (B_m <= 8.5e+207) {
tmp = 0.0 - (Math.pow((2.0 * (F * (C + Math.hypot(B_m, C)))), 0.5) / B_m);
} else {
tmp = Math.pow((2.0 * F), 0.5) / (0.0 - Math.sqrt(B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = ((4.0 * A) * C) - (B_m * B_m) tmp = 0 if B_m <= 3.1e-115: tmp = math.sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0 elif B_m <= 0.000235: tmp = math.sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0 elif B_m <= 8.5e+207: tmp = 0.0 - (math.pow((2.0 * (F * (C + math.hypot(B_m, C)))), 0.5) / B_m) else: tmp = math.pow((2.0 * F), 0.5) / (0.0 - math.sqrt(B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)) tmp = 0.0 if (B_m <= 3.1e-115) tmp = Float64(sqrt(Float64(C * Float64(Float64(-16.0 * Float64(A * Float64(C * F))) + Float64(4.0 * Float64(F * Float64(B_m * B_m)))))) / t_0); elseif (B_m <= 0.000235) tmp = Float64(sqrt(Float64(Float64(F * Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C)))) * Float64(Float64(4.0 * A) + Float64(Float64(B_m * B_m) / Float64(A - C))))) / t_0); elseif (B_m <= 8.5e+207) tmp = Float64(0.0 - Float64((Float64(2.0 * Float64(F * Float64(C + hypot(B_m, C)))) ^ 0.5) / B_m)); else tmp = Float64((Float64(2.0 * F) ^ 0.5) / Float64(0.0 - sqrt(B_m))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = ((4.0 * A) * C) - (B_m * B_m); tmp = 0.0; if (B_m <= 3.1e-115) tmp = sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0; elseif (B_m <= 0.000235) tmp = sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0; elseif (B_m <= 8.5e+207) tmp = 0.0 - (((2.0 * (F * (C + hypot(B_m, C)))) ^ 0.5) / B_m); else tmp = ((2.0 * F) ^ 0.5) / (0.0 - sqrt(B_m)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 3.1e-115], N[(N[Sqrt[N[(C * N[(N[(-16.0 * N[(A * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(4.0 * N[(F * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[B$95$m, 0.000235], N[(N[Sqrt[N[(N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(4.0 * A), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[B$95$m, 8.5e+207], N[(0.0 - N[(N[Power[N[(2.0 * N[(F * N[(C + N[Sqrt[B$95$m ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / B$95$m), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(2.0 * F), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m\\
\mathbf{if}\;B\_m \leq 3.1 \cdot 10^{-115}:\\
\;\;\;\;\frac{\sqrt{C \cdot \left(-16 \cdot \left(A \cdot \left(C \cdot F\right)\right) + 4 \cdot \left(F \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{t\_0}\\
\mathbf{elif}\;B\_m \leq 0.000235:\\
\;\;\;\;\frac{\sqrt{\left(F \cdot \left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right)\right) \cdot \left(4 \cdot A + \frac{B\_m \cdot B\_m}{A - C}\right)}}{t\_0}\\
\mathbf{elif}\;B\_m \leq 8.5 \cdot 10^{+207}:\\
\;\;\;\;0 - \frac{{\left(2 \cdot \left(F \cdot \left(C + \mathsf{hypot}\left(B\_m, C\right)\right)\right)\right)}^{0.5}}{B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(2 \cdot F\right)}^{0.5}}{0 - \sqrt{B\_m}}\\
\end{array}
\end{array}
if B < 3.10000000000000007e-115Initial program 19.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified24.8%
Taylor expanded in C around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
Simplified10.3%
Taylor expanded in C around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.0%
Simplified18.0%
if 3.10000000000000007e-115 < B < 2.34999999999999993e-4Initial program 14.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified21.7%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr25.0%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6420.4%
Simplified20.4%
Taylor expanded in F around 0
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f6431.1%
Simplified31.1%
if 2.34999999999999993e-4 < B < 8.4999999999999996e207Initial program 25.5%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6446.5%
Simplified46.5%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr46.7%
if 8.4999999999999996e207 < B Initial program 0.0%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6460.2%
Simplified60.2%
*-commutativeN/A
sqrt-divN/A
pow1/2N/A
associate-*r/N/A
pow1/2N/A
unpow-prod-downN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6485.3%
Applied egg-rr85.3%
Final simplification30.1%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= B_m 6e-116)
(/ (sqrt (* C (+ (* -16.0 (* A (* C F))) (* 4.0 (* F (* B_m B_m)))))) t_0)
(if (<= B_m 0.00018)
(/
(sqrt
(*
(* F (+ (* B_m B_m) (* -4.0 (* A C))))
(+ (* 4.0 A) (/ (* B_m B_m) (- A C)))))
t_0)
(/ (pow (* 2.0 F) 0.5) (- 0.0 (sqrt B_m)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 6e-116) {
tmp = sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0;
} else if (B_m <= 0.00018) {
tmp = sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0;
} else {
tmp = pow((2.0 * F), 0.5) / (0.0 - sqrt(B_m));
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: t_0
real(8) :: tmp
t_0 = ((4.0d0 * a) * c) - (b_m * b_m)
if (b_m <= 6d-116) then
tmp = sqrt((c * (((-16.0d0) * (a * (c * f))) + (4.0d0 * (f * (b_m * b_m)))))) / t_0
else if (b_m <= 0.00018d0) then
tmp = sqrt(((f * ((b_m * b_m) + ((-4.0d0) * (a * c)))) * ((4.0d0 * a) + ((b_m * b_m) / (a - c))))) / t_0
else
tmp = ((2.0d0 * f) ** 0.5d0) / (0.0d0 - sqrt(b_m))
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 6e-116) {
tmp = Math.sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0;
} else if (B_m <= 0.00018) {
tmp = Math.sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0;
} else {
tmp = Math.pow((2.0 * F), 0.5) / (0.0 - Math.sqrt(B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = ((4.0 * A) * C) - (B_m * B_m) tmp = 0 if B_m <= 6e-116: tmp = math.sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0 elif B_m <= 0.00018: tmp = math.sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0 else: tmp = math.pow((2.0 * F), 0.5) / (0.0 - math.sqrt(B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)) tmp = 0.0 if (B_m <= 6e-116) tmp = Float64(sqrt(Float64(C * Float64(Float64(-16.0 * Float64(A * Float64(C * F))) + Float64(4.0 * Float64(F * Float64(B_m * B_m)))))) / t_0); elseif (B_m <= 0.00018) tmp = Float64(sqrt(Float64(Float64(F * Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C)))) * Float64(Float64(4.0 * A) + Float64(Float64(B_m * B_m) / Float64(A - C))))) / t_0); else tmp = Float64((Float64(2.0 * F) ^ 0.5) / Float64(0.0 - sqrt(B_m))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = ((4.0 * A) * C) - (B_m * B_m); tmp = 0.0; if (B_m <= 6e-116) tmp = sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0; elseif (B_m <= 0.00018) tmp = sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0; else tmp = ((2.0 * F) ^ 0.5) / (0.0 - sqrt(B_m)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 6e-116], N[(N[Sqrt[N[(C * N[(N[(-16.0 * N[(A * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(4.0 * N[(F * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[B$95$m, 0.00018], N[(N[Sqrt[N[(N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(4.0 * A), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[Power[N[(2.0 * F), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m\\
\mathbf{if}\;B\_m \leq 6 \cdot 10^{-116}:\\
\;\;\;\;\frac{\sqrt{C \cdot \left(-16 \cdot \left(A \cdot \left(C \cdot F\right)\right) + 4 \cdot \left(F \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{t\_0}\\
\mathbf{elif}\;B\_m \leq 0.00018:\\
\;\;\;\;\frac{\sqrt{\left(F \cdot \left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right)\right) \cdot \left(4 \cdot A + \frac{B\_m \cdot B\_m}{A - C}\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(2 \cdot F\right)}^{0.5}}{0 - \sqrt{B\_m}}\\
\end{array}
\end{array}
if B < 6.00000000000000053e-116Initial program 19.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified24.8%
Taylor expanded in C around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
Simplified10.3%
Taylor expanded in C around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.0%
Simplified18.0%
if 6.00000000000000053e-116 < B < 1.80000000000000011e-4Initial program 14.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified21.7%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr25.0%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6420.4%
Simplified20.4%
Taylor expanded in F around 0
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f6431.1%
Simplified31.1%
if 1.80000000000000011e-4 < B Initial program 15.1%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6443.6%
Simplified43.6%
*-commutativeN/A
sqrt-divN/A
pow1/2N/A
associate-*r/N/A
pow1/2N/A
unpow-prod-downN/A
/-lowering-/.f64N/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6454.0%
Applied egg-rr54.0%
Final simplification28.1%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= B_m 2.45e-115)
(/ (sqrt (* C (+ (* -16.0 (* A (* C F))) (* 4.0 (* F (* B_m B_m)))))) t_0)
(if (<= B_m 0.000165)
(/
(sqrt
(*
(* F (+ (* B_m B_m) (* -4.0 (* A C))))
(+ (* 4.0 A) (/ (* B_m B_m) (- A C)))))
t_0)
(- 0.0 (* (sqrt F) (sqrt (/ 2.0 B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 2.45e-115) {
tmp = sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0;
} else if (B_m <= 0.000165) {
tmp = sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0;
} else {
tmp = 0.0 - (sqrt(F) * sqrt((2.0 / B_m)));
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: t_0
real(8) :: tmp
t_0 = ((4.0d0 * a) * c) - (b_m * b_m)
if (b_m <= 2.45d-115) then
tmp = sqrt((c * (((-16.0d0) * (a * (c * f))) + (4.0d0 * (f * (b_m * b_m)))))) / t_0
else if (b_m <= 0.000165d0) then
tmp = sqrt(((f * ((b_m * b_m) + ((-4.0d0) * (a * c)))) * ((4.0d0 * a) + ((b_m * b_m) / (a - c))))) / t_0
else
tmp = 0.0d0 - (sqrt(f) * sqrt((2.0d0 / b_m)))
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 2.45e-115) {
tmp = Math.sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0;
} else if (B_m <= 0.000165) {
tmp = Math.sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0;
} else {
tmp = 0.0 - (Math.sqrt(F) * Math.sqrt((2.0 / B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = ((4.0 * A) * C) - (B_m * B_m) tmp = 0 if B_m <= 2.45e-115: tmp = math.sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0 elif B_m <= 0.000165: tmp = math.sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0 else: tmp = 0.0 - (math.sqrt(F) * math.sqrt((2.0 / B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)) tmp = 0.0 if (B_m <= 2.45e-115) tmp = Float64(sqrt(Float64(C * Float64(Float64(-16.0 * Float64(A * Float64(C * F))) + Float64(4.0 * Float64(F * Float64(B_m * B_m)))))) / t_0); elseif (B_m <= 0.000165) tmp = Float64(sqrt(Float64(Float64(F * Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C)))) * Float64(Float64(4.0 * A) + Float64(Float64(B_m * B_m) / Float64(A - C))))) / t_0); else tmp = Float64(0.0 - Float64(sqrt(F) * sqrt(Float64(2.0 / B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = ((4.0 * A) * C) - (B_m * B_m); tmp = 0.0; if (B_m <= 2.45e-115) tmp = sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0; elseif (B_m <= 0.000165) tmp = sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0; else tmp = 0.0 - (sqrt(F) * sqrt((2.0 / B_m))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 2.45e-115], N[(N[Sqrt[N[(C * N[(N[(-16.0 * N[(A * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(4.0 * N[(F * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[B$95$m, 0.000165], N[(N[Sqrt[N[(N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(4.0 * A), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(0.0 - N[(N[Sqrt[F], $MachinePrecision] * N[Sqrt[N[(2.0 / B$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m\\
\mathbf{if}\;B\_m \leq 2.45 \cdot 10^{-115}:\\
\;\;\;\;\frac{\sqrt{C \cdot \left(-16 \cdot \left(A \cdot \left(C \cdot F\right)\right) + 4 \cdot \left(F \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{t\_0}\\
\mathbf{elif}\;B\_m \leq 0.000165:\\
\;\;\;\;\frac{\sqrt{\left(F \cdot \left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right)\right) \cdot \left(4 \cdot A + \frac{B\_m \cdot B\_m}{A - C}\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;0 - \sqrt{F} \cdot \sqrt{\frac{2}{B\_m}}\\
\end{array}
\end{array}
if B < 2.44999999999999994e-115Initial program 19.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified24.8%
Taylor expanded in C around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
Simplified10.3%
Taylor expanded in C around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.0%
Simplified18.0%
if 2.44999999999999994e-115 < B < 1.65e-4Initial program 14.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified21.7%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr25.0%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6420.4%
Simplified20.4%
Taylor expanded in F around 0
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f6431.1%
Simplified31.1%
if 1.65e-4 < B Initial program 15.1%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6443.6%
Simplified43.6%
sqrt-unprodN/A
sqrt-lowering-sqrt.f64N/A
clear-numN/A
associate-*l/N/A
metadata-evalN/A
/-lowering-/.f64N/A
/-lowering-/.f6443.7%
Applied egg-rr43.7%
associate-/r/N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6453.8%
Applied egg-rr53.8%
Final simplification28.1%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= B_m 1.78e-115)
(/ (sqrt (* C (+ (* -16.0 (* A (* C F))) (* 4.0 (* F (* B_m B_m)))))) t_0)
(if (<= B_m 0.000135)
(/
(sqrt
(*
(* F (+ (* B_m B_m) (* -4.0 (* A C))))
(+ (* 4.0 A) (/ (* B_m B_m) (- A C)))))
t_0)
(- 0.0 (sqrt (* 2.0 (/ F B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 1.78e-115) {
tmp = sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0;
} else if (B_m <= 0.000135) {
tmp = sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0;
} else {
tmp = 0.0 - sqrt((2.0 * (F / B_m)));
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: t_0
real(8) :: tmp
t_0 = ((4.0d0 * a) * c) - (b_m * b_m)
if (b_m <= 1.78d-115) then
tmp = sqrt((c * (((-16.0d0) * (a * (c * f))) + (4.0d0 * (f * (b_m * b_m)))))) / t_0
else if (b_m <= 0.000135d0) then
tmp = sqrt(((f * ((b_m * b_m) + ((-4.0d0) * (a * c)))) * ((4.0d0 * a) + ((b_m * b_m) / (a - c))))) / t_0
else
tmp = 0.0d0 - sqrt((2.0d0 * (f / b_m)))
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 1.78e-115) {
tmp = Math.sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0;
} else if (B_m <= 0.000135) {
tmp = Math.sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0;
} else {
tmp = 0.0 - Math.sqrt((2.0 * (F / B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = ((4.0 * A) * C) - (B_m * B_m) tmp = 0 if B_m <= 1.78e-115: tmp = math.sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0 elif B_m <= 0.000135: tmp = math.sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0 else: tmp = 0.0 - math.sqrt((2.0 * (F / B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)) tmp = 0.0 if (B_m <= 1.78e-115) tmp = Float64(sqrt(Float64(C * Float64(Float64(-16.0 * Float64(A * Float64(C * F))) + Float64(4.0 * Float64(F * Float64(B_m * B_m)))))) / t_0); elseif (B_m <= 0.000135) tmp = Float64(sqrt(Float64(Float64(F * Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C)))) * Float64(Float64(4.0 * A) + Float64(Float64(B_m * B_m) / Float64(A - C))))) / t_0); else tmp = Float64(0.0 - sqrt(Float64(2.0 * Float64(F / B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = ((4.0 * A) * C) - (B_m * B_m); tmp = 0.0; if (B_m <= 1.78e-115) tmp = sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / t_0; elseif (B_m <= 0.000135) tmp = sqrt(((F * ((B_m * B_m) + (-4.0 * (A * C)))) * ((4.0 * A) + ((B_m * B_m) / (A - C))))) / t_0; else tmp = 0.0 - sqrt((2.0 * (F / B_m))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 1.78e-115], N[(N[Sqrt[N[(C * N[(N[(-16.0 * N[(A * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(4.0 * N[(F * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[B$95$m, 0.000135], N[(N[Sqrt[N[(N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(4.0 * A), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(0.0 - N[Sqrt[N[(2.0 * N[(F / B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m\\
\mathbf{if}\;B\_m \leq 1.78 \cdot 10^{-115}:\\
\;\;\;\;\frac{\sqrt{C \cdot \left(-16 \cdot \left(A \cdot \left(C \cdot F\right)\right) + 4 \cdot \left(F \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{t\_0}\\
\mathbf{elif}\;B\_m \leq 0.000135:\\
\;\;\;\;\frac{\sqrt{\left(F \cdot \left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right)\right) \cdot \left(4 \cdot A + \frac{B\_m \cdot B\_m}{A - C}\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;0 - \sqrt{2 \cdot \frac{F}{B\_m}}\\
\end{array}
\end{array}
if B < 1.78000000000000006e-115Initial program 19.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified24.8%
Taylor expanded in C around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
Simplified10.3%
Taylor expanded in C around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.0%
Simplified18.0%
if 1.78000000000000006e-115 < B < 1.35000000000000002e-4Initial program 14.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified21.7%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr25.0%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6420.4%
Simplified20.4%
Taylor expanded in F around 0
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f6431.1%
Simplified31.1%
if 1.35000000000000002e-4 < B Initial program 15.1%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6443.6%
Simplified43.6%
sqrt-unprodN/A
sqrt-lowering-sqrt.f64N/A
clear-numN/A
associate-*l/N/A
metadata-evalN/A
/-lowering-/.f64N/A
/-lowering-/.f6443.7%
Applied egg-rr43.7%
clear-numN/A
associate-/r/N/A
clear-numN/A
*-lowering-*.f64N/A
/-lowering-/.f6443.8%
Applied egg-rr43.8%
Final simplification25.7%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= C -1.05e+211)
(- 0.0 (sqrt (/ F (- A C))))
(if (<= C 6.5e-35)
(- 0.0 (sqrt (* 2.0 (/ F B_m))))
(*
(/ C (- (* 4.0 (* A C)) (* B_m B_m)))
(sqrt (* F (+ (* A -16.0) (* 4.0 (/ (* B_m B_m) C)))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= -1.05e+211) {
tmp = 0.0 - sqrt((F / (A - C)));
} else if (C <= 6.5e-35) {
tmp = 0.0 - sqrt((2.0 * (F / B_m)));
} else {
tmp = (C / ((4.0 * (A * C)) - (B_m * B_m))) * sqrt((F * ((A * -16.0) + (4.0 * ((B_m * B_m) / C)))));
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (c <= (-1.05d+211)) then
tmp = 0.0d0 - sqrt((f / (a - c)))
else if (c <= 6.5d-35) then
tmp = 0.0d0 - sqrt((2.0d0 * (f / b_m)))
else
tmp = (c / ((4.0d0 * (a * c)) - (b_m * b_m))) * sqrt((f * ((a * (-16.0d0)) + (4.0d0 * ((b_m * b_m) / c)))))
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= -1.05e+211) {
tmp = 0.0 - Math.sqrt((F / (A - C)));
} else if (C <= 6.5e-35) {
tmp = 0.0 - Math.sqrt((2.0 * (F / B_m)));
} else {
tmp = (C / ((4.0 * (A * C)) - (B_m * B_m))) * Math.sqrt((F * ((A * -16.0) + (4.0 * ((B_m * B_m) / C)))));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if C <= -1.05e+211: tmp = 0.0 - math.sqrt((F / (A - C))) elif C <= 6.5e-35: tmp = 0.0 - math.sqrt((2.0 * (F / B_m))) else: tmp = (C / ((4.0 * (A * C)) - (B_m * B_m))) * math.sqrt((F * ((A * -16.0) + (4.0 * ((B_m * B_m) / C))))) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (C <= -1.05e+211) tmp = Float64(0.0 - sqrt(Float64(F / Float64(A - C)))); elseif (C <= 6.5e-35) tmp = Float64(0.0 - sqrt(Float64(2.0 * Float64(F / B_m)))); else tmp = Float64(Float64(C / Float64(Float64(4.0 * Float64(A * C)) - Float64(B_m * B_m))) * sqrt(Float64(F * Float64(Float64(A * -16.0) + Float64(4.0 * Float64(Float64(B_m * B_m) / C)))))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (C <= -1.05e+211) tmp = 0.0 - sqrt((F / (A - C))); elseif (C <= 6.5e-35) tmp = 0.0 - sqrt((2.0 * (F / B_m))); else tmp = (C / ((4.0 * (A * C)) - (B_m * B_m))) * sqrt((F * ((A * -16.0) + (4.0 * ((B_m * B_m) / C))))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[C, -1.05e+211], N[(0.0 - N[Sqrt[N[(F / N[(A - C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 6.5e-35], N[(0.0 - N[Sqrt[N[(2.0 * N[(F / B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(C / N[(N[(4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(F * N[(N[(A * -16.0), $MachinePrecision] + N[(4.0 * N[(N[(B$95$m * B$95$m), $MachinePrecision] / C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;C \leq -1.05 \cdot 10^{+211}:\\
\;\;\;\;0 - \sqrt{\frac{F}{A - C}}\\
\mathbf{elif}\;C \leq 6.5 \cdot 10^{-35}:\\
\;\;\;\;0 - \sqrt{2 \cdot \frac{F}{B\_m}}\\
\mathbf{else}:\\
\;\;\;\;\frac{C}{4 \cdot \left(A \cdot C\right) - B\_m \cdot B\_m} \cdot \sqrt{F \cdot \left(A \cdot -16 + 4 \cdot \frac{B\_m \cdot B\_m}{C}\right)}\\
\end{array}
\end{array}
if C < -1.05e211Initial program 0.8%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified2.4%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr3.6%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6431.9%
Simplified31.9%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
--lowering--.f6427.6%
Simplified27.6%
if -1.05e211 < C < 6.4999999999999999e-35Initial program 19.8%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6415.1%
Simplified15.1%
sqrt-unprodN/A
sqrt-lowering-sqrt.f64N/A
clear-numN/A
associate-*l/N/A
metadata-evalN/A
/-lowering-/.f64N/A
/-lowering-/.f6415.2%
Applied egg-rr15.2%
clear-numN/A
associate-/r/N/A
clear-numN/A
*-lowering-*.f64N/A
/-lowering-/.f6415.2%
Applied egg-rr15.2%
if 6.4999999999999999e-35 < C Initial program 19.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified30.4%
Taylor expanded in C around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
Simplified17.2%
Taylor expanded in F around 0
*-lowering-*.f64N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f6435.5%
Simplified35.5%
Final simplification22.5%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 3.3e-40)
(/
(sqrt (* C (+ (* -16.0 (* A (* C F))) (* 4.0 (* F (* B_m B_m))))))
(- (* (* 4.0 A) C) (* B_m B_m)))
(- 0.0 (sqrt (* 2.0 (/ F B_m))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 3.3e-40) {
tmp = sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = 0.0 - sqrt((2.0 * (F / B_m)));
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (b_m <= 3.3d-40) then
tmp = sqrt((c * (((-16.0d0) * (a * (c * f))) + (4.0d0 * (f * (b_m * b_m)))))) / (((4.0d0 * a) * c) - (b_m * b_m))
else
tmp = 0.0d0 - sqrt((2.0d0 * (f / b_m)))
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 3.3e-40) {
tmp = Math.sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = 0.0 - Math.sqrt((2.0 * (F / B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 3.3e-40: tmp = math.sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / (((4.0 * A) * C) - (B_m * B_m)) else: tmp = 0.0 - math.sqrt((2.0 * (F / B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 3.3e-40) tmp = Float64(sqrt(Float64(C * Float64(Float64(-16.0 * Float64(A * Float64(C * F))) + Float64(4.0 * Float64(F * Float64(B_m * B_m)))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); else tmp = Float64(0.0 - sqrt(Float64(2.0 * Float64(F / B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (B_m <= 3.3e-40) tmp = sqrt((C * ((-16.0 * (A * (C * F))) + (4.0 * (F * (B_m * B_m)))))) / (((4.0 * A) * C) - (B_m * B_m)); else tmp = 0.0 - sqrt((2.0 * (F / B_m))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 3.3e-40], N[(N[Sqrt[N[(C * N[(N[(-16.0 * N[(A * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(4.0 * N[(F * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.0 - N[Sqrt[N[(2.0 * N[(F / B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 3.3 \cdot 10^{-40}:\\
\;\;\;\;\frac{\sqrt{C \cdot \left(-16 \cdot \left(A \cdot \left(C \cdot F\right)\right) + 4 \cdot \left(F \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;0 - \sqrt{2 \cdot \frac{F}{B\_m}}\\
\end{array}
\end{array}
if B < 3.29999999999999993e-40Initial program 18.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified23.6%
Taylor expanded in C around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
Simplified10.5%
Taylor expanded in C around 0
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6417.5%
Simplified17.5%
if 3.29999999999999993e-40 < B Initial program 15.8%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6439.1%
Simplified39.1%
sqrt-unprodN/A
sqrt-lowering-sqrt.f64N/A
clear-numN/A
associate-*l/N/A
metadata-evalN/A
/-lowering-/.f64N/A
/-lowering-/.f6439.2%
Applied egg-rr39.2%
clear-numN/A
associate-/r/N/A
clear-numN/A
*-lowering-*.f64N/A
/-lowering-/.f6439.2%
Applied egg-rr39.2%
Final simplification23.6%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= B_m 3.4e-8) (/ (sqrt (* (* C F) (* (* A A) -16.0))) (- (* (* 4.0 A) C) (* B_m B_m))) (- 0.0 (sqrt (* 2.0 (/ F B_m))))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 3.4e-8) {
tmp = sqrt(((C * F) * ((A * A) * -16.0))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = 0.0 - sqrt((2.0 * (F / B_m)));
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (b_m <= 3.4d-8) then
tmp = sqrt(((c * f) * ((a * a) * (-16.0d0)))) / (((4.0d0 * a) * c) - (b_m * b_m))
else
tmp = 0.0d0 - sqrt((2.0d0 * (f / b_m)))
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 3.4e-8) {
tmp = Math.sqrt(((C * F) * ((A * A) * -16.0))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = 0.0 - Math.sqrt((2.0 * (F / B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 3.4e-8: tmp = math.sqrt(((C * F) * ((A * A) * -16.0))) / (((4.0 * A) * C) - (B_m * B_m)) else: tmp = 0.0 - math.sqrt((2.0 * (F / B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 3.4e-8) tmp = Float64(sqrt(Float64(Float64(C * F) * Float64(Float64(A * A) * -16.0))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); else tmp = Float64(0.0 - sqrt(Float64(2.0 * Float64(F / B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (B_m <= 3.4e-8) tmp = sqrt(((C * F) * ((A * A) * -16.0))) / (((4.0 * A) * C) - (B_m * B_m)); else tmp = 0.0 - sqrt((2.0 * (F / B_m))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 3.4e-8], N[(N[Sqrt[N[(N[(C * F), $MachinePrecision] * N[(N[(A * A), $MachinePrecision] * -16.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.0 - N[Sqrt[N[(2.0 * N[(F / B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 3.4 \cdot 10^{-8}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot F\right) \cdot \left(\left(A \cdot A\right) \cdot -16\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;0 - \sqrt{2 \cdot \frac{F}{B\_m}}\\
\end{array}
\end{array}
if B < 3.4e-8Initial program 18.8%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified24.1%
Taylor expanded in B around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6411.1%
Simplified11.1%
if 3.4e-8 < B Initial program 14.6%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6442.4%
Simplified42.4%
sqrt-unprodN/A
sqrt-lowering-sqrt.f64N/A
clear-numN/A
associate-*l/N/A
metadata-evalN/A
/-lowering-/.f64N/A
/-lowering-/.f6442.5%
Applied egg-rr42.5%
clear-numN/A
associate-/r/N/A
clear-numN/A
*-lowering-*.f64N/A
/-lowering-/.f6442.5%
Applied egg-rr42.5%
Final simplification18.8%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= C -1e+211)
(- 0.0 (sqrt (/ F (- A C))))
(if (<= C 5.8e+119)
(- 0.0 (sqrt (* 2.0 (/ F B_m))))
(* (* -2.0 (/ 1.0 B_m)) (sqrt (* C F))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= -1e+211) {
tmp = 0.0 - sqrt((F / (A - C)));
} else if (C <= 5.8e+119) {
tmp = 0.0 - sqrt((2.0 * (F / B_m)));
} else {
tmp = (-2.0 * (1.0 / B_m)) * sqrt((C * F));
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (c <= (-1d+211)) then
tmp = 0.0d0 - sqrt((f / (a - c)))
else if (c <= 5.8d+119) then
tmp = 0.0d0 - sqrt((2.0d0 * (f / b_m)))
else
tmp = ((-2.0d0) * (1.0d0 / b_m)) * sqrt((c * f))
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= -1e+211) {
tmp = 0.0 - Math.sqrt((F / (A - C)));
} else if (C <= 5.8e+119) {
tmp = 0.0 - Math.sqrt((2.0 * (F / B_m)));
} else {
tmp = (-2.0 * (1.0 / B_m)) * Math.sqrt((C * F));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if C <= -1e+211: tmp = 0.0 - math.sqrt((F / (A - C))) elif C <= 5.8e+119: tmp = 0.0 - math.sqrt((2.0 * (F / B_m))) else: tmp = (-2.0 * (1.0 / B_m)) * math.sqrt((C * F)) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (C <= -1e+211) tmp = Float64(0.0 - sqrt(Float64(F / Float64(A - C)))); elseif (C <= 5.8e+119) tmp = Float64(0.0 - sqrt(Float64(2.0 * Float64(F / B_m)))); else tmp = Float64(Float64(-2.0 * Float64(1.0 / B_m)) * sqrt(Float64(C * F))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (C <= -1e+211) tmp = 0.0 - sqrt((F / (A - C))); elseif (C <= 5.8e+119) tmp = 0.0 - sqrt((2.0 * (F / B_m))); else tmp = (-2.0 * (1.0 / B_m)) * sqrt((C * F)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[C, -1e+211], N[(0.0 - N[Sqrt[N[(F / N[(A - C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[C, 5.8e+119], N[(0.0 - N[Sqrt[N[(2.0 * N[(F / B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[(-2.0 * N[(1.0 / B$95$m), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(C * F), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;C \leq -1 \cdot 10^{+211}:\\
\;\;\;\;0 - \sqrt{\frac{F}{A - C}}\\
\mathbf{elif}\;C \leq 5.8 \cdot 10^{+119}:\\
\;\;\;\;0 - \sqrt{2 \cdot \frac{F}{B\_m}}\\
\mathbf{else}:\\
\;\;\;\;\left(-2 \cdot \frac{1}{B\_m}\right) \cdot \sqrt{C \cdot F}\\
\end{array}
\end{array}
if C < -9.9999999999999996e210Initial program 0.8%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified2.4%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr3.6%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6431.9%
Simplified31.9%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
--lowering--.f6427.6%
Simplified27.6%
if -9.9999999999999996e210 < C < 5.80000000000000014e119Initial program 22.7%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6415.7%
Simplified15.7%
sqrt-unprodN/A
sqrt-lowering-sqrt.f64N/A
clear-numN/A
associate-*l/N/A
metadata-evalN/A
/-lowering-/.f64N/A
/-lowering-/.f6415.8%
Applied egg-rr15.8%
clear-numN/A
associate-/r/N/A
clear-numN/A
*-lowering-*.f64N/A
/-lowering-/.f6415.8%
Applied egg-rr15.8%
if 5.80000000000000014e119 < C Initial program 7.6%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified23.6%
Taylor expanded in C around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
Simplified7.4%
Taylor expanded in C around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f6414.0%
Simplified14.0%
Final simplification16.6%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= B_m 1.45e-67) (- 0.0 (sqrt (/ F (- A C)))) (- 0.0 (sqrt (* 2.0 (/ F B_m))))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.45e-67) {
tmp = 0.0 - sqrt((F / (A - C)));
} else {
tmp = 0.0 - sqrt((2.0 * (F / B_m)));
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (b_m <= 1.45d-67) then
tmp = 0.0d0 - sqrt((f / (a - c)))
else
tmp = 0.0d0 - sqrt((2.0d0 * (f / b_m)))
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.45e-67) {
tmp = 0.0 - Math.sqrt((F / (A - C)));
} else {
tmp = 0.0 - Math.sqrt((2.0 * (F / B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 1.45e-67: tmp = 0.0 - math.sqrt((F / (A - C))) else: tmp = 0.0 - math.sqrt((2.0 * (F / B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 1.45e-67) tmp = Float64(0.0 - sqrt(Float64(F / Float64(A - C)))); else tmp = Float64(0.0 - sqrt(Float64(2.0 * Float64(F / B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (B_m <= 1.45e-67) tmp = 0.0 - sqrt((F / (A - C))); else tmp = 0.0 - sqrt((2.0 * (F / B_m))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 1.45e-67], N[(0.0 - N[Sqrt[N[(F / N[(A - C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(0.0 - N[Sqrt[N[(2.0 * N[(F / B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 1.45 \cdot 10^{-67}:\\
\;\;\;\;0 - \sqrt{\frac{F}{A - C}}\\
\mathbf{else}:\\
\;\;\;\;0 - \sqrt{2 \cdot \frac{F}{B\_m}}\\
\end{array}
\end{array}
if B < 1.45000000000000002e-67Initial program 18.4%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified23.6%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr35.7%
Taylor expanded in B around 0
+-commutativeN/A
+-lowering-+.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f6421.0%
Simplified21.0%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
--lowering--.f6410.4%
Simplified10.4%
if 1.45000000000000002e-67 < B Initial program 16.2%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6437.1%
Simplified37.1%
sqrt-unprodN/A
sqrt-lowering-sqrt.f64N/A
clear-numN/A
associate-*l/N/A
metadata-evalN/A
/-lowering-/.f64N/A
/-lowering-/.f6437.2%
Applied egg-rr37.2%
clear-numN/A
associate-/r/N/A
clear-numN/A
*-lowering-*.f64N/A
/-lowering-/.f6437.2%
Applied egg-rr37.2%
Final simplification18.5%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (- 0.0 (sqrt (* 2.0 (/ F B_m)))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
return 0.0 - sqrt((2.0 * (F / B_m)));
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
code = 0.0d0 - sqrt((2.0d0 * (f / b_m)))
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
return 0.0 - Math.sqrt((2.0 * (F / B_m)));
}
B_m = math.fabs(B) def code(A, B_m, C, F): return 0.0 - math.sqrt((2.0 * (F / B_m)))
B_m = abs(B) function code(A, B_m, C, F) return Float64(0.0 - sqrt(Float64(2.0 * Float64(F / B_m)))) end
B_m = abs(B); function tmp = code(A, B_m, C, F) tmp = 0.0 - sqrt((2.0 * (F / B_m))); end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := N[(0.0 - N[Sqrt[N[(2.0 * N[(F / B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
B_m = \left|B\right|
\\
0 - \sqrt{2 \cdot \frac{F}{B\_m}}
\end{array}
Initial program 17.8%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6412.4%
Simplified12.4%
sqrt-unprodN/A
sqrt-lowering-sqrt.f64N/A
clear-numN/A
associate-*l/N/A
metadata-evalN/A
/-lowering-/.f64N/A
/-lowering-/.f6412.5%
Applied egg-rr12.5%
clear-numN/A
associate-/r/N/A
clear-numN/A
*-lowering-*.f64N/A
/-lowering-/.f6412.5%
Applied egg-rr12.5%
Final simplification12.5%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (- 0.0 (sqrt (* F (/ 2.0 B_m)))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
return 0.0 - sqrt((F * (2.0 / B_m)));
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
code = 0.0d0 - sqrt((f * (2.0d0 / b_m)))
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
return 0.0 - Math.sqrt((F * (2.0 / B_m)));
}
B_m = math.fabs(B) def code(A, B_m, C, F): return 0.0 - math.sqrt((F * (2.0 / B_m)))
B_m = abs(B) function code(A, B_m, C, F) return Float64(0.0 - sqrt(Float64(F * Float64(2.0 / B_m)))) end
B_m = abs(B); function tmp = code(A, B_m, C, F) tmp = 0.0 - sqrt((F * (2.0 / B_m))); end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := N[(0.0 - N[Sqrt[N[(F * N[(2.0 / B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
B_m = \left|B\right|
\\
0 - \sqrt{F \cdot \frac{2}{B\_m}}
\end{array}
Initial program 17.8%
Taylor expanded in B around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6412.4%
Simplified12.4%
sqrt-unprodN/A
sqrt-lowering-sqrt.f64N/A
clear-numN/A
associate-*l/N/A
metadata-evalN/A
/-lowering-/.f64N/A
/-lowering-/.f6412.5%
Applied egg-rr12.5%
associate-/r/N/A
*-lowering-*.f64N/A
/-lowering-/.f6412.4%
Applied egg-rr12.4%
Final simplification12.4%
herbie shell --seed 2024156
(FPCore (A B C F)
:name "ABCF->ab-angle a"
:precision binary64
(/ (- (sqrt (* (* 2.0 (* (- (pow B 2.0) (* (* 4.0 A) C)) F)) (+ (+ A C) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0))))))) (- (pow B 2.0) (* (* 4.0 A) C))))