
(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 14 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)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (fma B_m B_m (* A (* C -4.0))))
(t_1 (/ (pow B_m 2.0) A))
(t_2 (- (* 4.0 C) t_1))
(t_3 (* (* 4.0 A) C))
(t_4
(/
(sqrt
(*
(* 2.0 (* (- (pow B_m 2.0) t_3) F))
(+ (+ A C) (sqrt (+ (pow B_m 2.0) (pow (- A C) 2.0))))))
(- t_3 (pow B_m 2.0))))
(t_5 (* F t_0)))
(if (<= t_4 -1e+239)
(* (sqrt F) (- (sqrt (/ t_2 (fma A (* C -4.0) (pow B_m 2.0))))))
(if (<= t_4 -1e-191)
(* (sqrt (* (* 2.0 t_5) (+ (+ A C) (hypot (- A C) B_m)))) (/ -1.0 t_0))
(if (<= t_4 5e-132)
(/
-1.0
(*
A
(/
(fma C -4.0 t_1)
(sqrt (* (* F (fma -4.0 (* A C) (pow B_m 2.0))) t_2)))))
(if (<= t_4 INFINITY)
(/ (* (sqrt t_5) (sqrt (* 4.0 C))) (- t_0))
(* (sqrt F) (- (sqrt (/ 2.0 B_m))))))))))B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double t_0 = fma(B_m, B_m, (A * (C * -4.0)));
double t_1 = pow(B_m, 2.0) / A;
double t_2 = (4.0 * C) - t_1;
double t_3 = (4.0 * A) * C;
double t_4 = sqrt(((2.0 * ((pow(B_m, 2.0) - t_3) * F)) * ((A + C) + sqrt((pow(B_m, 2.0) + pow((A - C), 2.0)))))) / (t_3 - pow(B_m, 2.0));
double t_5 = F * t_0;
double tmp;
if (t_4 <= -1e+239) {
tmp = sqrt(F) * -sqrt((t_2 / fma(A, (C * -4.0), pow(B_m, 2.0))));
} else if (t_4 <= -1e-191) {
tmp = sqrt(((2.0 * t_5) * ((A + C) + hypot((A - C), B_m)))) * (-1.0 / t_0);
} else if (t_4 <= 5e-132) {
tmp = -1.0 / (A * (fma(C, -4.0, t_1) / sqrt(((F * fma(-4.0, (A * C), pow(B_m, 2.0))) * t_2))));
} else if (t_4 <= ((double) INFINITY)) {
tmp = (sqrt(t_5) * sqrt((4.0 * C))) / -t_0;
} else {
tmp = sqrt(F) * -sqrt((2.0 / B_m));
}
return tmp;
}
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) t_0 = fma(B_m, B_m, Float64(A * Float64(C * -4.0))) t_1 = Float64((B_m ^ 2.0) / A) t_2 = Float64(Float64(4.0 * C) - t_1) t_3 = Float64(Float64(4.0 * A) * C) t_4 = Float64(sqrt(Float64(Float64(2.0 * Float64(Float64((B_m ^ 2.0) - t_3) * F)) * Float64(Float64(A + C) + sqrt(Float64((B_m ^ 2.0) + (Float64(A - C) ^ 2.0)))))) / Float64(t_3 - (B_m ^ 2.0))) t_5 = Float64(F * t_0) tmp = 0.0 if (t_4 <= -1e+239) tmp = Float64(sqrt(F) * Float64(-sqrt(Float64(t_2 / fma(A, Float64(C * -4.0), (B_m ^ 2.0)))))); elseif (t_4 <= -1e-191) tmp = Float64(sqrt(Float64(Float64(2.0 * t_5) * Float64(Float64(A + C) + hypot(Float64(A - C), B_m)))) * Float64(-1.0 / t_0)); elseif (t_4 <= 5e-132) tmp = Float64(-1.0 / Float64(A * Float64(fma(C, -4.0, t_1) / sqrt(Float64(Float64(F * fma(-4.0, Float64(A * C), (B_m ^ 2.0))) * t_2))))); elseif (t_4 <= Inf) tmp = Float64(Float64(sqrt(t_5) * sqrt(Float64(4.0 * C))) / Float64(-t_0)); else tmp = Float64(sqrt(F) * Float64(-sqrt(Float64(2.0 / B_m)))); end return tmp end
B_m = N[Abs[B], $MachinePrecision]
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(B$95$m * B$95$m + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[Power[B$95$m, 2.0], $MachinePrecision] / A), $MachinePrecision]}, Block[{t$95$2 = N[(N[(4.0 * C), $MachinePrecision] - t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]}, Block[{t$95$4 = N[(N[Sqrt[N[(N[(2.0 * N[(N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$3), $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$3 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(F * t$95$0), $MachinePrecision]}, If[LessEqual[t$95$4, -1e+239], N[(N[Sqrt[F], $MachinePrecision] * (-N[Sqrt[N[(t$95$2 / N[(A * N[(C * -4.0), $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], If[LessEqual[t$95$4, -1e-191], N[(N[Sqrt[N[(N[(2.0 * t$95$5), $MachinePrecision] * N[(N[(A + C), $MachinePrecision] + N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(-1.0 / t$95$0), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, 5e-132], N[(-1.0 / N[(A * N[(N[(C * -4.0 + t$95$1), $MachinePrecision] / N[Sqrt[N[(N[(F * N[(-4.0 * N[(A * C), $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, Infinity], N[(N[(N[Sqrt[t$95$5], $MachinePrecision] * N[Sqrt[N[(4.0 * C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / (-t$95$0)), $MachinePrecision], N[(N[Sqrt[F], $MachinePrecision] * (-N[Sqrt[N[(2.0 / B$95$m), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]]]]]]]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(B\_m, B\_m, A \cdot \left(C \cdot -4\right)\right)\\
t_1 := \frac{{B\_m}^{2}}{A}\\
t_2 := 4 \cdot C - t\_1\\
t_3 := \left(4 \cdot A\right) \cdot C\\
t_4 := \frac{\sqrt{\left(2 \cdot \left(\left({B\_m}^{2} - t\_3\right) \cdot F\right)\right) \cdot \left(\left(A + C\right) + \sqrt{{B\_m}^{2} + {\left(A - C\right)}^{2}}\right)}}{t\_3 - {B\_m}^{2}}\\
t_5 := F \cdot t\_0\\
\mathbf{if}\;t\_4 \leq -1 \cdot 10^{+239}:\\
\;\;\;\;\sqrt{F} \cdot \left(-\sqrt{\frac{t\_2}{\mathsf{fma}\left(A, C \cdot -4, {B\_m}^{2}\right)}}\right)\\
\mathbf{elif}\;t\_4 \leq -1 \cdot 10^{-191}:\\
\;\;\;\;\sqrt{\left(2 \cdot t\_5\right) \cdot \left(\left(A + C\right) + \mathsf{hypot}\left(A - C, B\_m\right)\right)} \cdot \frac{-1}{t\_0}\\
\mathbf{elif}\;t\_4 \leq 5 \cdot 10^{-132}:\\
\;\;\;\;\frac{-1}{A \cdot \frac{\mathsf{fma}\left(C, -4, t\_1\right)}{\sqrt{\left(F \cdot \mathsf{fma}\left(-4, A \cdot C, {B\_m}^{2}\right)\right) \cdot t\_2}}}\\
\mathbf{elif}\;t\_4 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_5} \cdot \sqrt{4 \cdot C}}{-t\_0}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(-\sqrt{\frac{2}{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))) < -9.99999999999999991e238Initial program 5.6%
Simplified17.8%
Taylor expanded in A around -inf 34.3%
Taylor expanded in F around 0 25.5%
pow1/225.8%
associate-/l*31.1%
unpow-prod-down49.5%
pow1/249.5%
+-commutative49.5%
mul-1-neg49.5%
sub-neg49.5%
*-commutative49.5%
*-commutative49.5%
associate-*r*49.5%
fma-define49.5%
Applied egg-rr49.5%
unpow1/249.3%
Simplified49.3%
if -9.99999999999999991e238 < (/.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))) < -1e-191Initial program 97.2%
Simplified97.3%
associate-*r*97.3%
associate-+r+97.3%
hypot-undefine97.2%
unpow297.2%
unpow297.2%
+-commutative97.2%
sqrt-prod97.3%
*-commutative97.3%
associate-+l+97.3%
Applied egg-rr97.3%
div-inv97.3%
sqrt-unprod97.4%
*-commutative97.4%
associate-+r+97.4%
Applied egg-rr97.4%
if -1e-191 < (/.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))) < 4.9999999999999999e-132Initial program 24.7%
Simplified24.5%
Taylor expanded in A around -inf 28.9%
Taylor expanded in A around -inf 28.9%
associate-*r*28.9%
mul-1-neg28.9%
cancel-sign-sub-inv28.9%
metadata-eval28.9%
Simplified28.9%
clear-num29.0%
inv-pow29.0%
Applied egg-rr29.0%
unpow-129.0%
associate-/l*29.0%
fma-undefine29.0%
unpow229.0%
associate-*r*29.0%
*-commutative29.0%
+-commutative29.0%
fma-define29.0%
*-commutative29.0%
distribute-frac-neg29.0%
fmm-undef29.0%
Simplified29.0%
if 4.9999999999999999e-132 < (/.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 27.6%
Simplified47.9%
Taylor expanded in A around -inf 40.0%
*-commutative40.0%
Simplified40.0%
sqrt-prod56.2%
*-commutative56.2%
*-commutative56.2%
Applied egg-rr56.2%
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%
Taylor expanded in B around inf 20.3%
mul-1-neg20.3%
*-commutative20.3%
Simplified20.3%
*-commutative20.3%
pow1/220.4%
pow1/220.4%
pow-prod-down20.6%
Applied egg-rr20.6%
unpow1/220.5%
Simplified20.5%
associate-*l/20.5%
Applied egg-rr20.5%
pow1/220.6%
associate-/l*20.6%
unpow-prod-down28.5%
pow1/228.5%
Applied egg-rr28.5%
unpow1/228.5%
Simplified28.5%
Final simplification42.2%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (/ (pow B_m 2.0) A)) (t_1 (fma B_m B_m (* A (* C -4.0)))))
(if (<= (pow B_m 2.0) 5e-176)
(/
-1.0
(*
A
(/
(fma C -4.0 t_0)
(sqrt (* (- (* 4.0 C) t_0) (* -4.0 (* A (* C F))))))))
(if (<= (pow B_m 2.0) 2e+42)
(/
(* (sqrt (* 2.0 (* F t_1))) (sqrt (+ A (+ C (hypot (- A C) B_m)))))
(- t_1))
(if (<= (pow B_m 2.0) 5e+111)
(/
-1.0
(*
A
(*
(sqrt
(/
-1.0
(* F (* (+ (pow B_m 2.0) (* -4.0 (* A C))) (- t_0 (* 4.0 C))))))
(+ t_0 (* C -4.0)))))
(if (<= (pow B_m 2.0) 4e+259)
(*
(sqrt 2.0)
(-
(sqrt
(*
F
(/
(+ (+ A C) (hypot B_m (- A C)))
(fma -4.0 (* A C) (pow B_m 2.0)))))))
(* (sqrt F) (- (sqrt (/ 2.0 B_m))))))))))B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double t_0 = pow(B_m, 2.0) / A;
double t_1 = fma(B_m, B_m, (A * (C * -4.0)));
double tmp;
if (pow(B_m, 2.0) <= 5e-176) {
tmp = -1.0 / (A * (fma(C, -4.0, t_0) / sqrt((((4.0 * C) - t_0) * (-4.0 * (A * (C * F)))))));
} else if (pow(B_m, 2.0) <= 2e+42) {
tmp = (sqrt((2.0 * (F * t_1))) * sqrt((A + (C + hypot((A - C), B_m))))) / -t_1;
} else if (pow(B_m, 2.0) <= 5e+111) {
tmp = -1.0 / (A * (sqrt((-1.0 / (F * ((pow(B_m, 2.0) + (-4.0 * (A * C))) * (t_0 - (4.0 * C)))))) * (t_0 + (C * -4.0))));
} else if (pow(B_m, 2.0) <= 4e+259) {
tmp = sqrt(2.0) * -sqrt((F * (((A + C) + hypot(B_m, (A - C))) / fma(-4.0, (A * C), pow(B_m, 2.0)))));
} else {
tmp = sqrt(F) * -sqrt((2.0 / B_m));
}
return tmp;
}
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) t_0 = Float64((B_m ^ 2.0) / A) t_1 = fma(B_m, B_m, Float64(A * Float64(C * -4.0))) tmp = 0.0 if ((B_m ^ 2.0) <= 5e-176) tmp = Float64(-1.0 / Float64(A * Float64(fma(C, -4.0, t_0) / sqrt(Float64(Float64(Float64(4.0 * C) - t_0) * Float64(-4.0 * Float64(A * Float64(C * F)))))))); elseif ((B_m ^ 2.0) <= 2e+42) tmp = Float64(Float64(sqrt(Float64(2.0 * Float64(F * t_1))) * sqrt(Float64(A + Float64(C + hypot(Float64(A - C), B_m))))) / Float64(-t_1)); elseif ((B_m ^ 2.0) <= 5e+111) tmp = Float64(-1.0 / Float64(A * Float64(sqrt(Float64(-1.0 / Float64(F * Float64(Float64((B_m ^ 2.0) + Float64(-4.0 * Float64(A * C))) * Float64(t_0 - Float64(4.0 * C)))))) * Float64(t_0 + Float64(C * -4.0))))); elseif ((B_m ^ 2.0) <= 4e+259) tmp = Float64(sqrt(2.0) * Float64(-sqrt(Float64(F * Float64(Float64(Float64(A + C) + hypot(B_m, Float64(A - C))) / fma(-4.0, Float64(A * C), (B_m ^ 2.0))))))); else tmp = Float64(sqrt(F) * Float64(-sqrt(Float64(2.0 / B_m)))); end return tmp end
B_m = N[Abs[B], $MachinePrecision]
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[Power[B$95$m, 2.0], $MachinePrecision] / A), $MachinePrecision]}, Block[{t$95$1 = N[(B$95$m * B$95$m + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e-176], N[(-1.0 / N[(A * N[(N[(C * -4.0 + t$95$0), $MachinePrecision] / N[Sqrt[N[(N[(N[(4.0 * C), $MachinePrecision] - t$95$0), $MachinePrecision] * N[(-4.0 * N[(A * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 2e+42], N[(N[(N[Sqrt[N[(2.0 * N[(F * t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(A + N[(C + N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / (-t$95$1)), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e+111], N[(-1.0 / N[(A * N[(N[Sqrt[N[(-1.0 / N[(F * N[(N[(N[Power[B$95$m, 2.0], $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(t$95$0 - N[(4.0 * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(t$95$0 + N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 4e+259], N[(N[Sqrt[2.0], $MachinePrecision] * (-N[Sqrt[N[(F * N[(N[(N[(A + C), $MachinePrecision] + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] / N[(-4.0 * N[(A * C), $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], N[(N[Sqrt[F], $MachinePrecision] * (-N[Sqrt[N[(2.0 / B$95$m), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]]]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
t_0 := \frac{{B\_m}^{2}}{A}\\
t_1 := \mathsf{fma}\left(B\_m, B\_m, A \cdot \left(C \cdot -4\right)\right)\\
\mathbf{if}\;{B\_m}^{2} \leq 5 \cdot 10^{-176}:\\
\;\;\;\;\frac{-1}{A \cdot \frac{\mathsf{fma}\left(C, -4, t\_0\right)}{\sqrt{\left(4 \cdot C - t\_0\right) \cdot \left(-4 \cdot \left(A \cdot \left(C \cdot F\right)\right)\right)}}}\\
\mathbf{elif}\;{B\_m}^{2} \leq 2 \cdot 10^{+42}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot t\_1\right)} \cdot \sqrt{A + \left(C + \mathsf{hypot}\left(A - C, B\_m\right)\right)}}{-t\_1}\\
\mathbf{elif}\;{B\_m}^{2} \leq 5 \cdot 10^{+111}:\\
\;\;\;\;\frac{-1}{A \cdot \left(\sqrt{\frac{-1}{F \cdot \left(\left({B\_m}^{2} + -4 \cdot \left(A \cdot C\right)\right) \cdot \left(t\_0 - 4 \cdot C\right)\right)}} \cdot \left(t\_0 + C \cdot -4\right)\right)}\\
\mathbf{elif}\;{B\_m}^{2} \leq 4 \cdot 10^{+259}:\\
\;\;\;\;\sqrt{2} \cdot \left(-\sqrt{F \cdot \frac{\left(A + C\right) + \mathsf{hypot}\left(B\_m, A - C\right)}{\mathsf{fma}\left(-4, A \cdot C, {B\_m}^{2}\right)}}\right)\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(-\sqrt{\frac{2}{B\_m}}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 5e-176Initial program 19.7%
Simplified31.3%
Taylor expanded in A around -inf 22.2%
Taylor expanded in A around -inf 22.2%
associate-*r*22.2%
mul-1-neg22.2%
cancel-sign-sub-inv22.2%
metadata-eval22.2%
Simplified22.2%
clear-num22.2%
inv-pow22.2%
Applied egg-rr22.2%
unpow-122.2%
associate-/l*22.6%
fma-undefine22.6%
unpow222.6%
associate-*r*22.6%
*-commutative22.6%
+-commutative22.6%
fma-define22.6%
*-commutative22.6%
distribute-frac-neg22.6%
fmm-undef22.6%
Simplified22.6%
Taylor expanded in C around inf 22.0%
if 5e-176 < (pow.f64 B #s(literal 2 binary64)) < 2.00000000000000009e42Initial program 45.3%
Simplified50.4%
associate-*r*50.4%
associate-+r+50.0%
hypot-undefine45.3%
unpow245.3%
unpow245.3%
+-commutative45.3%
sqrt-prod51.7%
*-commutative51.7%
associate-+l+52.1%
Applied egg-rr67.9%
if 2.00000000000000009e42 < (pow.f64 B #s(literal 2 binary64)) < 4.9999999999999997e111Initial program 8.4%
Simplified10.2%
Taylor expanded in A around -inf 34.1%
Taylor expanded in A around -inf 33.9%
associate-*r*33.9%
mul-1-neg33.9%
cancel-sign-sub-inv33.9%
metadata-eval33.9%
Simplified33.9%
clear-num33.8%
inv-pow33.8%
Applied egg-rr33.8%
unpow-133.8%
associate-/l*33.9%
fma-undefine33.9%
unpow233.9%
associate-*r*33.9%
*-commutative33.9%
+-commutative33.9%
fma-define33.9%
*-commutative33.9%
distribute-frac-neg33.9%
fmm-undef33.9%
Simplified33.9%
Taylor expanded in F around 0 40.4%
if 4.9999999999999997e111 < (pow.f64 B #s(literal 2 binary64)) < 4e259Initial program 23.8%
Taylor expanded in F around 0 27.4%
Simplified57.9%
if 4e259 < (pow.f64 B #s(literal 2 binary64)) Initial program 2.9%
Taylor expanded in B around inf 32.2%
mul-1-neg32.2%
*-commutative32.2%
Simplified32.2%
*-commutative32.2%
pow1/232.2%
pow1/232.2%
pow-prod-down32.4%
Applied egg-rr32.4%
unpow1/232.4%
Simplified32.4%
associate-*l/32.4%
Applied egg-rr32.4%
pow1/232.4%
associate-/l*32.4%
unpow-prod-down45.6%
pow1/245.6%
Applied egg-rr45.6%
unpow1/245.6%
Simplified45.6%
Final simplification40.6%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (/ (pow B_m 2.0) A)))
(if (<= (pow B_m 2.0) 1e-67)
(/
-1.0
(*
A
(/
(fma C -4.0 t_0)
(sqrt (* (- (* 4.0 C) t_0) (* -4.0 (* A (* C F))))))))
(if (<= (pow B_m 2.0) 4e+259)
(*
(sqrt 2.0)
(-
(sqrt
(*
F
(/
(+ (+ A C) (hypot B_m (- A C)))
(fma -4.0 (* A C) (pow B_m 2.0)))))))
(* (sqrt F) (- (sqrt (/ 2.0 B_m))))))))B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double t_0 = pow(B_m, 2.0) / A;
double tmp;
if (pow(B_m, 2.0) <= 1e-67) {
tmp = -1.0 / (A * (fma(C, -4.0, t_0) / sqrt((((4.0 * C) - t_0) * (-4.0 * (A * (C * F)))))));
} else if (pow(B_m, 2.0) <= 4e+259) {
tmp = sqrt(2.0) * -sqrt((F * (((A + C) + hypot(B_m, (A - C))) / fma(-4.0, (A * C), pow(B_m, 2.0)))));
} else {
tmp = sqrt(F) * -sqrt((2.0 / B_m));
}
return tmp;
}
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) t_0 = Float64((B_m ^ 2.0) / A) tmp = 0.0 if ((B_m ^ 2.0) <= 1e-67) tmp = Float64(-1.0 / Float64(A * Float64(fma(C, -4.0, t_0) / sqrt(Float64(Float64(Float64(4.0 * C) - t_0) * Float64(-4.0 * Float64(A * Float64(C * F)))))))); elseif ((B_m ^ 2.0) <= 4e+259) tmp = Float64(sqrt(2.0) * Float64(-sqrt(Float64(F * Float64(Float64(Float64(A + C) + hypot(B_m, Float64(A - C))) / fma(-4.0, Float64(A * C), (B_m ^ 2.0))))))); else tmp = Float64(sqrt(F) * Float64(-sqrt(Float64(2.0 / B_m)))); end return tmp end
B_m = N[Abs[B], $MachinePrecision]
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[Power[B$95$m, 2.0], $MachinePrecision] / A), $MachinePrecision]}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 1e-67], N[(-1.0 / N[(A * N[(N[(C * -4.0 + t$95$0), $MachinePrecision] / N[Sqrt[N[(N[(N[(4.0 * C), $MachinePrecision] - t$95$0), $MachinePrecision] * N[(-4.0 * N[(A * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 4e+259], N[(N[Sqrt[2.0], $MachinePrecision] * (-N[Sqrt[N[(F * N[(N[(N[(A + C), $MachinePrecision] + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] / N[(-4.0 * N[(A * C), $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], N[(N[Sqrt[F], $MachinePrecision] * (-N[Sqrt[N[(2.0 / B$95$m), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
t_0 := \frac{{B\_m}^{2}}{A}\\
\mathbf{if}\;{B\_m}^{2} \leq 10^{-67}:\\
\;\;\;\;\frac{-1}{A \cdot \frac{\mathsf{fma}\left(C, -4, t\_0\right)}{\sqrt{\left(4 \cdot C - t\_0\right) \cdot \left(-4 \cdot \left(A \cdot \left(C \cdot F\right)\right)\right)}}}\\
\mathbf{elif}\;{B\_m}^{2} \leq 4 \cdot 10^{+259}:\\
\;\;\;\;\sqrt{2} \cdot \left(-\sqrt{F \cdot \frac{\left(A + C\right) + \mathsf{hypot}\left(B\_m, A - C\right)}{\mathsf{fma}\left(-4, A \cdot C, {B\_m}^{2}\right)}}\right)\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(-\sqrt{\frac{2}{B\_m}}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 9.99999999999999943e-68Initial program 22.4%
Simplified32.5%
Taylor expanded in A around -inf 24.5%
Taylor expanded in A around -inf 24.5%
associate-*r*24.5%
mul-1-neg24.5%
cancel-sign-sub-inv24.5%
metadata-eval24.5%
Simplified24.5%
clear-num24.5%
inv-pow24.5%
Applied egg-rr24.5%
unpow-124.5%
associate-/l*24.9%
fma-undefine24.9%
unpow224.9%
associate-*r*24.9%
*-commutative24.9%
+-commutative24.9%
fma-define24.9%
*-commutative24.9%
distribute-frac-neg24.9%
fmm-undef24.9%
Simplified24.9%
Taylor expanded in C around inf 25.2%
if 9.99999999999999943e-68 < (pow.f64 B #s(literal 2 binary64)) < 4e259Initial program 30.6%
Taylor expanded in F around 0 32.2%
Simplified48.6%
if 4e259 < (pow.f64 B #s(literal 2 binary64)) Initial program 2.9%
Taylor expanded in B around inf 32.2%
mul-1-neg32.2%
*-commutative32.2%
Simplified32.2%
*-commutative32.2%
pow1/232.2%
pow1/232.2%
pow-prod-down32.4%
Applied egg-rr32.4%
unpow1/232.4%
Simplified32.4%
associate-*l/32.4%
Applied egg-rr32.4%
pow1/232.4%
associate-/l*32.4%
unpow-prod-down45.6%
pow1/245.6%
Applied egg-rr45.6%
unpow1/245.6%
Simplified45.6%
Final simplification36.8%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (/ (pow B_m 2.0) A)) (t_1 (fma B_m B_m (* A (* C -4.0)))))
(if (<= (pow B_m 2.0) 5e-176)
(/
-1.0
(*
A
(/
(fma C -4.0 t_0)
(sqrt (* (- (* 4.0 C) t_0) (* -4.0 (* A (* C F))))))))
(if (<= (pow B_m 2.0) 4e+221)
(/ (* (sqrt (* 2.0 (* F t_1))) (sqrt (* 2.0 C))) (- t_1))
(* (sqrt F) (- (sqrt (/ 2.0 B_m))))))))B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double t_0 = pow(B_m, 2.0) / A;
double t_1 = fma(B_m, B_m, (A * (C * -4.0)));
double tmp;
if (pow(B_m, 2.0) <= 5e-176) {
tmp = -1.0 / (A * (fma(C, -4.0, t_0) / sqrt((((4.0 * C) - t_0) * (-4.0 * (A * (C * F)))))));
} else if (pow(B_m, 2.0) <= 4e+221) {
tmp = (sqrt((2.0 * (F * t_1))) * sqrt((2.0 * C))) / -t_1;
} else {
tmp = sqrt(F) * -sqrt((2.0 / B_m));
}
return tmp;
}
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) t_0 = Float64((B_m ^ 2.0) / A) t_1 = fma(B_m, B_m, Float64(A * Float64(C * -4.0))) tmp = 0.0 if ((B_m ^ 2.0) <= 5e-176) tmp = Float64(-1.0 / Float64(A * Float64(fma(C, -4.0, t_0) / sqrt(Float64(Float64(Float64(4.0 * C) - t_0) * Float64(-4.0 * Float64(A * Float64(C * F)))))))); elseif ((B_m ^ 2.0) <= 4e+221) tmp = Float64(Float64(sqrt(Float64(2.0 * Float64(F * t_1))) * sqrt(Float64(2.0 * C))) / Float64(-t_1)); else tmp = Float64(sqrt(F) * Float64(-sqrt(Float64(2.0 / B_m)))); end return tmp end
B_m = N[Abs[B], $MachinePrecision]
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[Power[B$95$m, 2.0], $MachinePrecision] / A), $MachinePrecision]}, Block[{t$95$1 = N[(B$95$m * B$95$m + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e-176], N[(-1.0 / N[(A * N[(N[(C * -4.0 + t$95$0), $MachinePrecision] / N[Sqrt[N[(N[(N[(4.0 * C), $MachinePrecision] - t$95$0), $MachinePrecision] * N[(-4.0 * N[(A * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 4e+221], N[(N[(N[Sqrt[N[(2.0 * N[(F * t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(2.0 * C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / (-t$95$1)), $MachinePrecision], N[(N[Sqrt[F], $MachinePrecision] * (-N[Sqrt[N[(2.0 / B$95$m), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
t_0 := \frac{{B\_m}^{2}}{A}\\
t_1 := \mathsf{fma}\left(B\_m, B\_m, A \cdot \left(C \cdot -4\right)\right)\\
\mathbf{if}\;{B\_m}^{2} \leq 5 \cdot 10^{-176}:\\
\;\;\;\;\frac{-1}{A \cdot \frac{\mathsf{fma}\left(C, -4, t\_0\right)}{\sqrt{\left(4 \cdot C - t\_0\right) \cdot \left(-4 \cdot \left(A \cdot \left(C \cdot F\right)\right)\right)}}}\\
\mathbf{elif}\;{B\_m}^{2} \leq 4 \cdot 10^{+221}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot t\_1\right)} \cdot \sqrt{2 \cdot C}}{-t\_1}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(-\sqrt{\frac{2}{B\_m}}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 5e-176Initial program 19.7%
Simplified31.3%
Taylor expanded in A around -inf 22.2%
Taylor expanded in A around -inf 22.2%
associate-*r*22.2%
mul-1-neg22.2%
cancel-sign-sub-inv22.2%
metadata-eval22.2%
Simplified22.2%
clear-num22.2%
inv-pow22.2%
Applied egg-rr22.2%
unpow-122.2%
associate-/l*22.6%
fma-undefine22.6%
unpow222.6%
associate-*r*22.6%
*-commutative22.6%
+-commutative22.6%
fma-define22.6%
*-commutative22.6%
distribute-frac-neg22.6%
fmm-undef22.6%
Simplified22.6%
Taylor expanded in C around inf 22.0%
if 5e-176 < (pow.f64 B #s(literal 2 binary64)) < 4.0000000000000002e221Initial program 34.5%
Simplified40.7%
associate-*r*40.7%
associate-+r+40.0%
hypot-undefine34.5%
unpow234.5%
unpow234.5%
+-commutative34.5%
sqrt-prod38.1%
*-commutative38.1%
associate-+l+38.6%
Applied egg-rr52.8%
Taylor expanded in A around -inf 28.5%
if 4.0000000000000002e221 < (pow.f64 B #s(literal 2 binary64)) Initial program 2.9%
Taylor expanded in B around inf 31.6%
mul-1-neg31.6%
*-commutative31.6%
Simplified31.6%
*-commutative31.6%
pow1/231.6%
pow1/231.6%
pow-prod-down31.9%
Applied egg-rr31.9%
unpow1/231.9%
Simplified31.9%
associate-*l/31.9%
Applied egg-rr31.9%
pow1/231.9%
associate-/l*31.9%
unpow-prod-down44.0%
pow1/244.0%
Applied egg-rr44.0%
unpow1/244.0%
Simplified44.0%
Final simplification30.3%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (fma B_m B_m (* A (* C -4.0)))))
(if (<= (pow B_m 2.0) 5e-176)
(/
-1.0
(*
A
(/
(* C -4.0)
(sqrt
(*
(* F (fma -4.0 (* A C) (pow B_m 2.0)))
(- (* 4.0 C) (/ (pow B_m 2.0) A)))))))
(if (<= (pow B_m 2.0) 4e+221)
(/ (* (sqrt (* 2.0 (* F t_0))) (sqrt (* 2.0 C))) (- t_0))
(* (sqrt F) (- (sqrt (/ 2.0 B_m))))))))B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double t_0 = fma(B_m, B_m, (A * (C * -4.0)));
double tmp;
if (pow(B_m, 2.0) <= 5e-176) {
tmp = -1.0 / (A * ((C * -4.0) / sqrt(((F * fma(-4.0, (A * C), pow(B_m, 2.0))) * ((4.0 * C) - (pow(B_m, 2.0) / A))))));
} else if (pow(B_m, 2.0) <= 4e+221) {
tmp = (sqrt((2.0 * (F * t_0))) * sqrt((2.0 * C))) / -t_0;
} else {
tmp = sqrt(F) * -sqrt((2.0 / B_m));
}
return tmp;
}
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) t_0 = fma(B_m, B_m, Float64(A * Float64(C * -4.0))) tmp = 0.0 if ((B_m ^ 2.0) <= 5e-176) tmp = Float64(-1.0 / Float64(A * Float64(Float64(C * -4.0) / sqrt(Float64(Float64(F * fma(-4.0, Float64(A * C), (B_m ^ 2.0))) * Float64(Float64(4.0 * C) - Float64((B_m ^ 2.0) / A))))))); elseif ((B_m ^ 2.0) <= 4e+221) tmp = Float64(Float64(sqrt(Float64(2.0 * Float64(F * t_0))) * sqrt(Float64(2.0 * C))) / Float64(-t_0)); else tmp = Float64(sqrt(F) * Float64(-sqrt(Float64(2.0 / B_m)))); end return tmp end
B_m = N[Abs[B], $MachinePrecision]
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(B$95$m * B$95$m + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e-176], N[(-1.0 / N[(A * N[(N[(C * -4.0), $MachinePrecision] / N[Sqrt[N[(N[(F * N[(-4.0 * N[(A * C), $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(4.0 * C), $MachinePrecision] - N[(N[Power[B$95$m, 2.0], $MachinePrecision] / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 4e+221], N[(N[(N[Sqrt[N[(2.0 * N[(F * t$95$0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(2.0 * C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / (-t$95$0)), $MachinePrecision], N[(N[Sqrt[F], $MachinePrecision] * (-N[Sqrt[N[(2.0 / B$95$m), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(B\_m, B\_m, A \cdot \left(C \cdot -4\right)\right)\\
\mathbf{if}\;{B\_m}^{2} \leq 5 \cdot 10^{-176}:\\
\;\;\;\;\frac{-1}{A \cdot \frac{C \cdot -4}{\sqrt{\left(F \cdot \mathsf{fma}\left(-4, A \cdot C, {B\_m}^{2}\right)\right) \cdot \left(4 \cdot C - \frac{{B\_m}^{2}}{A}\right)}}}\\
\mathbf{elif}\;{B\_m}^{2} \leq 4 \cdot 10^{+221}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot t\_0\right)} \cdot \sqrt{2 \cdot C}}{-t\_0}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(-\sqrt{\frac{2}{B\_m}}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 5e-176Initial program 19.7%
Simplified31.3%
Taylor expanded in A around -inf 22.2%
Taylor expanded in A around -inf 22.2%
associate-*r*22.2%
mul-1-neg22.2%
cancel-sign-sub-inv22.2%
metadata-eval22.2%
Simplified22.2%
clear-num22.2%
inv-pow22.2%
Applied egg-rr22.2%
unpow-122.2%
associate-/l*22.6%
fma-undefine22.6%
unpow222.6%
associate-*r*22.6%
*-commutative22.6%
+-commutative22.6%
fma-define22.6%
*-commutative22.6%
distribute-frac-neg22.6%
fmm-undef22.6%
Simplified22.6%
Taylor expanded in C around inf 22.5%
if 5e-176 < (pow.f64 B #s(literal 2 binary64)) < 4.0000000000000002e221Initial program 34.5%
Simplified40.7%
associate-*r*40.7%
associate-+r+40.0%
hypot-undefine34.5%
unpow234.5%
unpow234.5%
+-commutative34.5%
sqrt-prod38.1%
*-commutative38.1%
associate-+l+38.6%
Applied egg-rr52.8%
Taylor expanded in A around -inf 28.5%
if 4.0000000000000002e221 < (pow.f64 B #s(literal 2 binary64)) Initial program 2.9%
Taylor expanded in B around inf 31.6%
mul-1-neg31.6%
*-commutative31.6%
Simplified31.6%
*-commutative31.6%
pow1/231.6%
pow1/231.6%
pow-prod-down31.9%
Applied egg-rr31.9%
unpow1/231.9%
Simplified31.9%
associate-*l/31.9%
Applied egg-rr31.9%
pow1/231.9%
associate-/l*31.9%
unpow-prod-down44.0%
pow1/244.0%
Applied egg-rr44.0%
unpow1/244.0%
Simplified44.0%
Final simplification30.5%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (fma B_m B_m (* A (* C -4.0)))) (t_1 (* F t_0)))
(if (<= (pow B_m 2.0) 5e-176)
(/ -1.0 (/ t_0 (sqrt (* t_1 (* 4.0 C)))))
(if (<= (pow B_m 2.0) 4e+221)
(/ (* (sqrt (* 2.0 t_1)) (sqrt (* 2.0 C))) (- t_0))
(* (sqrt F) (- (sqrt (/ 2.0 B_m))))))))B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double t_0 = fma(B_m, B_m, (A * (C * -4.0)));
double t_1 = F * t_0;
double tmp;
if (pow(B_m, 2.0) <= 5e-176) {
tmp = -1.0 / (t_0 / sqrt((t_1 * (4.0 * C))));
} else if (pow(B_m, 2.0) <= 4e+221) {
tmp = (sqrt((2.0 * t_1)) * sqrt((2.0 * C))) / -t_0;
} else {
tmp = sqrt(F) * -sqrt((2.0 / B_m));
}
return tmp;
}
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) t_0 = fma(B_m, B_m, Float64(A * Float64(C * -4.0))) t_1 = Float64(F * t_0) tmp = 0.0 if ((B_m ^ 2.0) <= 5e-176) tmp = Float64(-1.0 / Float64(t_0 / sqrt(Float64(t_1 * Float64(4.0 * C))))); elseif ((B_m ^ 2.0) <= 4e+221) tmp = Float64(Float64(sqrt(Float64(2.0 * t_1)) * sqrt(Float64(2.0 * C))) / Float64(-t_0)); else tmp = Float64(sqrt(F) * Float64(-sqrt(Float64(2.0 / B_m)))); end return tmp end
B_m = N[Abs[B], $MachinePrecision]
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(B$95$m * B$95$m + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(F * t$95$0), $MachinePrecision]}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e-176], N[(-1.0 / N[(t$95$0 / N[Sqrt[N[(t$95$1 * N[(4.0 * C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 4e+221], N[(N[(N[Sqrt[N[(2.0 * t$95$1), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(2.0 * C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / (-t$95$0)), $MachinePrecision], N[(N[Sqrt[F], $MachinePrecision] * (-N[Sqrt[N[(2.0 / B$95$m), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(B\_m, B\_m, A \cdot \left(C \cdot -4\right)\right)\\
t_1 := F \cdot t\_0\\
\mathbf{if}\;{B\_m}^{2} \leq 5 \cdot 10^{-176}:\\
\;\;\;\;\frac{-1}{\frac{t\_0}{\sqrt{t\_1 \cdot \left(4 \cdot C\right)}}}\\
\mathbf{elif}\;{B\_m}^{2} \leq 4 \cdot 10^{+221}:\\
\;\;\;\;\frac{\sqrt{2 \cdot t\_1} \cdot \sqrt{2 \cdot C}}{-t\_0}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(-\sqrt{\frac{2}{B\_m}}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 5e-176Initial program 19.7%
Simplified31.3%
Taylor expanded in A around -inf 23.1%
*-commutative23.1%
Simplified23.1%
clear-num23.1%
inv-pow23.1%
*-commutative23.1%
*-commutative23.1%
*-commutative23.1%
Applied egg-rr23.1%
unpow-123.1%
Simplified23.1%
if 5e-176 < (pow.f64 B #s(literal 2 binary64)) < 4.0000000000000002e221Initial program 34.5%
Simplified40.7%
associate-*r*40.7%
associate-+r+40.0%
hypot-undefine34.5%
unpow234.5%
unpow234.5%
+-commutative34.5%
sqrt-prod38.1%
*-commutative38.1%
associate-+l+38.6%
Applied egg-rr52.8%
Taylor expanded in A around -inf 28.5%
if 4.0000000000000002e221 < (pow.f64 B #s(literal 2 binary64)) Initial program 2.9%
Taylor expanded in B around inf 31.6%
mul-1-neg31.6%
*-commutative31.6%
Simplified31.6%
*-commutative31.6%
pow1/231.6%
pow1/231.6%
pow-prod-down31.9%
Applied egg-rr31.9%
unpow1/231.9%
Simplified31.9%
associate-*l/31.9%
Applied egg-rr31.9%
pow1/231.9%
associate-/l*31.9%
unpow-prod-down44.0%
pow1/244.0%
Applied egg-rr44.0%
unpow1/244.0%
Simplified44.0%
Final simplification30.8%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (fma B_m B_m (* A (* C -4.0)))) (t_1 (* F t_0)))
(if (<= (pow B_m 2.0) 5e-176)
(/ -1.0 (/ t_0 (sqrt (* t_1 (* 4.0 C)))))
(if (<= (pow B_m 2.0) 4e+221)
(/ (* (sqrt t_1) (sqrt (* 4.0 C))) (- t_0))
(* (sqrt F) (- (sqrt (/ 2.0 B_m))))))))B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double t_0 = fma(B_m, B_m, (A * (C * -4.0)));
double t_1 = F * t_0;
double tmp;
if (pow(B_m, 2.0) <= 5e-176) {
tmp = -1.0 / (t_0 / sqrt((t_1 * (4.0 * C))));
} else if (pow(B_m, 2.0) <= 4e+221) {
tmp = (sqrt(t_1) * sqrt((4.0 * C))) / -t_0;
} else {
tmp = sqrt(F) * -sqrt((2.0 / B_m));
}
return tmp;
}
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) t_0 = fma(B_m, B_m, Float64(A * Float64(C * -4.0))) t_1 = Float64(F * t_0) tmp = 0.0 if ((B_m ^ 2.0) <= 5e-176) tmp = Float64(-1.0 / Float64(t_0 / sqrt(Float64(t_1 * Float64(4.0 * C))))); elseif ((B_m ^ 2.0) <= 4e+221) tmp = Float64(Float64(sqrt(t_1) * sqrt(Float64(4.0 * C))) / Float64(-t_0)); else tmp = Float64(sqrt(F) * Float64(-sqrt(Float64(2.0 / B_m)))); end return tmp end
B_m = N[Abs[B], $MachinePrecision]
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(B$95$m * B$95$m + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(F * t$95$0), $MachinePrecision]}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e-176], N[(-1.0 / N[(t$95$0 / N[Sqrt[N[(t$95$1 * N[(4.0 * C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 4e+221], N[(N[(N[Sqrt[t$95$1], $MachinePrecision] * N[Sqrt[N[(4.0 * C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / (-t$95$0)), $MachinePrecision], N[(N[Sqrt[F], $MachinePrecision] * (-N[Sqrt[N[(2.0 / B$95$m), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(B\_m, B\_m, A \cdot \left(C \cdot -4\right)\right)\\
t_1 := F \cdot t\_0\\
\mathbf{if}\;{B\_m}^{2} \leq 5 \cdot 10^{-176}:\\
\;\;\;\;\frac{-1}{\frac{t\_0}{\sqrt{t\_1 \cdot \left(4 \cdot C\right)}}}\\
\mathbf{elif}\;{B\_m}^{2} \leq 4 \cdot 10^{+221}:\\
\;\;\;\;\frac{\sqrt{t\_1} \cdot \sqrt{4 \cdot C}}{-t\_0}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(-\sqrt{\frac{2}{B\_m}}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 5e-176Initial program 19.7%
Simplified31.3%
Taylor expanded in A around -inf 23.1%
*-commutative23.1%
Simplified23.1%
clear-num23.1%
inv-pow23.1%
*-commutative23.1%
*-commutative23.1%
*-commutative23.1%
Applied egg-rr23.1%
unpow-123.1%
Simplified23.1%
if 5e-176 < (pow.f64 B #s(literal 2 binary64)) < 4.0000000000000002e221Initial program 34.5%
Simplified40.7%
Taylor expanded in A around -inf 26.1%
*-commutative26.1%
Simplified26.1%
sqrt-prod28.5%
*-commutative28.5%
*-commutative28.5%
Applied egg-rr28.5%
if 4.0000000000000002e221 < (pow.f64 B #s(literal 2 binary64)) Initial program 2.9%
Taylor expanded in B around inf 31.6%
mul-1-neg31.6%
*-commutative31.6%
Simplified31.6%
*-commutative31.6%
pow1/231.6%
pow1/231.6%
pow-prod-down31.9%
Applied egg-rr31.9%
unpow1/231.9%
Simplified31.9%
associate-*l/31.9%
Applied egg-rr31.9%
pow1/231.9%
associate-/l*31.9%
unpow-prod-down44.0%
pow1/244.0%
Applied egg-rr44.0%
unpow1/244.0%
Simplified44.0%
Final simplification30.8%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(if (<= (pow B_m 2.0) 1e-75)
(/
(sqrt (* (* F (fma B_m B_m (* A (* C -4.0)))) (* 4.0 C)))
(* (* 4.0 A) C))
(if (<= (pow B_m 2.0) 1e-25)
(- (sqrt (/ F (- A))))
(if (<= (pow B_m 2.0) 5e+294)
(* (sqrt (* F (+ C (hypot C B_m)))) (/ (sqrt 2.0) (- B_m)))
(* (sqrt F) (- (sqrt (/ 2.0 B_m))))))))B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double tmp;
if (pow(B_m, 2.0) <= 1e-75) {
tmp = sqrt(((F * fma(B_m, B_m, (A * (C * -4.0)))) * (4.0 * C))) / ((4.0 * A) * C);
} else if (pow(B_m, 2.0) <= 1e-25) {
tmp = -sqrt((F / -A));
} else if (pow(B_m, 2.0) <= 5e+294) {
tmp = sqrt((F * (C + hypot(C, B_m)))) * (sqrt(2.0) / -B_m);
} else {
tmp = sqrt(F) * -sqrt((2.0 / B_m));
}
return tmp;
}
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) tmp = 0.0 if ((B_m ^ 2.0) <= 1e-75) tmp = Float64(sqrt(Float64(Float64(F * fma(B_m, B_m, Float64(A * Float64(C * -4.0)))) * Float64(4.0 * C))) / Float64(Float64(4.0 * A) * C)); elseif ((B_m ^ 2.0) <= 1e-25) tmp = Float64(-sqrt(Float64(F / Float64(-A)))); elseif ((B_m ^ 2.0) <= 5e+294) tmp = Float64(sqrt(Float64(F * Float64(C + hypot(C, B_m)))) * Float64(sqrt(2.0) / Float64(-B_m))); else tmp = Float64(sqrt(F) * Float64(-sqrt(Float64(2.0 / B_m)))); end return tmp end
B_m = N[Abs[B], $MachinePrecision] NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. code[A_, B$95$m_, C_, F_] := If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 1e-75], N[(N[Sqrt[N[(N[(F * N[(B$95$m * B$95$m + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(4.0 * C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 1e-25], (-N[Sqrt[N[(F / (-A)), $MachinePrecision]], $MachinePrecision]), If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e+294], N[(N[Sqrt[N[(F * N[(C + N[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / (-B$95$m)), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[F], $MachinePrecision] * (-N[Sqrt[N[(2.0 / B$95$m), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
\mathbf{if}\;{B\_m}^{2} \leq 10^{-75}:\\
\;\;\;\;\frac{\sqrt{\left(F \cdot \mathsf{fma}\left(B\_m, B\_m, A \cdot \left(C \cdot -4\right)\right)\right) \cdot \left(4 \cdot C\right)}}{\left(4 \cdot A\right) \cdot C}\\
\mathbf{elif}\;{B\_m}^{2} \leq 10^{-25}:\\
\;\;\;\;-\sqrt{\frac{F}{-A}}\\
\mathbf{elif}\;{B\_m}^{2} \leq 5 \cdot 10^{+294}:\\
\;\;\;\;\sqrt{F \cdot \left(C + \mathsf{hypot}\left(C, B\_m\right)\right)} \cdot \frac{\sqrt{2}}{-B\_m}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(-\sqrt{\frac{2}{B\_m}}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 9.9999999999999996e-76Initial program 22.5%
Simplified32.8%
Taylor expanded in A around -inf 25.5%
*-commutative25.5%
Simplified25.5%
Taylor expanded in B around 0 23.7%
associate-*r*23.7%
Simplified23.7%
if 9.9999999999999996e-76 < (pow.f64 B #s(literal 2 binary64)) < 1.00000000000000004e-25Initial program 23.9%
Simplified32.8%
Taylor expanded in A around -inf 28.5%
Taylor expanded in F around 0 37.3%
Taylor expanded in B around 0 55.2%
associate-*r/55.2%
neg-mul-155.2%
Simplified55.2%
if 1.00000000000000004e-25 < (pow.f64 B #s(literal 2 binary64)) < 4.9999999999999999e294Initial program 33.2%
Taylor expanded in A around 0 8.7%
mul-1-neg8.7%
*-commutative8.7%
*-commutative8.7%
+-commutative8.7%
unpow28.7%
unpow28.7%
hypot-define12.4%
Simplified12.4%
if 4.9999999999999999e294 < (pow.f64 B #s(literal 2 binary64)) Initial program 0.0%
Taylor expanded in B around inf 33.6%
mul-1-neg33.6%
*-commutative33.6%
Simplified33.6%
*-commutative33.6%
pow1/233.6%
pow1/233.6%
pow-prod-down33.8%
Applied egg-rr33.8%
unpow1/233.8%
Simplified33.8%
associate-*l/33.8%
Applied egg-rr33.8%
pow1/233.8%
associate-/l*33.8%
unpow-prod-down47.7%
pow1/247.7%
Applied egg-rr47.7%
unpow1/247.7%
Simplified47.7%
Final simplification28.6%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (fma B_m B_m (* A (* C -4.0)))))
(if (<= (pow B_m 2.0) 4e+221)
(/ (sqrt (* (* F t_0) (* 4.0 C))) (- t_0))
(* (sqrt F) (- (sqrt (/ 2.0 B_m)))))))B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double t_0 = fma(B_m, B_m, (A * (C * -4.0)));
double tmp;
if (pow(B_m, 2.0) <= 4e+221) {
tmp = sqrt(((F * t_0) * (4.0 * C))) / -t_0;
} else {
tmp = sqrt(F) * -sqrt((2.0 / B_m));
}
return tmp;
}
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) t_0 = fma(B_m, B_m, Float64(A * Float64(C * -4.0))) tmp = 0.0 if ((B_m ^ 2.0) <= 4e+221) tmp = Float64(sqrt(Float64(Float64(F * t_0) * Float64(4.0 * C))) / Float64(-t_0)); else tmp = Float64(sqrt(F) * Float64(-sqrt(Float64(2.0 / B_m)))); end return tmp end
B_m = N[Abs[B], $MachinePrecision]
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(B$95$m * B$95$m + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 4e+221], N[(N[Sqrt[N[(N[(F * t$95$0), $MachinePrecision] * N[(4.0 * C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$0)), $MachinePrecision], N[(N[Sqrt[F], $MachinePrecision] * (-N[Sqrt[N[(2.0 / B$95$m), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
t_0 := \mathsf{fma}\left(B\_m, B\_m, A \cdot \left(C \cdot -4\right)\right)\\
\mathbf{if}\;{B\_m}^{2} \leq 4 \cdot 10^{+221}:\\
\;\;\;\;\frac{\sqrt{\left(F \cdot t\_0\right) \cdot \left(4 \cdot C\right)}}{-t\_0}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(-\sqrt{\frac{2}{B\_m}}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 4.0000000000000002e221Initial program 25.9%
Simplified35.3%
Taylor expanded in A around -inf 24.4%
*-commutative24.4%
Simplified24.4%
if 4.0000000000000002e221 < (pow.f64 B #s(literal 2 binary64)) Initial program 2.9%
Taylor expanded in B around inf 31.6%
mul-1-neg31.6%
*-commutative31.6%
Simplified31.6%
*-commutative31.6%
pow1/231.6%
pow1/231.6%
pow-prod-down31.9%
Applied egg-rr31.9%
unpow1/231.9%
Simplified31.9%
associate-*l/31.9%
Applied egg-rr31.9%
pow1/231.9%
associate-/l*31.9%
unpow-prod-down44.0%
pow1/244.0%
Applied egg-rr44.0%
unpow1/244.0%
Simplified44.0%
Final simplification30.1%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(if (<= (pow B_m 2.0) 1e-75)
(/
(sqrt (* (* F (fma B_m B_m (* A (* C -4.0)))) (* 4.0 C)))
(* (* 4.0 A) C))
(if (<= (pow B_m 2.0) 4e+221)
(- (sqrt (/ F (- A))))
(* (sqrt F) (- (sqrt (/ 2.0 B_m)))))))B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double tmp;
if (pow(B_m, 2.0) <= 1e-75) {
tmp = sqrt(((F * fma(B_m, B_m, (A * (C * -4.0)))) * (4.0 * C))) / ((4.0 * A) * C);
} else if (pow(B_m, 2.0) <= 4e+221) {
tmp = -sqrt((F / -A));
} else {
tmp = sqrt(F) * -sqrt((2.0 / B_m));
}
return tmp;
}
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) tmp = 0.0 if ((B_m ^ 2.0) <= 1e-75) tmp = Float64(sqrt(Float64(Float64(F * fma(B_m, B_m, Float64(A * Float64(C * -4.0)))) * Float64(4.0 * C))) / Float64(Float64(4.0 * A) * C)); elseif ((B_m ^ 2.0) <= 4e+221) tmp = Float64(-sqrt(Float64(F / Float64(-A)))); else tmp = Float64(sqrt(F) * Float64(-sqrt(Float64(2.0 / B_m)))); end return tmp end
B_m = N[Abs[B], $MachinePrecision] NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. code[A_, B$95$m_, C_, F_] := If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 1e-75], N[(N[Sqrt[N[(N[(F * N[(B$95$m * B$95$m + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(4.0 * C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 4e+221], (-N[Sqrt[N[(F / (-A)), $MachinePrecision]], $MachinePrecision]), N[(N[Sqrt[F], $MachinePrecision] * (-N[Sqrt[N[(2.0 / B$95$m), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
\mathbf{if}\;{B\_m}^{2} \leq 10^{-75}:\\
\;\;\;\;\frac{\sqrt{\left(F \cdot \mathsf{fma}\left(B\_m, B\_m, A \cdot \left(C \cdot -4\right)\right)\right) \cdot \left(4 \cdot C\right)}}{\left(4 \cdot A\right) \cdot C}\\
\mathbf{elif}\;{B\_m}^{2} \leq 4 \cdot 10^{+221}:\\
\;\;\;\;-\sqrt{\frac{F}{-A}}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(-\sqrt{\frac{2}{B\_m}}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 9.9999999999999996e-76Initial program 22.5%
Simplified32.8%
Taylor expanded in A around -inf 25.5%
*-commutative25.5%
Simplified25.5%
Taylor expanded in B around 0 23.7%
associate-*r*23.7%
Simplified23.7%
if 9.9999999999999996e-76 < (pow.f64 B #s(literal 2 binary64)) < 4.0000000000000002e221Initial program 32.4%
Simplified39.9%
Taylor expanded in A around -inf 25.2%
Taylor expanded in F around 0 19.5%
Taylor expanded in B around 0 22.6%
associate-*r/22.6%
neg-mul-122.6%
Simplified22.6%
if 4.0000000000000002e221 < (pow.f64 B #s(literal 2 binary64)) Initial program 2.9%
Taylor expanded in B around inf 31.6%
mul-1-neg31.6%
*-commutative31.6%
Simplified31.6%
*-commutative31.6%
pow1/231.6%
pow1/231.6%
pow-prod-down31.9%
Applied egg-rr31.9%
unpow1/231.9%
Simplified31.9%
associate-*l/31.9%
Applied egg-rr31.9%
pow1/231.9%
associate-/l*31.9%
unpow-prod-down44.0%
pow1/244.0%
Applied egg-rr44.0%
unpow1/244.0%
Simplified44.0%
Final simplification29.3%
B_m = (fabs.f64 B) NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. (FPCore (A B_m C F) :precision binary64 (if (<= (pow B_m 2.0) 4e+221) (- (sqrt (/ F (- A)))) (* (sqrt F) (- (sqrt (/ 2.0 B_m))))))
B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double tmp;
if (pow(B_m, 2.0) <= 4e+221) {
tmp = -sqrt((F / -A));
} else {
tmp = sqrt(F) * -sqrt((2.0 / B_m));
}
return tmp;
}
B_m = abs(b)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
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 ** 2.0d0) <= 4d+221) then
tmp = -sqrt((f / -a))
else
tmp = sqrt(f) * -sqrt((2.0d0 / b_m))
end if
code = tmp
end function
B_m = Math.abs(B);
assert A < B_m && B_m < C && C < F;
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (Math.pow(B_m, 2.0) <= 4e+221) {
tmp = -Math.sqrt((F / -A));
} else {
tmp = Math.sqrt(F) * -Math.sqrt((2.0 / B_m));
}
return tmp;
}
B_m = math.fabs(B) [A, B_m, C, F] = sort([A, B_m, C, F]) def code(A, B_m, C, F): tmp = 0 if math.pow(B_m, 2.0) <= 4e+221: tmp = -math.sqrt((F / -A)) else: tmp = math.sqrt(F) * -math.sqrt((2.0 / B_m)) return tmp
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) tmp = 0.0 if ((B_m ^ 2.0) <= 4e+221) tmp = Float64(-sqrt(Float64(F / Float64(-A)))); else tmp = Float64(sqrt(F) * Float64(-sqrt(Float64(2.0 / B_m)))); end return tmp end
B_m = abs(B);
A, B_m, C, F = num2cell(sort([A, B_m, C, F])){:}
function tmp_2 = code(A, B_m, C, F)
tmp = 0.0;
if ((B_m ^ 2.0) <= 4e+221)
tmp = -sqrt((F / -A));
else
tmp = sqrt(F) * -sqrt((2.0 / B_m));
end
tmp_2 = tmp;
end
B_m = N[Abs[B], $MachinePrecision] NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. code[A_, B$95$m_, C_, F_] := If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 4e+221], (-N[Sqrt[N[(F / (-A)), $MachinePrecision]], $MachinePrecision]), N[(N[Sqrt[F], $MachinePrecision] * (-N[Sqrt[N[(2.0 / B$95$m), $MachinePrecision]], $MachinePrecision])), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
\mathbf{if}\;{B\_m}^{2} \leq 4 \cdot 10^{+221}:\\
\;\;\;\;-\sqrt{\frac{F}{-A}}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F} \cdot \left(-\sqrt{\frac{2}{B\_m}}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 4.0000000000000002e221Initial program 25.9%
Simplified35.3%
Taylor expanded in A around -inf 24.4%
Taylor expanded in F around 0 16.0%
Taylor expanded in B around 0 20.5%
associate-*r/20.5%
neg-mul-120.5%
Simplified20.5%
if 4.0000000000000002e221 < (pow.f64 B #s(literal 2 binary64)) Initial program 2.9%
Taylor expanded in B around inf 31.6%
mul-1-neg31.6%
*-commutative31.6%
Simplified31.6%
*-commutative31.6%
pow1/231.6%
pow1/231.6%
pow-prod-down31.9%
Applied egg-rr31.9%
unpow1/231.9%
Simplified31.9%
associate-*l/31.9%
Applied egg-rr31.9%
pow1/231.9%
associate-/l*31.9%
unpow-prod-down44.0%
pow1/244.0%
Applied egg-rr44.0%
unpow1/244.0%
Simplified44.0%
Final simplification27.3%
B_m = (fabs.f64 B) NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. (FPCore (A B_m C F) :precision binary64 (if (<= B_m 7.5e+109) (- (sqrt (/ F (- A)))) (- (sqrt (* 2.0 (fabs (/ F B_m)))))))
B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 7.5e+109) {
tmp = -sqrt((F / -A));
} else {
tmp = -sqrt((2.0 * fabs((F / B_m))));
}
return tmp;
}
B_m = abs(b)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
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 <= 7.5d+109) then
tmp = -sqrt((f / -a))
else
tmp = -sqrt((2.0d0 * abs((f / b_m))))
end if
code = tmp
end function
B_m = Math.abs(B);
assert A < B_m && B_m < C && C < F;
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 7.5e+109) {
tmp = -Math.sqrt((F / -A));
} else {
tmp = -Math.sqrt((2.0 * Math.abs((F / B_m))));
}
return tmp;
}
B_m = math.fabs(B) [A, B_m, C, F] = sort([A, B_m, C, F]) def code(A, B_m, C, F): tmp = 0 if B_m <= 7.5e+109: tmp = -math.sqrt((F / -A)) else: tmp = -math.sqrt((2.0 * math.fabs((F / B_m)))) return tmp
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 7.5e+109) tmp = Float64(-sqrt(Float64(F / Float64(-A)))); else tmp = Float64(-sqrt(Float64(2.0 * abs(Float64(F / B_m))))); end return tmp end
B_m = abs(B);
A, B_m, C, F = num2cell(sort([A, B_m, C, F])){:}
function tmp_2 = code(A, B_m, C, F)
tmp = 0.0;
if (B_m <= 7.5e+109)
tmp = -sqrt((F / -A));
else
tmp = -sqrt((2.0 * abs((F / B_m))));
end
tmp_2 = tmp;
end
B_m = N[Abs[B], $MachinePrecision] NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 7.5e+109], (-N[Sqrt[N[(F / (-A)), $MachinePrecision]], $MachinePrecision]), (-N[Sqrt[N[(2.0 * N[Abs[N[(F / B$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision])]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 7.5 \cdot 10^{+109}:\\
\;\;\;\;-\sqrt{\frac{F}{-A}}\\
\mathbf{else}:\\
\;\;\;\;-\sqrt{2 \cdot \left|\frac{F}{B\_m}\right|}\\
\end{array}
\end{array}
if B < 7.50000000000000018e109Initial program 23.1%
Simplified31.1%
Taylor expanded in A around -inf 20.8%
Taylor expanded in F around 0 13.8%
Taylor expanded in B around 0 18.5%
associate-*r/18.5%
neg-mul-118.5%
Simplified18.5%
if 7.50000000000000018e109 < B Initial program 0.2%
Taylor expanded in B around inf 52.8%
mul-1-neg52.8%
*-commutative52.8%
Simplified52.8%
*-commutative52.8%
pow1/252.8%
pow1/252.8%
pow-prod-down53.2%
Applied egg-rr53.2%
unpow1/253.2%
Simplified53.2%
add-sqr-sqrt52.8%
pow1/252.8%
pow1/252.8%
pow-prod-down38.6%
pow238.6%
Applied egg-rr38.6%
unpow1/238.6%
unpow238.6%
rem-sqrt-square53.2%
Simplified53.2%
Final simplification24.4%
B_m = (fabs.f64 B) NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. (FPCore (A B_m C F) :precision binary64 (if (<= B_m 5.8e+110) (- (sqrt (/ F (- A)))) (- (sqrt (* F (/ 2.0 B_m))))))
B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 5.8e+110) {
tmp = -sqrt((F / -A));
} else {
tmp = -sqrt((F * (2.0 / B_m)));
}
return tmp;
}
B_m = abs(b)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
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 <= 5.8d+110) then
tmp = -sqrt((f / -a))
else
tmp = -sqrt((f * (2.0d0 / b_m)))
end if
code = tmp
end function
B_m = Math.abs(B);
assert A < B_m && B_m < C && C < F;
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 5.8e+110) {
tmp = -Math.sqrt((F / -A));
} else {
tmp = -Math.sqrt((F * (2.0 / B_m)));
}
return tmp;
}
B_m = math.fabs(B) [A, B_m, C, F] = sort([A, B_m, C, F]) def code(A, B_m, C, F): tmp = 0 if B_m <= 5.8e+110: tmp = -math.sqrt((F / -A)) else: tmp = -math.sqrt((F * (2.0 / B_m))) return tmp
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 5.8e+110) tmp = Float64(-sqrt(Float64(F / Float64(-A)))); else tmp = Float64(-sqrt(Float64(F * Float64(2.0 / B_m)))); end return tmp end
B_m = abs(B);
A, B_m, C, F = num2cell(sort([A, B_m, C, F])){:}
function tmp_2 = code(A, B_m, C, F)
tmp = 0.0;
if (B_m <= 5.8e+110)
tmp = -sqrt((F / -A));
else
tmp = -sqrt((F * (2.0 / B_m)));
end
tmp_2 = tmp;
end
B_m = N[Abs[B], $MachinePrecision] NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 5.8e+110], (-N[Sqrt[N[(F / (-A)), $MachinePrecision]], $MachinePrecision]), (-N[Sqrt[N[(F * N[(2.0 / B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 5.8 \cdot 10^{+110}:\\
\;\;\;\;-\sqrt{\frac{F}{-A}}\\
\mathbf{else}:\\
\;\;\;\;-\sqrt{F \cdot \frac{2}{B\_m}}\\
\end{array}
\end{array}
if B < 5.7999999999999999e110Initial program 23.1%
Simplified31.1%
Taylor expanded in A around -inf 20.8%
Taylor expanded in F around 0 13.8%
Taylor expanded in B around 0 18.5%
associate-*r/18.5%
neg-mul-118.5%
Simplified18.5%
if 5.7999999999999999e110 < B Initial program 0.2%
Taylor expanded in B around inf 52.8%
mul-1-neg52.8%
*-commutative52.8%
Simplified52.8%
*-commutative52.8%
pow1/252.8%
pow1/252.8%
pow-prod-down53.2%
Applied egg-rr53.2%
unpow1/253.2%
Simplified53.2%
associate-*l/53.2%
Applied egg-rr53.2%
associate-/l*53.2%
Applied egg-rr53.2%
Final simplification24.4%
B_m = (fabs.f64 B) NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. (FPCore (A B_m C F) :precision binary64 (- (sqrt (* F (/ 2.0 B_m)))))
B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
return -sqrt((F * (2.0 / B_m)));
}
B_m = abs(b)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
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 = -sqrt((f * (2.0d0 / b_m)))
end function
B_m = Math.abs(B);
assert A < B_m && B_m < C && C < F;
public static double code(double A, double B_m, double C, double F) {
return -Math.sqrt((F * (2.0 / B_m)));
}
B_m = math.fabs(B) [A, B_m, C, F] = sort([A, B_m, C, F]) def code(A, B_m, C, F): return -math.sqrt((F * (2.0 / B_m)))
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) return Float64(-sqrt(Float64(F * Float64(2.0 / B_m)))) end
B_m = abs(B);
A, B_m, C, F = num2cell(sort([A, B_m, C, F])){:}
function tmp = code(A, B_m, C, F)
tmp = -sqrt((F * (2.0 / B_m)));
end
B_m = N[Abs[B], $MachinePrecision] NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. code[A_, B$95$m_, C_, F_] := (-N[Sqrt[N[(F * N[(2.0 / B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision])
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
-\sqrt{F \cdot \frac{2}{B\_m}}
\end{array}
Initial program 19.3%
Taylor expanded in B around inf 11.3%
mul-1-neg11.3%
*-commutative11.3%
Simplified11.3%
*-commutative11.3%
pow1/211.5%
pow1/211.5%
pow-prod-down11.5%
Applied egg-rr11.5%
unpow1/211.4%
Simplified11.4%
associate-*l/11.4%
Applied egg-rr11.4%
associate-/l*11.4%
Applied egg-rr11.4%
herbie shell --seed 2024180
(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))))