
(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 19 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 (* C (* A 4.0)))
(t_1 (- t_0 (pow B_m 2.0)))
(t_2 (fma (* C A) -4.0 (* B_m B_m)))
(t_3 (/ (* B_m B_m) A))
(t_4 (- (sqrt F)))
(t_5
(/
(sqrt
(*
(+ (+ C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))
(* (* F (- (pow B_m 2.0) t_0)) 2.0)))
t_1))
(t_6 (fma -4.0 (* C A) (* B_m B_m)))
(t_7 (- t_6))
(t_8 (* t_2 2.0)))
(if (<= t_5 (- INFINITY))
(* (/ (sqrt (+ (fma -0.5 t_3 C) C)) t_7) (* (sqrt t_2) (sqrt (* F 2.0))))
(if (<= t_5 -1e-204)
(* (* t_4 (sqrt t_8)) (/ (sqrt (+ (+ (hypot (- A C) B_m) A) C)) t_6))
(if (<= t_5 0.0)
(/ (* (sqrt (* (fma t_3 -0.5 (* C 2.0)) t_8)) (sqrt F)) t_1)
(if (<= t_5 INFINITY)
(*
(sqrt (* (* F 2.0) t_6))
(/ (sqrt (+ (* (fma 0.0 (/ A C) 1.0) C) C)) t_7))
(/ t_4 (sqrt (* 0.5 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 = C * (A * 4.0);
double t_1 = t_0 - pow(B_m, 2.0);
double t_2 = fma((C * A), -4.0, (B_m * B_m));
double t_3 = (B_m * B_m) / A;
double t_4 = -sqrt(F);
double t_5 = sqrt((((C + A) + sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))) * ((F * (pow(B_m, 2.0) - t_0)) * 2.0))) / t_1;
double t_6 = fma(-4.0, (C * A), (B_m * B_m));
double t_7 = -t_6;
double t_8 = t_2 * 2.0;
double tmp;
if (t_5 <= -((double) INFINITY)) {
tmp = (sqrt((fma(-0.5, t_3, C) + C)) / t_7) * (sqrt(t_2) * sqrt((F * 2.0)));
} else if (t_5 <= -1e-204) {
tmp = (t_4 * sqrt(t_8)) * (sqrt(((hypot((A - C), B_m) + A) + C)) / t_6);
} else if (t_5 <= 0.0) {
tmp = (sqrt((fma(t_3, -0.5, (C * 2.0)) * t_8)) * sqrt(F)) / t_1;
} else if (t_5 <= ((double) INFINITY)) {
tmp = sqrt(((F * 2.0) * t_6)) * (sqrt(((fma(0.0, (A / C), 1.0) * C) + C)) / t_7);
} else {
tmp = t_4 / sqrt((0.5 * 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(C * Float64(A * 4.0)) t_1 = Float64(t_0 - (B_m ^ 2.0)) t_2 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) t_3 = Float64(Float64(B_m * B_m) / A) t_4 = Float64(-sqrt(F)) t_5 = Float64(sqrt(Float64(Float64(Float64(C + A) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_0)) * 2.0))) / t_1) t_6 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_7 = Float64(-t_6) t_8 = Float64(t_2 * 2.0) tmp = 0.0 if (t_5 <= Float64(-Inf)) tmp = Float64(Float64(sqrt(Float64(fma(-0.5, t_3, C) + C)) / t_7) * Float64(sqrt(t_2) * sqrt(Float64(F * 2.0)))); elseif (t_5 <= -1e-204) tmp = Float64(Float64(t_4 * sqrt(t_8)) * Float64(sqrt(Float64(Float64(hypot(Float64(A - C), B_m) + A) + C)) / t_6)); elseif (t_5 <= 0.0) tmp = Float64(Float64(sqrt(Float64(fma(t_3, -0.5, Float64(C * 2.0)) * t_8)) * sqrt(F)) / t_1); elseif (t_5 <= Inf) tmp = Float64(sqrt(Float64(Float64(F * 2.0) * t_6)) * Float64(sqrt(Float64(Float64(fma(0.0, Float64(A / C), 1.0) * C) + C)) / t_7)); else tmp = Float64(t_4 / sqrt(Float64(0.5 * 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[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision]}, Block[{t$95$4 = (-N[Sqrt[F], $MachinePrecision])}, Block[{t$95$5 = N[(N[Sqrt[N[(N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision]}, Block[{t$95$6 = N[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$7 = (-t$95$6)}, Block[{t$95$8 = N[(t$95$2 * 2.0), $MachinePrecision]}, If[LessEqual[t$95$5, (-Infinity)], N[(N[(N[Sqrt[N[(N[(-0.5 * t$95$3 + C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$7), $MachinePrecision] * N[(N[Sqrt[t$95$2], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$5, -1e-204], N[(N[(t$95$4 * N[Sqrt[t$95$8], $MachinePrecision]), $MachinePrecision] * N[(N[Sqrt[N[(N[(N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision] + A), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$6), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$5, 0.0], N[(N[(N[Sqrt[N[(N[(t$95$3 * -0.5 + N[(C * 2.0), $MachinePrecision]), $MachinePrecision] * t$95$8), $MachinePrecision]], $MachinePrecision] * N[Sqrt[F], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[t$95$5, Infinity], N[(N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] * t$95$6), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[N[(N[(N[(0.0 * N[(A / C), $MachinePrecision] + 1.0), $MachinePrecision] * C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$7), $MachinePrecision]), $MachinePrecision], N[(t$95$4 / N[Sqrt[N[(0.5 * 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 := C \cdot \left(A \cdot 4\right)\\
t_1 := t\_0 - {B\_m}^{2}\\
t_2 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
t_3 := \frac{B\_m \cdot B\_m}{A}\\
t_4 := -\sqrt{F}\\
t_5 := \frac{\sqrt{\left(\left(C + A\right) + \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_0\right)\right) \cdot 2\right)}}{t\_1}\\
t_6 := \mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_7 := -t\_6\\
t_8 := t\_2 \cdot 2\\
\mathbf{if}\;t\_5 \leq -\infty:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(-0.5, t\_3, C\right) + C}}{t\_7} \cdot \left(\sqrt{t\_2} \cdot \sqrt{F \cdot 2}\right)\\
\mathbf{elif}\;t\_5 \leq -1 \cdot 10^{-204}:\\
\;\;\;\;\left(t\_4 \cdot \sqrt{t\_8}\right) \cdot \frac{\sqrt{\left(\mathsf{hypot}\left(A - C, B\_m\right) + A\right) + C}}{t\_6}\\
\mathbf{elif}\;t\_5 \leq 0:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(t\_3, -0.5, C \cdot 2\right) \cdot t\_8} \cdot \sqrt{F}}{t\_1}\\
\mathbf{elif}\;t\_5 \leq \infty:\\
\;\;\;\;\sqrt{\left(F \cdot 2\right) \cdot t\_6} \cdot \frac{\sqrt{\mathsf{fma}\left(0, \frac{A}{C}, 1\right) \cdot C + C}}{t\_7}\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_4}{\sqrt{0.5 \cdot B\_m}}\\
\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))) < -inf.0Initial program 3.0%
Applied rewrites32.8%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites51.9%
Taylor expanded in A around -inf
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6447.0
Applied rewrites47.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))) < -1e-204Initial program 99.1%
Applied rewrites99.2%
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
associate-*l*N/A
*-commutativeN/A
Applied rewrites99.3%
if -1e-204 < (/.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))) < -0.0Initial program 3.6%
Taylor expanded in A around -inf
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6422.6
Applied rewrites22.6%
lift-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*r*N/A
Applied rewrites21.7%
if -0.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))) < +inf.0Initial program 36.7%
Applied rewrites86.5%
Taylor expanded in C around inf
lower-*.f64N/A
+-commutativeN/A
distribute-lft1-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-/.f6447.4
Applied rewrites47.4%
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
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.3
Applied rewrites15.3%
Applied rewrites15.4%
Applied rewrites15.4%
Applied rewrites21.3%
Final simplification42.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 (/ (* B_m B_m) A))
(t_1 (fma -4.0 (* C A) (* B_m B_m)))
(t_2 (* C (* A 4.0)))
(t_3 (fma (* C A) -4.0 (* B_m B_m)))
(t_4 (sqrt (* F 2.0)))
(t_5 (- t_1))
(t_6 (- t_2 (pow B_m 2.0)))
(t_7
(/
(sqrt
(*
(+ (+ C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))
(* (* F (- (pow B_m 2.0) t_2)) 2.0)))
t_6))
(t_8 (sqrt t_3)))
(if (<= t_7 (- INFINITY))
(* (/ (sqrt (+ (fma -0.5 t_0 C) C)) t_5) (* t_8 t_4))
(if (<= t_7 -1e-204)
(* (/ (sqrt (+ (+ (hypot (- A C) B_m) A) C)) t_1) (* (- t_8) t_4))
(if (<= t_7 0.0)
(/ (* (sqrt (* (fma t_0 -0.5 (* C 2.0)) (* t_3 2.0))) (sqrt F)) t_6)
(if (<= t_7 INFINITY)
(*
(sqrt (* (* F 2.0) t_1))
(/ (sqrt (+ (* (fma 0.0 (/ A C) 1.0) C) C)) t_5))
(/ (- (sqrt F)) (sqrt (* 0.5 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 = (B_m * B_m) / A;
double t_1 = fma(-4.0, (C * A), (B_m * B_m));
double t_2 = C * (A * 4.0);
double t_3 = fma((C * A), -4.0, (B_m * B_m));
double t_4 = sqrt((F * 2.0));
double t_5 = -t_1;
double t_6 = t_2 - pow(B_m, 2.0);
double t_7 = sqrt((((C + A) + sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))) * ((F * (pow(B_m, 2.0) - t_2)) * 2.0))) / t_6;
double t_8 = sqrt(t_3);
double tmp;
if (t_7 <= -((double) INFINITY)) {
tmp = (sqrt((fma(-0.5, t_0, C) + C)) / t_5) * (t_8 * t_4);
} else if (t_7 <= -1e-204) {
tmp = (sqrt(((hypot((A - C), B_m) + A) + C)) / t_1) * (-t_8 * t_4);
} else if (t_7 <= 0.0) {
tmp = (sqrt((fma(t_0, -0.5, (C * 2.0)) * (t_3 * 2.0))) * sqrt(F)) / t_6;
} else if (t_7 <= ((double) INFINITY)) {
tmp = sqrt(((F * 2.0) * t_1)) * (sqrt(((fma(0.0, (A / C), 1.0) * C) + C)) / t_5);
} else {
tmp = -sqrt(F) / sqrt((0.5 * 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(Float64(B_m * B_m) / A) t_1 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_2 = Float64(C * Float64(A * 4.0)) t_3 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) t_4 = sqrt(Float64(F * 2.0)) t_5 = Float64(-t_1) t_6 = Float64(t_2 - (B_m ^ 2.0)) t_7 = Float64(sqrt(Float64(Float64(Float64(C + A) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_2)) * 2.0))) / t_6) t_8 = sqrt(t_3) tmp = 0.0 if (t_7 <= Float64(-Inf)) tmp = Float64(Float64(sqrt(Float64(fma(-0.5, t_0, C) + C)) / t_5) * Float64(t_8 * t_4)); elseif (t_7 <= -1e-204) tmp = Float64(Float64(sqrt(Float64(Float64(hypot(Float64(A - C), B_m) + A) + C)) / t_1) * Float64(Float64(-t_8) * t_4)); elseif (t_7 <= 0.0) tmp = Float64(Float64(sqrt(Float64(fma(t_0, -0.5, Float64(C * 2.0)) * Float64(t_3 * 2.0))) * sqrt(F)) / t_6); elseif (t_7 <= Inf) tmp = Float64(sqrt(Float64(Float64(F * 2.0) * t_1)) * Float64(sqrt(Float64(Float64(fma(0.0, Float64(A / C), 1.0) * C) + C)) / t_5)); else tmp = Float64(Float64(-sqrt(F)) / sqrt(Float64(0.5 * 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[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision]}, Block[{t$95$1 = N[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$5 = (-t$95$1)}, Block[{t$95$6 = N[(t$95$2 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$7 = N[(N[Sqrt[N[(N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$2), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$6), $MachinePrecision]}, Block[{t$95$8 = N[Sqrt[t$95$3], $MachinePrecision]}, If[LessEqual[t$95$7, (-Infinity)], N[(N[(N[Sqrt[N[(N[(-0.5 * t$95$0 + C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$5), $MachinePrecision] * N[(t$95$8 * t$95$4), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$7, -1e-204], N[(N[(N[Sqrt[N[(N[(N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision] + A), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision] * N[((-t$95$8) * t$95$4), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$7, 0.0], N[(N[(N[Sqrt[N[(N[(t$95$0 * -0.5 + N[(C * 2.0), $MachinePrecision]), $MachinePrecision] * N[(t$95$3 * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[F], $MachinePrecision]), $MachinePrecision] / t$95$6), $MachinePrecision], If[LessEqual[t$95$7, Infinity], N[(N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] * t$95$1), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[N[(N[(N[(0.0 * N[(A / C), $MachinePrecision] + 1.0), $MachinePrecision] * C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$5), $MachinePrecision]), $MachinePrecision], N[((-N[Sqrt[F], $MachinePrecision]) / N[Sqrt[N[(0.5 * 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 \cdot B\_m}{A}\\
t_1 := \mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_2 := C \cdot \left(A \cdot 4\right)\\
t_3 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
t_4 := \sqrt{F \cdot 2}\\
t_5 := -t\_1\\
t_6 := t\_2 - {B\_m}^{2}\\
t_7 := \frac{\sqrt{\left(\left(C + A\right) + \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_2\right)\right) \cdot 2\right)}}{t\_6}\\
t_8 := \sqrt{t\_3}\\
\mathbf{if}\;t\_7 \leq -\infty:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(-0.5, t\_0, C\right) + C}}{t\_5} \cdot \left(t\_8 \cdot t\_4\right)\\
\mathbf{elif}\;t\_7 \leq -1 \cdot 10^{-204}:\\
\;\;\;\;\frac{\sqrt{\left(\mathsf{hypot}\left(A - C, B\_m\right) + A\right) + C}}{t\_1} \cdot \left(\left(-t\_8\right) \cdot t\_4\right)\\
\mathbf{elif}\;t\_7 \leq 0:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(t\_0, -0.5, C \cdot 2\right) \cdot \left(t\_3 \cdot 2\right)} \cdot \sqrt{F}}{t\_6}\\
\mathbf{elif}\;t\_7 \leq \infty:\\
\;\;\;\;\sqrt{\left(F \cdot 2\right) \cdot t\_1} \cdot \frac{\sqrt{\mathsf{fma}\left(0, \frac{A}{C}, 1\right) \cdot C + C}}{t\_5}\\
\mathbf{else}:\\
\;\;\;\;\frac{-\sqrt{F}}{\sqrt{0.5 \cdot B\_m}}\\
\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))) < -inf.0Initial program 3.0%
Applied rewrites32.8%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites51.9%
Taylor expanded in A around -inf
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6447.0
Applied rewrites47.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))) < -1e-204Initial program 99.1%
Applied rewrites99.2%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites99.2%
if -1e-204 < (/.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))) < -0.0Initial program 3.6%
Taylor expanded in A around -inf
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6422.6
Applied rewrites22.6%
lift-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*r*N/A
Applied rewrites21.7%
if -0.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))) < +inf.0Initial program 36.7%
Applied rewrites86.5%
Taylor expanded in C around inf
lower-*.f64N/A
+-commutativeN/A
distribute-lft1-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-/.f6447.4
Applied rewrites47.4%
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
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.3
Applied rewrites15.3%
Applied rewrites15.4%
Applied rewrites15.4%
Applied rewrites21.3%
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 (/ (* B_m B_m) A))
(t_1 (fma -4.0 (* C A) (* B_m B_m)))
(t_2 (* C (* A 4.0)))
(t_3 (fma (* C A) -4.0 (* B_m B_m)))
(t_4 (sqrt t_3))
(t_5 (sqrt (* F 2.0)))
(t_6
(/
(sqrt
(*
(+ (+ C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))
(* (* F (- (pow B_m 2.0) t_2)) 2.0)))
(- t_2 (pow B_m 2.0))))
(t_7 (- t_1)))
(if (<= t_6 (- INFINITY))
(* (/ (sqrt (+ (fma -0.5 t_0 C) C)) t_7) (* t_4 t_5))
(if (<= t_6 -2e-177)
(* (/ (sqrt (+ (+ (hypot (- A C) B_m) A) C)) t_1) (* (- t_4) t_5))
(if (<= t_6 0.0)
(/ (sqrt (* (* (* t_3 F) 2.0) (fma t_0 -0.5 (* C 2.0)))) (- t_3))
(if (<= t_6 INFINITY)
(*
(sqrt (* (* F 2.0) t_1))
(/ (sqrt (+ (* (fma 0.0 (/ A C) 1.0) C) C)) t_7))
(/ (- (sqrt F)) (sqrt (* 0.5 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 = (B_m * B_m) / A;
double t_1 = fma(-4.0, (C * A), (B_m * B_m));
double t_2 = C * (A * 4.0);
double t_3 = fma((C * A), -4.0, (B_m * B_m));
double t_4 = sqrt(t_3);
double t_5 = sqrt((F * 2.0));
double t_6 = sqrt((((C + A) + sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))) * ((F * (pow(B_m, 2.0) - t_2)) * 2.0))) / (t_2 - pow(B_m, 2.0));
double t_7 = -t_1;
double tmp;
if (t_6 <= -((double) INFINITY)) {
tmp = (sqrt((fma(-0.5, t_0, C) + C)) / t_7) * (t_4 * t_5);
} else if (t_6 <= -2e-177) {
tmp = (sqrt(((hypot((A - C), B_m) + A) + C)) / t_1) * (-t_4 * t_5);
} else if (t_6 <= 0.0) {
tmp = sqrt((((t_3 * F) * 2.0) * fma(t_0, -0.5, (C * 2.0)))) / -t_3;
} else if (t_6 <= ((double) INFINITY)) {
tmp = sqrt(((F * 2.0) * t_1)) * (sqrt(((fma(0.0, (A / C), 1.0) * C) + C)) / t_7);
} else {
tmp = -sqrt(F) / sqrt((0.5 * 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(Float64(B_m * B_m) / A) t_1 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_2 = Float64(C * Float64(A * 4.0)) t_3 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) t_4 = sqrt(t_3) t_5 = sqrt(Float64(F * 2.0)) t_6 = Float64(sqrt(Float64(Float64(Float64(C + A) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_2)) * 2.0))) / Float64(t_2 - (B_m ^ 2.0))) t_7 = Float64(-t_1) tmp = 0.0 if (t_6 <= Float64(-Inf)) tmp = Float64(Float64(sqrt(Float64(fma(-0.5, t_0, C) + C)) / t_7) * Float64(t_4 * t_5)); elseif (t_6 <= -2e-177) tmp = Float64(Float64(sqrt(Float64(Float64(hypot(Float64(A - C), B_m) + A) + C)) / t_1) * Float64(Float64(-t_4) * t_5)); elseif (t_6 <= 0.0) tmp = Float64(sqrt(Float64(Float64(Float64(t_3 * F) * 2.0) * fma(t_0, -0.5, Float64(C * 2.0)))) / Float64(-t_3)); elseif (t_6 <= Inf) tmp = Float64(sqrt(Float64(Float64(F * 2.0) * t_1)) * Float64(sqrt(Float64(Float64(fma(0.0, Float64(A / C), 1.0) * C) + C)) / t_7)); else tmp = Float64(Float64(-sqrt(F)) / sqrt(Float64(0.5 * 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[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision]}, Block[{t$95$1 = N[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[Sqrt[t$95$3], $MachinePrecision]}, Block[{t$95$5 = N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$6 = N[(N[Sqrt[N[(N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$2), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$2 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$7 = (-t$95$1)}, If[LessEqual[t$95$6, (-Infinity)], N[(N[(N[Sqrt[N[(N[(-0.5 * t$95$0 + C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$7), $MachinePrecision] * N[(t$95$4 * t$95$5), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$6, -2e-177], N[(N[(N[Sqrt[N[(N[(N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision] + A), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision] * N[((-t$95$4) * t$95$5), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$6, 0.0], N[(N[Sqrt[N[(N[(N[(t$95$3 * F), $MachinePrecision] * 2.0), $MachinePrecision] * N[(t$95$0 * -0.5 + N[(C * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$3)), $MachinePrecision], If[LessEqual[t$95$6, Infinity], N[(N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] * t$95$1), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[N[(N[(N[(0.0 * N[(A / C), $MachinePrecision] + 1.0), $MachinePrecision] * C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$7), $MachinePrecision]), $MachinePrecision], N[((-N[Sqrt[F], $MachinePrecision]) / N[Sqrt[N[(0.5 * 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 \cdot B\_m}{A}\\
t_1 := \mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_2 := C \cdot \left(A \cdot 4\right)\\
t_3 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
t_4 := \sqrt{t\_3}\\
t_5 := \sqrt{F \cdot 2}\\
t_6 := \frac{\sqrt{\left(\left(C + A\right) + \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_2\right)\right) \cdot 2\right)}}{t\_2 - {B\_m}^{2}}\\
t_7 := -t\_1\\
\mathbf{if}\;t\_6 \leq -\infty:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(-0.5, t\_0, C\right) + C}}{t\_7} \cdot \left(t\_4 \cdot t\_5\right)\\
\mathbf{elif}\;t\_6 \leq -2 \cdot 10^{-177}:\\
\;\;\;\;\frac{\sqrt{\left(\mathsf{hypot}\left(A - C, B\_m\right) + A\right) + C}}{t\_1} \cdot \left(\left(-t\_4\right) \cdot t\_5\right)\\
\mathbf{elif}\;t\_6 \leq 0:\\
\;\;\;\;\frac{\sqrt{\left(\left(t\_3 \cdot F\right) \cdot 2\right) \cdot \mathsf{fma}\left(t\_0, -0.5, C \cdot 2\right)}}{-t\_3}\\
\mathbf{elif}\;t\_6 \leq \infty:\\
\;\;\;\;\sqrt{\left(F \cdot 2\right) \cdot t\_1} \cdot \frac{\sqrt{\mathsf{fma}\left(0, \frac{A}{C}, 1\right) \cdot C + C}}{t\_7}\\
\mathbf{else}:\\
\;\;\;\;\frac{-\sqrt{F}}{\sqrt{0.5 \cdot B\_m}}\\
\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))) < -inf.0Initial program 3.0%
Applied rewrites32.8%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites51.9%
Taylor expanded in A around -inf
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6447.0
Applied rewrites47.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))) < -1.9999999999999999e-177Initial program 99.1%
Applied rewrites99.1%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites99.2%
if -1.9999999999999999e-177 < (/.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))) < -0.0Initial program 6.2%
Taylor expanded in A around -inf
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6424.7
Applied rewrites24.7%
Applied rewrites24.7%
if -0.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))) < +inf.0Initial program 36.7%
Applied rewrites86.5%
Taylor expanded in C around inf
lower-*.f64N/A
+-commutativeN/A
distribute-lft1-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-/.f6447.4
Applied rewrites47.4%
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
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.3
Applied rewrites15.3%
Applied rewrites15.4%
Applied rewrites15.4%
Applied rewrites21.3%
Final simplification42.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
(let* ((t_0 (/ (* B_m B_m) A))
(t_1 (fma -4.0 (* C A) (* B_m B_m)))
(t_2 (* C (* A 4.0)))
(t_3 (fma (* C A) -4.0 (* B_m B_m)))
(t_4
(/
(sqrt
(*
(+ (+ C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))
(* (* F (- (pow B_m 2.0) t_2)) 2.0)))
(- t_2 (pow B_m 2.0))))
(t_5 (- t_1)))
(if (<= t_4 (- INFINITY))
(* (/ (sqrt (+ (fma -0.5 t_0 C) C)) t_5) (* (sqrt t_3) (sqrt (* F 2.0))))
(if (<= t_4 -1e-204)
(*
(/ (- (sqrt 2.0)) (fma B_m B_m (* -4.0 (* C A))))
(sqrt (* (* (+ (+ (hypot B_m (- A C)) C) A) F) t_1)))
(if (<= t_4 0.0)
(/ (sqrt (* (* (* t_3 F) 2.0) (fma t_0 -0.5 (* C 2.0)))) (- t_3))
(if (<= t_4 INFINITY)
(*
(sqrt (* (* F 2.0) t_1))
(/ (sqrt (+ (* (fma 0.0 (/ A C) 1.0) C) C)) t_5))
(/ (- (sqrt F)) (sqrt (* 0.5 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 = (B_m * B_m) / A;
double t_1 = fma(-4.0, (C * A), (B_m * B_m));
double t_2 = C * (A * 4.0);
double t_3 = fma((C * A), -4.0, (B_m * B_m));
double t_4 = sqrt((((C + A) + sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))) * ((F * (pow(B_m, 2.0) - t_2)) * 2.0))) / (t_2 - pow(B_m, 2.0));
double t_5 = -t_1;
double tmp;
if (t_4 <= -((double) INFINITY)) {
tmp = (sqrt((fma(-0.5, t_0, C) + C)) / t_5) * (sqrt(t_3) * sqrt((F * 2.0)));
} else if (t_4 <= -1e-204) {
tmp = (-sqrt(2.0) / fma(B_m, B_m, (-4.0 * (C * A)))) * sqrt(((((hypot(B_m, (A - C)) + C) + A) * F) * t_1));
} else if (t_4 <= 0.0) {
tmp = sqrt((((t_3 * F) * 2.0) * fma(t_0, -0.5, (C * 2.0)))) / -t_3;
} else if (t_4 <= ((double) INFINITY)) {
tmp = sqrt(((F * 2.0) * t_1)) * (sqrt(((fma(0.0, (A / C), 1.0) * C) + C)) / t_5);
} else {
tmp = -sqrt(F) / sqrt((0.5 * 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(Float64(B_m * B_m) / A) t_1 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_2 = Float64(C * Float64(A * 4.0)) t_3 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) t_4 = Float64(sqrt(Float64(Float64(Float64(C + A) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_2)) * 2.0))) / Float64(t_2 - (B_m ^ 2.0))) t_5 = Float64(-t_1) tmp = 0.0 if (t_4 <= Float64(-Inf)) tmp = Float64(Float64(sqrt(Float64(fma(-0.5, t_0, C) + C)) / t_5) * Float64(sqrt(t_3) * sqrt(Float64(F * 2.0)))); elseif (t_4 <= -1e-204) tmp = Float64(Float64(Float64(-sqrt(2.0)) / fma(B_m, B_m, Float64(-4.0 * Float64(C * A)))) * sqrt(Float64(Float64(Float64(Float64(hypot(B_m, Float64(A - C)) + C) + A) * F) * t_1))); elseif (t_4 <= 0.0) tmp = Float64(sqrt(Float64(Float64(Float64(t_3 * F) * 2.0) * fma(t_0, -0.5, Float64(C * 2.0)))) / Float64(-t_3)); elseif (t_4 <= Inf) tmp = Float64(sqrt(Float64(Float64(F * 2.0) * t_1)) * Float64(sqrt(Float64(Float64(fma(0.0, Float64(A / C), 1.0) * C) + C)) / t_5)); else tmp = Float64(Float64(-sqrt(F)) / sqrt(Float64(0.5 * 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[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision]}, Block[{t$95$1 = N[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[Sqrt[N[(N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$2), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$2 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = (-t$95$1)}, If[LessEqual[t$95$4, (-Infinity)], N[(N[(N[Sqrt[N[(N[(-0.5 * t$95$0 + C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$5), $MachinePrecision] * N[(N[Sqrt[t$95$3], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, -1e-204], N[(N[((-N[Sqrt[2.0], $MachinePrecision]) / N[(B$95$m * B$95$m + N[(-4.0 * N[(C * A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[(N[(N[(N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision] + C), $MachinePrecision] + A), $MachinePrecision] * F), $MachinePrecision] * t$95$1), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, 0.0], N[(N[Sqrt[N[(N[(N[(t$95$3 * F), $MachinePrecision] * 2.0), $MachinePrecision] * N[(t$95$0 * -0.5 + N[(C * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$3)), $MachinePrecision], If[LessEqual[t$95$4, Infinity], N[(N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] * t$95$1), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[N[(N[(N[(0.0 * N[(A / C), $MachinePrecision] + 1.0), $MachinePrecision] * C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$5), $MachinePrecision]), $MachinePrecision], N[((-N[Sqrt[F], $MachinePrecision]) / N[Sqrt[N[(0.5 * 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 \cdot B\_m}{A}\\
t_1 := \mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_2 := C \cdot \left(A \cdot 4\right)\\
t_3 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
t_4 := \frac{\sqrt{\left(\left(C + A\right) + \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_2\right)\right) \cdot 2\right)}}{t\_2 - {B\_m}^{2}}\\
t_5 := -t\_1\\
\mathbf{if}\;t\_4 \leq -\infty:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(-0.5, t\_0, C\right) + C}}{t\_5} \cdot \left(\sqrt{t\_3} \cdot \sqrt{F \cdot 2}\right)\\
\mathbf{elif}\;t\_4 \leq -1 \cdot 10^{-204}:\\
\;\;\;\;\frac{-\sqrt{2}}{\mathsf{fma}\left(B\_m, B\_m, -4 \cdot \left(C \cdot A\right)\right)} \cdot \sqrt{\left(\left(\left(\mathsf{hypot}\left(B\_m, A - C\right) + C\right) + A\right) \cdot F\right) \cdot t\_1}\\
\mathbf{elif}\;t\_4 \leq 0:\\
\;\;\;\;\frac{\sqrt{\left(\left(t\_3 \cdot F\right) \cdot 2\right) \cdot \mathsf{fma}\left(t\_0, -0.5, C \cdot 2\right)}}{-t\_3}\\
\mathbf{elif}\;t\_4 \leq \infty:\\
\;\;\;\;\sqrt{\left(F \cdot 2\right) \cdot t\_1} \cdot \frac{\sqrt{\mathsf{fma}\left(0, \frac{A}{C}, 1\right) \cdot C + C}}{t\_5}\\
\mathbf{else}:\\
\;\;\;\;\frac{-\sqrt{F}}{\sqrt{0.5 \cdot B\_m}}\\
\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))) < -inf.0Initial program 3.0%
Applied rewrites32.8%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites51.9%
Taylor expanded in A around -inf
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6447.0
Applied rewrites47.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))) < -1e-204Initial program 99.1%
Taylor expanded in A around -inf
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6422.9
Applied rewrites22.9%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
Applied rewrites23.1%
Taylor expanded in F around 0
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
Applied rewrites99.2%
if -1e-204 < (/.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))) < -0.0Initial program 3.6%
Taylor expanded in A around -inf
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6422.6
Applied rewrites22.6%
Applied rewrites22.6%
if -0.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))) < +inf.0Initial program 36.7%
Applied rewrites86.5%
Taylor expanded in C around inf
lower-*.f64N/A
+-commutativeN/A
distribute-lft1-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-/.f6447.4
Applied rewrites47.4%
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
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.3
Applied rewrites15.3%
Applied rewrites15.4%
Applied rewrites15.4%
Applied rewrites21.3%
Final simplification42.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
(let* ((t_0 (/ (* B_m B_m) A))
(t_1 (fma -4.0 (* C A) (* B_m B_m)))
(t_2 (* (* F 2.0) t_1))
(t_3 (* C (* A 4.0)))
(t_4 (fma (* C A) -4.0 (* B_m B_m)))
(t_5
(/
(sqrt
(*
(+ (+ C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))
(* (* F (- (pow B_m 2.0) t_3)) 2.0)))
(- t_3 (pow B_m 2.0))))
(t_6 (- t_1)))
(if (<= t_5 (- INFINITY))
(* (/ (sqrt (+ (fma -0.5 t_0 C) C)) t_6) (* (sqrt t_4) (sqrt (* F 2.0))))
(if (<= t_5 -2e-177)
(/ (sqrt (* t_2 (+ (+ (hypot (- A C) B_m) A) C))) t_6)
(if (<= t_5 0.0)
(/ (sqrt (* (* (* t_4 F) 2.0) (fma t_0 -0.5 (* C 2.0)))) (- t_4))
(if (<= t_5 INFINITY)
(* (sqrt t_2) (/ (sqrt (+ (* (fma 0.0 (/ A C) 1.0) C) C)) t_6))
(/ (- (sqrt F)) (sqrt (* 0.5 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 = (B_m * B_m) / A;
double t_1 = fma(-4.0, (C * A), (B_m * B_m));
double t_2 = (F * 2.0) * t_1;
double t_3 = C * (A * 4.0);
double t_4 = fma((C * A), -4.0, (B_m * B_m));
double t_5 = sqrt((((C + A) + sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))) * ((F * (pow(B_m, 2.0) - t_3)) * 2.0))) / (t_3 - pow(B_m, 2.0));
double t_6 = -t_1;
double tmp;
if (t_5 <= -((double) INFINITY)) {
tmp = (sqrt((fma(-0.5, t_0, C) + C)) / t_6) * (sqrt(t_4) * sqrt((F * 2.0)));
} else if (t_5 <= -2e-177) {
tmp = sqrt((t_2 * ((hypot((A - C), B_m) + A) + C))) / t_6;
} else if (t_5 <= 0.0) {
tmp = sqrt((((t_4 * F) * 2.0) * fma(t_0, -0.5, (C * 2.0)))) / -t_4;
} else if (t_5 <= ((double) INFINITY)) {
tmp = sqrt(t_2) * (sqrt(((fma(0.0, (A / C), 1.0) * C) + C)) / t_6);
} else {
tmp = -sqrt(F) / sqrt((0.5 * 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(Float64(B_m * B_m) / A) t_1 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_2 = Float64(Float64(F * 2.0) * t_1) t_3 = Float64(C * Float64(A * 4.0)) t_4 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) t_5 = Float64(sqrt(Float64(Float64(Float64(C + A) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_3)) * 2.0))) / Float64(t_3 - (B_m ^ 2.0))) t_6 = Float64(-t_1) tmp = 0.0 if (t_5 <= Float64(-Inf)) tmp = Float64(Float64(sqrt(Float64(fma(-0.5, t_0, C) + C)) / t_6) * Float64(sqrt(t_4) * sqrt(Float64(F * 2.0)))); elseif (t_5 <= -2e-177) tmp = Float64(sqrt(Float64(t_2 * Float64(Float64(hypot(Float64(A - C), B_m) + A) + C))) / t_6); elseif (t_5 <= 0.0) tmp = Float64(sqrt(Float64(Float64(Float64(t_4 * F) * 2.0) * fma(t_0, -0.5, Float64(C * 2.0)))) / Float64(-t_4)); elseif (t_5 <= Inf) tmp = Float64(sqrt(t_2) * Float64(sqrt(Float64(Float64(fma(0.0, Float64(A / C), 1.0) * C) + C)) / t_6)); else tmp = Float64(Float64(-sqrt(F)) / sqrt(Float64(0.5 * 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[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision]}, Block[{t$95$1 = N[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(F * 2.0), $MachinePrecision] * t$95$1), $MachinePrecision]}, Block[{t$95$3 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(N[Sqrt[N[(N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$3), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$3 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$6 = (-t$95$1)}, If[LessEqual[t$95$5, (-Infinity)], N[(N[(N[Sqrt[N[(N[(-0.5 * t$95$0 + C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$6), $MachinePrecision] * N[(N[Sqrt[t$95$4], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$5, -2e-177], N[(N[Sqrt[N[(t$95$2 * N[(N[(N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision] + A), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$6), $MachinePrecision], If[LessEqual[t$95$5, 0.0], N[(N[Sqrt[N[(N[(N[(t$95$4 * F), $MachinePrecision] * 2.0), $MachinePrecision] * N[(t$95$0 * -0.5 + N[(C * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$4)), $MachinePrecision], If[LessEqual[t$95$5, Infinity], N[(N[Sqrt[t$95$2], $MachinePrecision] * N[(N[Sqrt[N[(N[(N[(0.0 * N[(A / C), $MachinePrecision] + 1.0), $MachinePrecision] * C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$6), $MachinePrecision]), $MachinePrecision], N[((-N[Sqrt[F], $MachinePrecision]) / N[Sqrt[N[(0.5 * 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 \cdot B\_m}{A}\\
t_1 := \mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_2 := \left(F \cdot 2\right) \cdot t\_1\\
t_3 := C \cdot \left(A \cdot 4\right)\\
t_4 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
t_5 := \frac{\sqrt{\left(\left(C + A\right) + \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_3\right)\right) \cdot 2\right)}}{t\_3 - {B\_m}^{2}}\\
t_6 := -t\_1\\
\mathbf{if}\;t\_5 \leq -\infty:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(-0.5, t\_0, C\right) + C}}{t\_6} \cdot \left(\sqrt{t\_4} \cdot \sqrt{F \cdot 2}\right)\\
\mathbf{elif}\;t\_5 \leq -2 \cdot 10^{-177}:\\
\;\;\;\;\frac{\sqrt{t\_2 \cdot \left(\left(\mathsf{hypot}\left(A - C, B\_m\right) + A\right) + C\right)}}{t\_6}\\
\mathbf{elif}\;t\_5 \leq 0:\\
\;\;\;\;\frac{\sqrt{\left(\left(t\_4 \cdot F\right) \cdot 2\right) \cdot \mathsf{fma}\left(t\_0, -0.5, C \cdot 2\right)}}{-t\_4}\\
\mathbf{elif}\;t\_5 \leq \infty:\\
\;\;\;\;\sqrt{t\_2} \cdot \frac{\sqrt{\mathsf{fma}\left(0, \frac{A}{C}, 1\right) \cdot C + C}}{t\_6}\\
\mathbf{else}:\\
\;\;\;\;\frac{-\sqrt{F}}{\sqrt{0.5 \cdot B\_m}}\\
\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))) < -inf.0Initial program 3.0%
Applied rewrites32.8%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites51.9%
Taylor expanded in A around -inf
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6447.0
Applied rewrites47.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))) < -1.9999999999999999e-177Initial program 99.1%
Applied rewrites99.1%
if -1.9999999999999999e-177 < (/.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))) < -0.0Initial program 6.2%
Taylor expanded in A around -inf
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6424.7
Applied rewrites24.7%
Applied rewrites24.7%
if -0.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))) < +inf.0Initial program 36.7%
Applied rewrites86.5%
Taylor expanded in C around inf
lower-*.f64N/A
+-commutativeN/A
distribute-lft1-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-/.f6447.4
Applied rewrites47.4%
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
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.3
Applied rewrites15.3%
Applied rewrites15.4%
Applied rewrites15.4%
Applied rewrites21.3%
Final simplification42.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 (/ (* B_m B_m) A))
(t_1 (* C (* A 4.0)))
(t_2 (fma (* C A) -4.0 (* B_m B_m)))
(t_3
(/
(sqrt
(*
(+ (+ C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))
(* (* F (- (pow B_m 2.0) t_1)) 2.0)))
(- t_1 (pow B_m 2.0))))
(t_4 (fma -4.0 (* C A) (* B_m B_m)))
(t_5 (- t_4)))
(if (<= t_3 -4e+186)
(* (/ (sqrt (+ (fma -0.5 t_0 C) C)) t_5) (* (sqrt t_2) (sqrt (* F 2.0))))
(if (<= t_3 -2e-177)
(*
(sqrt
(/
(* (+ (+ (hypot (- A C) B_m) C) A) F)
(fma (* -4.0 A) C (* B_m B_m))))
(- (sqrt 2.0)))
(if (<= t_3 0.0)
(/ (sqrt (* (* (* t_2 F) 2.0) (fma t_0 -0.5 (* C 2.0)))) (- t_2))
(if (<= t_3 INFINITY)
(*
(sqrt (* (* F 2.0) t_4))
(/ (sqrt (+ (* (fma 0.0 (/ A C) 1.0) C) C)) t_5))
(/ (- (sqrt F)) (sqrt (* 0.5 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 = (B_m * B_m) / A;
double t_1 = C * (A * 4.0);
double t_2 = fma((C * A), -4.0, (B_m * B_m));
double t_3 = sqrt((((C + A) + sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))) * ((F * (pow(B_m, 2.0) - t_1)) * 2.0))) / (t_1 - pow(B_m, 2.0));
double t_4 = fma(-4.0, (C * A), (B_m * B_m));
double t_5 = -t_4;
double tmp;
if (t_3 <= -4e+186) {
tmp = (sqrt((fma(-0.5, t_0, C) + C)) / t_5) * (sqrt(t_2) * sqrt((F * 2.0)));
} else if (t_3 <= -2e-177) {
tmp = sqrt(((((hypot((A - C), B_m) + C) + A) * F) / fma((-4.0 * A), C, (B_m * B_m)))) * -sqrt(2.0);
} else if (t_3 <= 0.0) {
tmp = sqrt((((t_2 * F) * 2.0) * fma(t_0, -0.5, (C * 2.0)))) / -t_2;
} else if (t_3 <= ((double) INFINITY)) {
tmp = sqrt(((F * 2.0) * t_4)) * (sqrt(((fma(0.0, (A / C), 1.0) * C) + C)) / t_5);
} else {
tmp = -sqrt(F) / sqrt((0.5 * 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(Float64(B_m * B_m) / A) t_1 = Float64(C * Float64(A * 4.0)) t_2 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) t_3 = Float64(sqrt(Float64(Float64(Float64(C + A) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_1)) * 2.0))) / Float64(t_1 - (B_m ^ 2.0))) t_4 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_5 = Float64(-t_4) tmp = 0.0 if (t_3 <= -4e+186) tmp = Float64(Float64(sqrt(Float64(fma(-0.5, t_0, C) + C)) / t_5) * Float64(sqrt(t_2) * sqrt(Float64(F * 2.0)))); elseif (t_3 <= -2e-177) tmp = Float64(sqrt(Float64(Float64(Float64(Float64(hypot(Float64(A - C), B_m) + C) + A) * F) / fma(Float64(-4.0 * A), C, Float64(B_m * B_m)))) * Float64(-sqrt(2.0))); elseif (t_3 <= 0.0) tmp = Float64(sqrt(Float64(Float64(Float64(t_2 * F) * 2.0) * fma(t_0, -0.5, Float64(C * 2.0)))) / Float64(-t_2)); elseif (t_3 <= Inf) tmp = Float64(sqrt(Float64(Float64(F * 2.0) * t_4)) * Float64(sqrt(Float64(Float64(fma(0.0, Float64(A / C), 1.0) * C) + C)) / t_5)); else tmp = Float64(Float64(-sqrt(F)) / sqrt(Float64(0.5 * 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[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision]}, Block[{t$95$1 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$1 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = (-t$95$4)}, If[LessEqual[t$95$3, -4e+186], N[(N[(N[Sqrt[N[(N[(-0.5 * t$95$0 + C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$5), $MachinePrecision] * N[(N[Sqrt[t$95$2], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -2e-177], N[(N[Sqrt[N[(N[(N[(N[(N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $MachinePrecision] + A), $MachinePrecision] * F), $MachinePrecision] / N[(N[(-4.0 * A), $MachinePrecision] * C + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision], If[LessEqual[t$95$3, 0.0], N[(N[Sqrt[N[(N[(N[(t$95$2 * F), $MachinePrecision] * 2.0), $MachinePrecision] * N[(t$95$0 * -0.5 + N[(C * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$2)), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] * t$95$4), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[N[(N[(N[(0.0 * N[(A / C), $MachinePrecision] + 1.0), $MachinePrecision] * C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$5), $MachinePrecision]), $MachinePrecision], N[((-N[Sqrt[F], $MachinePrecision]) / N[Sqrt[N[(0.5 * 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 \cdot B\_m}{A}\\
t_1 := C \cdot \left(A \cdot 4\right)\\
t_2 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
t_3 := \frac{\sqrt{\left(\left(C + A\right) + \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_1\right)\right) \cdot 2\right)}}{t\_1 - {B\_m}^{2}}\\
t_4 := \mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_5 := -t\_4\\
\mathbf{if}\;t\_3 \leq -4 \cdot 10^{+186}:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(-0.5, t\_0, C\right) + C}}{t\_5} \cdot \left(\sqrt{t\_2} \cdot \sqrt{F \cdot 2}\right)\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-177}:\\
\;\;\;\;\sqrt{\frac{\left(\left(\mathsf{hypot}\left(A - C, B\_m\right) + C\right) + A\right) \cdot F}{\mathsf{fma}\left(-4 \cdot A, C, B\_m \cdot B\_m\right)}} \cdot \left(-\sqrt{2}\right)\\
\mathbf{elif}\;t\_3 \leq 0:\\
\;\;\;\;\frac{\sqrt{\left(\left(t\_2 \cdot F\right) \cdot 2\right) \cdot \mathsf{fma}\left(t\_0, -0.5, C \cdot 2\right)}}{-t\_2}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\sqrt{\left(F \cdot 2\right) \cdot t\_4} \cdot \frac{\sqrt{\mathsf{fma}\left(0, \frac{A}{C}, 1\right) \cdot C + C}}{t\_5}\\
\mathbf{else}:\\
\;\;\;\;\frac{-\sqrt{F}}{\sqrt{0.5 \cdot B\_m}}\\
\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))) < -3.99999999999999992e186Initial program 7.2%
Applied rewrites35.7%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites53.9%
Taylor expanded in A around -inf
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6445.3
Applied rewrites45.3%
if -3.99999999999999992e186 < (/.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.9999999999999999e-177Initial program 99.1%
Taylor expanded in F around 0
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
Applied rewrites93.0%
if -1.9999999999999999e-177 < (/.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))) < -0.0Initial program 6.2%
Taylor expanded in A around -inf
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6424.7
Applied rewrites24.7%
Applied rewrites24.7%
if -0.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))) < +inf.0Initial program 36.7%
Applied rewrites86.5%
Taylor expanded in C around inf
lower-*.f64N/A
+-commutativeN/A
distribute-lft1-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-/.f6447.4
Applied rewrites47.4%
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
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.3
Applied rewrites15.3%
Applied rewrites15.4%
Applied rewrites15.4%
Applied rewrites21.3%
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 (/ (* B_m B_m) A))
(t_1 (* C (* A 4.0)))
(t_2 (fma (* C A) -4.0 (* B_m B_m)))
(t_3
(/
(sqrt
(*
(+ (+ C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))
(* (* F (- (pow B_m 2.0) t_1)) 2.0)))
(- t_1 (pow B_m 2.0))))
(t_4 (fma -4.0 (* C A) (* B_m B_m)))
(t_5 (- t_4)))
(if (<= t_3 -100000.0)
(* (/ (sqrt (+ (fma -0.5 t_0 C) C)) t_5) (* (sqrt t_2) (sqrt (* F 2.0))))
(if (<= t_3 -2e-177)
(*
(* (/ (sqrt 2.0) B_m) (sqrt F))
(- (sqrt (+ (+ C A) (hypot (- A C) B_m)))))
(if (<= t_3 0.0)
(/ (sqrt (* (* (* t_2 F) 2.0) (fma t_0 -0.5 (* C 2.0)))) (- t_2))
(if (<= t_3 INFINITY)
(*
(sqrt (* (* F 2.0) t_4))
(/ (sqrt (+ (* (fma 0.0 (/ A C) 1.0) C) C)) t_5))
(/ (- (sqrt F)) (sqrt (* 0.5 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 = (B_m * B_m) / A;
double t_1 = C * (A * 4.0);
double t_2 = fma((C * A), -4.0, (B_m * B_m));
double t_3 = sqrt((((C + A) + sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))) * ((F * (pow(B_m, 2.0) - t_1)) * 2.0))) / (t_1 - pow(B_m, 2.0));
double t_4 = fma(-4.0, (C * A), (B_m * B_m));
double t_5 = -t_4;
double tmp;
if (t_3 <= -100000.0) {
tmp = (sqrt((fma(-0.5, t_0, C) + C)) / t_5) * (sqrt(t_2) * sqrt((F * 2.0)));
} else if (t_3 <= -2e-177) {
tmp = ((sqrt(2.0) / B_m) * sqrt(F)) * -sqrt(((C + A) + hypot((A - C), B_m)));
} else if (t_3 <= 0.0) {
tmp = sqrt((((t_2 * F) * 2.0) * fma(t_0, -0.5, (C * 2.0)))) / -t_2;
} else if (t_3 <= ((double) INFINITY)) {
tmp = sqrt(((F * 2.0) * t_4)) * (sqrt(((fma(0.0, (A / C), 1.0) * C) + C)) / t_5);
} else {
tmp = -sqrt(F) / sqrt((0.5 * 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(Float64(B_m * B_m) / A) t_1 = Float64(C * Float64(A * 4.0)) t_2 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) t_3 = Float64(sqrt(Float64(Float64(Float64(C + A) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_1)) * 2.0))) / Float64(t_1 - (B_m ^ 2.0))) t_4 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_5 = Float64(-t_4) tmp = 0.0 if (t_3 <= -100000.0) tmp = Float64(Float64(sqrt(Float64(fma(-0.5, t_0, C) + C)) / t_5) * Float64(sqrt(t_2) * sqrt(Float64(F * 2.0)))); elseif (t_3 <= -2e-177) tmp = Float64(Float64(Float64(sqrt(2.0) / B_m) * sqrt(F)) * Float64(-sqrt(Float64(Float64(C + A) + hypot(Float64(A - C), B_m))))); elseif (t_3 <= 0.0) tmp = Float64(sqrt(Float64(Float64(Float64(t_2 * F) * 2.0) * fma(t_0, -0.5, Float64(C * 2.0)))) / Float64(-t_2)); elseif (t_3 <= Inf) tmp = Float64(sqrt(Float64(Float64(F * 2.0) * t_4)) * Float64(sqrt(Float64(Float64(fma(0.0, Float64(A / C), 1.0) * C) + C)) / t_5)); else tmp = Float64(Float64(-sqrt(F)) / sqrt(Float64(0.5 * 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[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision]}, Block[{t$95$1 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$1 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = (-t$95$4)}, If[LessEqual[t$95$3, -100000.0], N[(N[(N[Sqrt[N[(N[(-0.5 * t$95$0 + C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$5), $MachinePrecision] * N[(N[Sqrt[t$95$2], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -2e-177], N[(N[(N[(N[Sqrt[2.0], $MachinePrecision] / B$95$m), $MachinePrecision] * N[Sqrt[F], $MachinePrecision]), $MachinePrecision] * (-N[Sqrt[N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], If[LessEqual[t$95$3, 0.0], N[(N[Sqrt[N[(N[(N[(t$95$2 * F), $MachinePrecision] * 2.0), $MachinePrecision] * N[(t$95$0 * -0.5 + N[(C * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$2)), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] * t$95$4), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[N[(N[(N[(0.0 * N[(A / C), $MachinePrecision] + 1.0), $MachinePrecision] * C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$5), $MachinePrecision]), $MachinePrecision], N[((-N[Sqrt[F], $MachinePrecision]) / N[Sqrt[N[(0.5 * 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 \cdot B\_m}{A}\\
t_1 := C \cdot \left(A \cdot 4\right)\\
t_2 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
t_3 := \frac{\sqrt{\left(\left(C + A\right) + \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_1\right)\right) \cdot 2\right)}}{t\_1 - {B\_m}^{2}}\\
t_4 := \mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_5 := -t\_4\\
\mathbf{if}\;t\_3 \leq -100000:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(-0.5, t\_0, C\right) + C}}{t\_5} \cdot \left(\sqrt{t\_2} \cdot \sqrt{F \cdot 2}\right)\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-177}:\\
\;\;\;\;\left(\frac{\sqrt{2}}{B\_m} \cdot \sqrt{F}\right) \cdot \left(-\sqrt{\left(C + A\right) + \mathsf{hypot}\left(A - C, B\_m\right)}\right)\\
\mathbf{elif}\;t\_3 \leq 0:\\
\;\;\;\;\frac{\sqrt{\left(\left(t\_2 \cdot F\right) \cdot 2\right) \cdot \mathsf{fma}\left(t\_0, -0.5, C \cdot 2\right)}}{-t\_2}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\sqrt{\left(F \cdot 2\right) \cdot t\_4} \cdot \frac{\sqrt{\mathsf{fma}\left(0, \frac{A}{C}, 1\right) \cdot C + C}}{t\_5}\\
\mathbf{else}:\\
\;\;\;\;\frac{-\sqrt{F}}{\sqrt{0.5 \cdot B\_m}}\\
\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))) < -1e5Initial program 28.3%
Applied rewrites50.3%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites64.2%
Taylor expanded in A around -inf
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6441.7
Applied rewrites41.7%
if -1e5 < (/.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.9999999999999999e-177Initial program 99.0%
Applied rewrites98.8%
Taylor expanded in C around 0
lower-*.f64N/A
lower-/.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6447.3
Applied rewrites47.3%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lower-neg.f6447.3
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-+.f6447.3
Applied rewrites47.3%
if -1.9999999999999999e-177 < (/.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))) < -0.0Initial program 6.2%
Taylor expanded in A around -inf
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6424.7
Applied rewrites24.7%
Applied rewrites24.7%
if -0.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))) < +inf.0Initial program 36.7%
Applied rewrites86.5%
Taylor expanded in C around inf
lower-*.f64N/A
+-commutativeN/A
distribute-lft1-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-/.f6447.4
Applied rewrites47.4%
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
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.3
Applied rewrites15.3%
Applied rewrites15.4%
Applied rewrites15.4%
Applied rewrites21.3%
Final simplification32.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 (/ (* B_m B_m) A))
(t_1 (* C (* A 4.0)))
(t_2 (fma (* C A) -4.0 (* B_m B_m)))
(t_3 (sqrt (* F 2.0)))
(t_4
(/
(sqrt
(*
(+ (+ C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))
(* (* F (- (pow B_m 2.0) t_1)) 2.0)))
(- t_1 (pow B_m 2.0))))
(t_5 (fma -4.0 (* C A) (* B_m B_m)))
(t_6 (- t_5)))
(if (<= t_4 -100000.0)
(* (/ (sqrt (+ (fma -0.5 t_0 C) C)) t_6) (* (sqrt t_2) t_3))
(if (<= t_4 -2e-177)
(* (/ t_3 B_m) (- (sqrt (+ (+ C A) (hypot (- A C) B_m)))))
(if (<= t_4 0.0)
(/ (sqrt (* (* (* t_2 F) 2.0) (fma t_0 -0.5 (* C 2.0)))) (- t_2))
(if (<= t_4 INFINITY)
(*
(sqrt (* (* F 2.0) t_5))
(/ (sqrt (+ (* (fma 0.0 (/ A C) 1.0) C) C)) t_6))
(/ (- (sqrt F)) (sqrt (* 0.5 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 = (B_m * B_m) / A;
double t_1 = C * (A * 4.0);
double t_2 = fma((C * A), -4.0, (B_m * B_m));
double t_3 = sqrt((F * 2.0));
double t_4 = sqrt((((C + A) + sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))) * ((F * (pow(B_m, 2.0) - t_1)) * 2.0))) / (t_1 - pow(B_m, 2.0));
double t_5 = fma(-4.0, (C * A), (B_m * B_m));
double t_6 = -t_5;
double tmp;
if (t_4 <= -100000.0) {
tmp = (sqrt((fma(-0.5, t_0, C) + C)) / t_6) * (sqrt(t_2) * t_3);
} else if (t_4 <= -2e-177) {
tmp = (t_3 / B_m) * -sqrt(((C + A) + hypot((A - C), B_m)));
} else if (t_4 <= 0.0) {
tmp = sqrt((((t_2 * F) * 2.0) * fma(t_0, -0.5, (C * 2.0)))) / -t_2;
} else if (t_4 <= ((double) INFINITY)) {
tmp = sqrt(((F * 2.0) * t_5)) * (sqrt(((fma(0.0, (A / C), 1.0) * C) + C)) / t_6);
} else {
tmp = -sqrt(F) / sqrt((0.5 * 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(Float64(B_m * B_m) / A) t_1 = Float64(C * Float64(A * 4.0)) t_2 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) t_3 = sqrt(Float64(F * 2.0)) t_4 = Float64(sqrt(Float64(Float64(Float64(C + A) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_1)) * 2.0))) / Float64(t_1 - (B_m ^ 2.0))) t_5 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_6 = Float64(-t_5) tmp = 0.0 if (t_4 <= -100000.0) tmp = Float64(Float64(sqrt(Float64(fma(-0.5, t_0, C) + C)) / t_6) * Float64(sqrt(t_2) * t_3)); elseif (t_4 <= -2e-177) tmp = Float64(Float64(t_3 / B_m) * Float64(-sqrt(Float64(Float64(C + A) + hypot(Float64(A - C), B_m))))); elseif (t_4 <= 0.0) tmp = Float64(sqrt(Float64(Float64(Float64(t_2 * F) * 2.0) * fma(t_0, -0.5, Float64(C * 2.0)))) / Float64(-t_2)); elseif (t_4 <= Inf) tmp = Float64(sqrt(Float64(Float64(F * 2.0) * t_5)) * Float64(sqrt(Float64(Float64(fma(0.0, Float64(A / C), 1.0) * C) + C)) / t_6)); else tmp = Float64(Float64(-sqrt(F)) / sqrt(Float64(0.5 * 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[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision]}, Block[{t$95$1 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$4 = N[(N[Sqrt[N[(N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$1 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$6 = (-t$95$5)}, If[LessEqual[t$95$4, -100000.0], N[(N[(N[Sqrt[N[(N[(-0.5 * t$95$0 + C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$6), $MachinePrecision] * N[(N[Sqrt[t$95$2], $MachinePrecision] * t$95$3), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, -2e-177], N[(N[(t$95$3 / B$95$m), $MachinePrecision] * (-N[Sqrt[N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], If[LessEqual[t$95$4, 0.0], N[(N[Sqrt[N[(N[(N[(t$95$2 * F), $MachinePrecision] * 2.0), $MachinePrecision] * N[(t$95$0 * -0.5 + N[(C * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$2)), $MachinePrecision], If[LessEqual[t$95$4, Infinity], N[(N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] * t$95$5), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[N[(N[(N[(0.0 * N[(A / C), $MachinePrecision] + 1.0), $MachinePrecision] * C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$6), $MachinePrecision]), $MachinePrecision], N[((-N[Sqrt[F], $MachinePrecision]) / N[Sqrt[N[(0.5 * 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 \cdot B\_m}{A}\\
t_1 := C \cdot \left(A \cdot 4\right)\\
t_2 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
t_3 := \sqrt{F \cdot 2}\\
t_4 := \frac{\sqrt{\left(\left(C + A\right) + \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_1\right)\right) \cdot 2\right)}}{t\_1 - {B\_m}^{2}}\\
t_5 := \mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_6 := -t\_5\\
\mathbf{if}\;t\_4 \leq -100000:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(-0.5, t\_0, C\right) + C}}{t\_6} \cdot \left(\sqrt{t\_2} \cdot t\_3\right)\\
\mathbf{elif}\;t\_4 \leq -2 \cdot 10^{-177}:\\
\;\;\;\;\frac{t\_3}{B\_m} \cdot \left(-\sqrt{\left(C + A\right) + \mathsf{hypot}\left(A - C, B\_m\right)}\right)\\
\mathbf{elif}\;t\_4 \leq 0:\\
\;\;\;\;\frac{\sqrt{\left(\left(t\_2 \cdot F\right) \cdot 2\right) \cdot \mathsf{fma}\left(t\_0, -0.5, C \cdot 2\right)}}{-t\_2}\\
\mathbf{elif}\;t\_4 \leq \infty:\\
\;\;\;\;\sqrt{\left(F \cdot 2\right) \cdot t\_5} \cdot \frac{\sqrt{\mathsf{fma}\left(0, \frac{A}{C}, 1\right) \cdot C + C}}{t\_6}\\
\mathbf{else}:\\
\;\;\;\;\frac{-\sqrt{F}}{\sqrt{0.5 \cdot B\_m}}\\
\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))) < -1e5Initial program 28.3%
Applied rewrites50.3%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites64.2%
Taylor expanded in A around -inf
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6441.7
Applied rewrites41.7%
if -1e5 < (/.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.9999999999999999e-177Initial program 99.0%
Applied rewrites98.8%
Taylor expanded in C around 0
lower-*.f64N/A
lower-/.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6447.3
Applied rewrites47.3%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lower-neg.f6447.3
lift-+.f64N/A
lift-+.f64N/A
associate-+l+N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
lower-+.f6447.3
Applied rewrites47.1%
if -1.9999999999999999e-177 < (/.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))) < -0.0Initial program 6.2%
Taylor expanded in A around -inf
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6424.7
Applied rewrites24.7%
Applied rewrites24.7%
if -0.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))) < +inf.0Initial program 36.7%
Applied rewrites86.5%
Taylor expanded in C around inf
lower-*.f64N/A
+-commutativeN/A
distribute-lft1-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-/.f6447.4
Applied rewrites47.4%
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
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.3
Applied rewrites15.3%
Applied rewrites15.4%
Applied rewrites15.4%
Applied rewrites21.3%
Final simplification32.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 (/ (* B_m B_m) A))
(t_1 (* C (* A 4.0)))
(t_2 (fma (* C A) -4.0 (* B_m B_m)))
(t_3
(/
(sqrt
(*
(+ (+ C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))
(* (* F (- (pow B_m 2.0) t_1)) 2.0)))
(- t_1 (pow B_m 2.0))))
(t_4 (fma -4.0 (* C A) (* B_m B_m)))
(t_5 (- t_4)))
(if (<= t_3 -100000.0)
(* (/ (sqrt (+ (fma -0.5 t_0 C) C)) t_5) (* (sqrt t_2) (sqrt (* F 2.0))))
(if (<= t_3 -2e-177)
(* (sqrt (* (+ (hypot C B_m) C) F)) (/ (- (sqrt 2.0)) B_m))
(if (<= t_3 0.0)
(/ (sqrt (* (* (* t_2 F) 2.0) (fma t_0 -0.5 (* C 2.0)))) (- t_2))
(if (<= t_3 INFINITY)
(*
(sqrt (* (* F 2.0) t_4))
(/ (sqrt (+ (* (fma 0.0 (/ A C) 1.0) C) C)) t_5))
(/ (- (sqrt F)) (sqrt (* 0.5 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 = (B_m * B_m) / A;
double t_1 = C * (A * 4.0);
double t_2 = fma((C * A), -4.0, (B_m * B_m));
double t_3 = sqrt((((C + A) + sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))) * ((F * (pow(B_m, 2.0) - t_1)) * 2.0))) / (t_1 - pow(B_m, 2.0));
double t_4 = fma(-4.0, (C * A), (B_m * B_m));
double t_5 = -t_4;
double tmp;
if (t_3 <= -100000.0) {
tmp = (sqrt((fma(-0.5, t_0, C) + C)) / t_5) * (sqrt(t_2) * sqrt((F * 2.0)));
} else if (t_3 <= -2e-177) {
tmp = sqrt(((hypot(C, B_m) + C) * F)) * (-sqrt(2.0) / B_m);
} else if (t_3 <= 0.0) {
tmp = sqrt((((t_2 * F) * 2.0) * fma(t_0, -0.5, (C * 2.0)))) / -t_2;
} else if (t_3 <= ((double) INFINITY)) {
tmp = sqrt(((F * 2.0) * t_4)) * (sqrt(((fma(0.0, (A / C), 1.0) * C) + C)) / t_5);
} else {
tmp = -sqrt(F) / sqrt((0.5 * 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(Float64(B_m * B_m) / A) t_1 = Float64(C * Float64(A * 4.0)) t_2 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) t_3 = Float64(sqrt(Float64(Float64(Float64(C + A) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_1)) * 2.0))) / Float64(t_1 - (B_m ^ 2.0))) t_4 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_5 = Float64(-t_4) tmp = 0.0 if (t_3 <= -100000.0) tmp = Float64(Float64(sqrt(Float64(fma(-0.5, t_0, C) + C)) / t_5) * Float64(sqrt(t_2) * sqrt(Float64(F * 2.0)))); elseif (t_3 <= -2e-177) tmp = Float64(sqrt(Float64(Float64(hypot(C, B_m) + C) * F)) * Float64(Float64(-sqrt(2.0)) / B_m)); elseif (t_3 <= 0.0) tmp = Float64(sqrt(Float64(Float64(Float64(t_2 * F) * 2.0) * fma(t_0, -0.5, Float64(C * 2.0)))) / Float64(-t_2)); elseif (t_3 <= Inf) tmp = Float64(sqrt(Float64(Float64(F * 2.0) * t_4)) * Float64(sqrt(Float64(Float64(fma(0.0, Float64(A / C), 1.0) * C) + C)) / t_5)); else tmp = Float64(Float64(-sqrt(F)) / sqrt(Float64(0.5 * 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[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision]}, Block[{t$95$1 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$1 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = (-t$95$4)}, If[LessEqual[t$95$3, -100000.0], N[(N[(N[Sqrt[N[(N[(-0.5 * t$95$0 + C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$5), $MachinePrecision] * N[(N[Sqrt[t$95$2], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -2e-177], N[(N[Sqrt[N[(N[(N[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $MachinePrecision] * F), $MachinePrecision]], $MachinePrecision] * N[((-N[Sqrt[2.0], $MachinePrecision]) / B$95$m), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 0.0], N[(N[Sqrt[N[(N[(N[(t$95$2 * F), $MachinePrecision] * 2.0), $MachinePrecision] * N[(t$95$0 * -0.5 + N[(C * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$2)), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] * t$95$4), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[N[(N[(N[(0.0 * N[(A / C), $MachinePrecision] + 1.0), $MachinePrecision] * C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$5), $MachinePrecision]), $MachinePrecision], N[((-N[Sqrt[F], $MachinePrecision]) / N[Sqrt[N[(0.5 * 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 \cdot B\_m}{A}\\
t_1 := C \cdot \left(A \cdot 4\right)\\
t_2 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
t_3 := \frac{\sqrt{\left(\left(C + A\right) + \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_1\right)\right) \cdot 2\right)}}{t\_1 - {B\_m}^{2}}\\
t_4 := \mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_5 := -t\_4\\
\mathbf{if}\;t\_3 \leq -100000:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(-0.5, t\_0, C\right) + C}}{t\_5} \cdot \left(\sqrt{t\_2} \cdot \sqrt{F \cdot 2}\right)\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-177}:\\
\;\;\;\;\sqrt{\left(\mathsf{hypot}\left(C, B\_m\right) + C\right) \cdot F} \cdot \frac{-\sqrt{2}}{B\_m}\\
\mathbf{elif}\;t\_3 \leq 0:\\
\;\;\;\;\frac{\sqrt{\left(\left(t\_2 \cdot F\right) \cdot 2\right) \cdot \mathsf{fma}\left(t\_0, -0.5, C \cdot 2\right)}}{-t\_2}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\sqrt{\left(F \cdot 2\right) \cdot t\_4} \cdot \frac{\sqrt{\mathsf{fma}\left(0, \frac{A}{C}, 1\right) \cdot C + C}}{t\_5}\\
\mathbf{else}:\\
\;\;\;\;\frac{-\sqrt{F}}{\sqrt{0.5 \cdot B\_m}}\\
\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))) < -1e5Initial program 28.3%
Applied rewrites50.3%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites64.2%
Taylor expanded in A around -inf
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6441.7
Applied rewrites41.7%
if -1e5 < (/.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.9999999999999999e-177Initial program 99.0%
Taylor expanded in A around 0
associate-*r*N/A
lower-*.f64N/A
mul-1-negN/A
lower-neg.f64N/A
lower-/.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
*-commutativeN/A
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
+-commutativeN/A
unpow2N/A
unpow2N/A
lower-hypot.f6442.8
Applied rewrites42.8%
if -1.9999999999999999e-177 < (/.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))) < -0.0Initial program 6.2%
Taylor expanded in A around -inf
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6424.7
Applied rewrites24.7%
Applied rewrites24.7%
if -0.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))) < +inf.0Initial program 36.7%
Applied rewrites86.5%
Taylor expanded in C around inf
lower-*.f64N/A
+-commutativeN/A
distribute-lft1-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-/.f6447.4
Applied rewrites47.4%
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
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.3
Applied rewrites15.3%
Applied rewrites15.4%
Applied rewrites15.4%
Applied rewrites21.3%
Final simplification31.9%
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 (/ (* B_m B_m) A))
(t_1 (* C (* A 4.0)))
(t_2 (fma (* C A) -4.0 (* B_m B_m)))
(t_3
(/
(sqrt
(*
(+ (+ C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))
(* (* F (- (pow B_m 2.0) t_1)) 2.0)))
(- t_1 (pow B_m 2.0))))
(t_4 (fma -4.0 (* C A) (* B_m B_m)))
(t_5 (sqrt (* (* F 2.0) t_4)))
(t_6 (- t_4)))
(if (<= t_3 -100000.0)
(* (/ (sqrt (+ (fma -0.5 t_0 C) C)) t_6) (* (sqrt t_2) (sqrt (* F 2.0))))
(if (<= t_3 -2e-177)
(* t_5 (/ (sqrt (+ (* (- (/ A B_m) -1.0) B_m) C)) t_6))
(if (<= t_3 0.0)
(/ (sqrt (* (* (* t_2 F) 2.0) (fma t_0 -0.5 (* C 2.0)))) (- t_2))
(if (<= t_3 INFINITY)
(* t_5 (/ (sqrt (+ (* (fma 0.0 (/ A C) 1.0) C) C)) t_6))
(/ (- (sqrt F)) (sqrt (* 0.5 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 = (B_m * B_m) / A;
double t_1 = C * (A * 4.0);
double t_2 = fma((C * A), -4.0, (B_m * B_m));
double t_3 = sqrt((((C + A) + sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))) * ((F * (pow(B_m, 2.0) - t_1)) * 2.0))) / (t_1 - pow(B_m, 2.0));
double t_4 = fma(-4.0, (C * A), (B_m * B_m));
double t_5 = sqrt(((F * 2.0) * t_4));
double t_6 = -t_4;
double tmp;
if (t_3 <= -100000.0) {
tmp = (sqrt((fma(-0.5, t_0, C) + C)) / t_6) * (sqrt(t_2) * sqrt((F * 2.0)));
} else if (t_3 <= -2e-177) {
tmp = t_5 * (sqrt(((((A / B_m) - -1.0) * B_m) + C)) / t_6);
} else if (t_3 <= 0.0) {
tmp = sqrt((((t_2 * F) * 2.0) * fma(t_0, -0.5, (C * 2.0)))) / -t_2;
} else if (t_3 <= ((double) INFINITY)) {
tmp = t_5 * (sqrt(((fma(0.0, (A / C), 1.0) * C) + C)) / t_6);
} else {
tmp = -sqrt(F) / sqrt((0.5 * 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(Float64(B_m * B_m) / A) t_1 = Float64(C * Float64(A * 4.0)) t_2 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) t_3 = Float64(sqrt(Float64(Float64(Float64(C + A) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_1)) * 2.0))) / Float64(t_1 - (B_m ^ 2.0))) t_4 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_5 = sqrt(Float64(Float64(F * 2.0) * t_4)) t_6 = Float64(-t_4) tmp = 0.0 if (t_3 <= -100000.0) tmp = Float64(Float64(sqrt(Float64(fma(-0.5, t_0, C) + C)) / t_6) * Float64(sqrt(t_2) * sqrt(Float64(F * 2.0)))); elseif (t_3 <= -2e-177) tmp = Float64(t_5 * Float64(sqrt(Float64(Float64(Float64(Float64(A / B_m) - -1.0) * B_m) + C)) / t_6)); elseif (t_3 <= 0.0) tmp = Float64(sqrt(Float64(Float64(Float64(t_2 * F) * 2.0) * fma(t_0, -0.5, Float64(C * 2.0)))) / Float64(-t_2)); elseif (t_3 <= Inf) tmp = Float64(t_5 * Float64(sqrt(Float64(Float64(fma(0.0, Float64(A / C), 1.0) * C) + C)) / t_6)); else tmp = Float64(Float64(-sqrt(F)) / sqrt(Float64(0.5 * 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[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision]}, Block[{t$95$1 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$1 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] * t$95$4), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$6 = (-t$95$4)}, If[LessEqual[t$95$3, -100000.0], N[(N[(N[Sqrt[N[(N[(-0.5 * t$95$0 + C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$6), $MachinePrecision] * N[(N[Sqrt[t$95$2], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -2e-177], N[(t$95$5 * N[(N[Sqrt[N[(N[(N[(N[(A / B$95$m), $MachinePrecision] - -1.0), $MachinePrecision] * B$95$m), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$6), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 0.0], N[(N[Sqrt[N[(N[(N[(t$95$2 * F), $MachinePrecision] * 2.0), $MachinePrecision] * N[(t$95$0 * -0.5 + N[(C * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$2)), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(t$95$5 * N[(N[Sqrt[N[(N[(N[(0.0 * N[(A / C), $MachinePrecision] + 1.0), $MachinePrecision] * C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$6), $MachinePrecision]), $MachinePrecision], N[((-N[Sqrt[F], $MachinePrecision]) / N[Sqrt[N[(0.5 * 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 \cdot B\_m}{A}\\
t_1 := C \cdot \left(A \cdot 4\right)\\
t_2 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
t_3 := \frac{\sqrt{\left(\left(C + A\right) + \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_1\right)\right) \cdot 2\right)}}{t\_1 - {B\_m}^{2}}\\
t_4 := \mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_5 := \sqrt{\left(F \cdot 2\right) \cdot t\_4}\\
t_6 := -t\_4\\
\mathbf{if}\;t\_3 \leq -100000:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(-0.5, t\_0, C\right) + C}}{t\_6} \cdot \left(\sqrt{t\_2} \cdot \sqrt{F \cdot 2}\right)\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-177}:\\
\;\;\;\;t\_5 \cdot \frac{\sqrt{\left(\frac{A}{B\_m} - -1\right) \cdot B\_m + C}}{t\_6}\\
\mathbf{elif}\;t\_3 \leq 0:\\
\;\;\;\;\frac{\sqrt{\left(\left(t\_2 \cdot F\right) \cdot 2\right) \cdot \mathsf{fma}\left(t\_0, -0.5, C \cdot 2\right)}}{-t\_2}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;t\_5 \cdot \frac{\sqrt{\mathsf{fma}\left(0, \frac{A}{C}, 1\right) \cdot C + C}}{t\_6}\\
\mathbf{else}:\\
\;\;\;\;\frac{-\sqrt{F}}{\sqrt{0.5 \cdot B\_m}}\\
\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))) < -1e5Initial program 28.3%
Applied rewrites50.3%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites64.2%
Taylor expanded in A around -inf
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6441.7
Applied rewrites41.7%
if -1e5 < (/.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.9999999999999999e-177Initial program 99.0%
Applied rewrites99.0%
Taylor expanded in B around inf
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f6446.6
Applied rewrites46.6%
if -1.9999999999999999e-177 < (/.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))) < -0.0Initial program 6.2%
Taylor expanded in A around -inf
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6424.7
Applied rewrites24.7%
Applied rewrites24.7%
if -0.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))) < +inf.0Initial program 36.7%
Applied rewrites86.5%
Taylor expanded in C around inf
lower-*.f64N/A
+-commutativeN/A
distribute-lft1-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-/.f6447.4
Applied rewrites47.4%
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
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.3
Applied rewrites15.3%
Applied rewrites15.4%
Applied rewrites15.4%
Applied rewrites21.3%
Final simplification32.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 -4.0 (* C A) (* B_m B_m)))
(t_1 (- t_0))
(t_2 (sqrt (* (* F 2.0) t_0)))
(t_3 (* C (* A 4.0)))
(t_4
(/
(sqrt
(*
(+ (+ C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))
(* (* F (- (pow B_m 2.0) t_3)) 2.0)))
(- t_3 (pow B_m 2.0))))
(t_5 (fma (* C A) -4.0 (* B_m B_m))))
(if (<= t_4 -0.0005)
(* (/ (sqrt (* C 2.0)) t_1) (* (sqrt t_5) (sqrt (* F 2.0))))
(if (<= t_4 -2e-177)
(* t_2 (/ (sqrt (+ (* (- (/ A B_m) -1.0) B_m) C)) t_1))
(if (<= t_4 0.0)
(/
(sqrt (* (* (* t_5 F) 2.0) (fma (/ (* B_m B_m) A) -0.5 (* C 2.0))))
(- t_5))
(if (<= t_4 INFINITY)
(* t_2 (/ (sqrt (+ (* (fma 0.0 (/ A C) 1.0) C) C)) t_1))
(/ (- (sqrt F)) (sqrt (* 0.5 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(-4.0, (C * A), (B_m * B_m));
double t_1 = -t_0;
double t_2 = sqrt(((F * 2.0) * t_0));
double t_3 = C * (A * 4.0);
double t_4 = sqrt((((C + A) + sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))) * ((F * (pow(B_m, 2.0) - t_3)) * 2.0))) / (t_3 - pow(B_m, 2.0));
double t_5 = fma((C * A), -4.0, (B_m * B_m));
double tmp;
if (t_4 <= -0.0005) {
tmp = (sqrt((C * 2.0)) / t_1) * (sqrt(t_5) * sqrt((F * 2.0)));
} else if (t_4 <= -2e-177) {
tmp = t_2 * (sqrt(((((A / B_m) - -1.0) * B_m) + C)) / t_1);
} else if (t_4 <= 0.0) {
tmp = sqrt((((t_5 * F) * 2.0) * fma(((B_m * B_m) / A), -0.5, (C * 2.0)))) / -t_5;
} else if (t_4 <= ((double) INFINITY)) {
tmp = t_2 * (sqrt(((fma(0.0, (A / C), 1.0) * C) + C)) / t_1);
} else {
tmp = -sqrt(F) / sqrt((0.5 * 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(-4.0, Float64(C * A), Float64(B_m * B_m)) t_1 = Float64(-t_0) t_2 = sqrt(Float64(Float64(F * 2.0) * t_0)) t_3 = Float64(C * Float64(A * 4.0)) t_4 = Float64(sqrt(Float64(Float64(Float64(C + A) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_3)) * 2.0))) / Float64(t_3 - (B_m ^ 2.0))) t_5 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) tmp = 0.0 if (t_4 <= -0.0005) tmp = Float64(Float64(sqrt(Float64(C * 2.0)) / t_1) * Float64(sqrt(t_5) * sqrt(Float64(F * 2.0)))); elseif (t_4 <= -2e-177) tmp = Float64(t_2 * Float64(sqrt(Float64(Float64(Float64(Float64(A / B_m) - -1.0) * B_m) + C)) / t_1)); elseif (t_4 <= 0.0) tmp = Float64(sqrt(Float64(Float64(Float64(t_5 * F) * 2.0) * fma(Float64(Float64(B_m * B_m) / A), -0.5, Float64(C * 2.0)))) / Float64(-t_5)); elseif (t_4 <= Inf) tmp = Float64(t_2 * Float64(sqrt(Float64(Float64(fma(0.0, Float64(A / C), 1.0) * C) + C)) / t_1)); else tmp = Float64(Float64(-sqrt(F)) / sqrt(Float64(0.5 * 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[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = (-t$95$0)}, Block[{t$95$2 = N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] * t$95$0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[Sqrt[N[(N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$3), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$3 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$4, -0.0005], N[(N[(N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision] * N[(N[Sqrt[t$95$5], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, -2e-177], N[(t$95$2 * N[(N[Sqrt[N[(N[(N[(N[(A / B$95$m), $MachinePrecision] - -1.0), $MachinePrecision] * B$95$m), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, 0.0], N[(N[Sqrt[N[(N[(N[(t$95$5 * F), $MachinePrecision] * 2.0), $MachinePrecision] * N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5 + N[(C * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$5)), $MachinePrecision], If[LessEqual[t$95$4, Infinity], N[(t$95$2 * N[(N[Sqrt[N[(N[(N[(0.0 * N[(A / C), $MachinePrecision] + 1.0), $MachinePrecision] * C), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], N[((-N[Sqrt[F], $MachinePrecision]) / N[Sqrt[N[(0.5 * 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(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_1 := -t\_0\\
t_2 := \sqrt{\left(F \cdot 2\right) \cdot t\_0}\\
t_3 := C \cdot \left(A \cdot 4\right)\\
t_4 := \frac{\sqrt{\left(\left(C + A\right) + \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_3\right)\right) \cdot 2\right)}}{t\_3 - {B\_m}^{2}}\\
t_5 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
\mathbf{if}\;t\_4 \leq -0.0005:\\
\;\;\;\;\frac{\sqrt{C \cdot 2}}{t\_1} \cdot \left(\sqrt{t\_5} \cdot \sqrt{F \cdot 2}\right)\\
\mathbf{elif}\;t\_4 \leq -2 \cdot 10^{-177}:\\
\;\;\;\;t\_2 \cdot \frac{\sqrt{\left(\frac{A}{B\_m} - -1\right) \cdot B\_m + C}}{t\_1}\\
\mathbf{elif}\;t\_4 \leq 0:\\
\;\;\;\;\frac{\sqrt{\left(\left(t\_5 \cdot F\right) \cdot 2\right) \cdot \mathsf{fma}\left(\frac{B\_m \cdot B\_m}{A}, -0.5, C \cdot 2\right)}}{-t\_5}\\
\mathbf{elif}\;t\_4 \leq \infty:\\
\;\;\;\;t\_2 \cdot \frac{\sqrt{\mathsf{fma}\left(0, \frac{A}{C}, 1\right) \cdot C + C}}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{-\sqrt{F}}{\sqrt{0.5 \cdot B\_m}}\\
\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))) < -5.0000000000000001e-4Initial program 29.4%
Applied rewrites51.1%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites64.8%
Taylor expanded in C around inf
lower-*.f6435.6
Applied rewrites35.6%
if -5.0000000000000001e-4 < (/.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.9999999999999999e-177Initial program 99.0%
Applied rewrites98.9%
Taylor expanded in B around inf
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f6447.6
Applied rewrites47.6%
if -1.9999999999999999e-177 < (/.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))) < -0.0Initial program 6.2%
Taylor expanded in A around -inf
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6424.7
Applied rewrites24.7%
Applied rewrites24.7%
if -0.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))) < +inf.0Initial program 36.7%
Applied rewrites86.5%
Taylor expanded in C around inf
lower-*.f64N/A
+-commutativeN/A
distribute-lft1-inN/A
metadata-evalN/A
lower-fma.f64N/A
lower-/.f6447.4
Applied rewrites47.4%
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
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.3
Applied rewrites15.3%
Applied rewrites15.4%
Applied rewrites15.4%
Applied rewrites21.3%
Final simplification30.9%
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 -4.0 (* C A) (* B_m B_m)))
(t_1 (- t_0))
(t_2 (* C (* A 4.0)))
(t_3
(/
(sqrt
(*
(+ (+ C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))
(* (* F (- (pow B_m 2.0) t_2)) 2.0)))
(- t_2 (pow B_m 2.0))))
(t_4 (fma (* C A) -4.0 (* B_m B_m)))
(t_5 (sqrt (* C 2.0)))
(t_6 (sqrt (* (* F 2.0) t_0))))
(if (<= t_3 -0.0005)
(* (/ t_5 t_1) (* (sqrt t_4) (sqrt (* F 2.0))))
(if (<= t_3 -2e-177)
(* t_6 (/ (sqrt (+ (* (- (/ A B_m) -1.0) B_m) C)) t_1))
(if (<= t_3 1e+112)
(/
(sqrt (* (* (* t_4 F) 2.0) (fma (/ (* B_m B_m) A) -0.5 (* C 2.0))))
(- t_4))
(if (<= t_3 INFINITY)
(* (/ t_6 t_1) t_5)
(/ (- (sqrt F)) (sqrt (* 0.5 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(-4.0, (C * A), (B_m * B_m));
double t_1 = -t_0;
double t_2 = C * (A * 4.0);
double t_3 = sqrt((((C + A) + sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))) * ((F * (pow(B_m, 2.0) - t_2)) * 2.0))) / (t_2 - pow(B_m, 2.0));
double t_4 = fma((C * A), -4.0, (B_m * B_m));
double t_5 = sqrt((C * 2.0));
double t_6 = sqrt(((F * 2.0) * t_0));
double tmp;
if (t_3 <= -0.0005) {
tmp = (t_5 / t_1) * (sqrt(t_4) * sqrt((F * 2.0)));
} else if (t_3 <= -2e-177) {
tmp = t_6 * (sqrt(((((A / B_m) - -1.0) * B_m) + C)) / t_1);
} else if (t_3 <= 1e+112) {
tmp = sqrt((((t_4 * F) * 2.0) * fma(((B_m * B_m) / A), -0.5, (C * 2.0)))) / -t_4;
} else if (t_3 <= ((double) INFINITY)) {
tmp = (t_6 / t_1) * t_5;
} else {
tmp = -sqrt(F) / sqrt((0.5 * 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(-4.0, Float64(C * A), Float64(B_m * B_m)) t_1 = Float64(-t_0) t_2 = Float64(C * Float64(A * 4.0)) t_3 = Float64(sqrt(Float64(Float64(Float64(C + A) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_2)) * 2.0))) / Float64(t_2 - (B_m ^ 2.0))) t_4 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) t_5 = sqrt(Float64(C * 2.0)) t_6 = sqrt(Float64(Float64(F * 2.0) * t_0)) tmp = 0.0 if (t_3 <= -0.0005) tmp = Float64(Float64(t_5 / t_1) * Float64(sqrt(t_4) * sqrt(Float64(F * 2.0)))); elseif (t_3 <= -2e-177) tmp = Float64(t_6 * Float64(sqrt(Float64(Float64(Float64(Float64(A / B_m) - -1.0) * B_m) + C)) / t_1)); elseif (t_3 <= 1e+112) tmp = Float64(sqrt(Float64(Float64(Float64(t_4 * F) * 2.0) * fma(Float64(Float64(B_m * B_m) / A), -0.5, Float64(C * 2.0)))) / Float64(-t_4)); elseif (t_3 <= Inf) tmp = Float64(Float64(t_6 / t_1) * t_5); else tmp = Float64(Float64(-sqrt(F)) / sqrt(Float64(0.5 * 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[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = (-t$95$0)}, Block[{t$95$2 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$2), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$2 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$6 = N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] * t$95$0), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[t$95$3, -0.0005], N[(N[(t$95$5 / t$95$1), $MachinePrecision] * N[(N[Sqrt[t$95$4], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -2e-177], N[(t$95$6 * N[(N[Sqrt[N[(N[(N[(N[(A / B$95$m), $MachinePrecision] - -1.0), $MachinePrecision] * B$95$m), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 1e+112], N[(N[Sqrt[N[(N[(N[(t$95$4 * F), $MachinePrecision] * 2.0), $MachinePrecision] * N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5 + N[(C * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$4)), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[(t$95$6 / t$95$1), $MachinePrecision] * t$95$5), $MachinePrecision], N[((-N[Sqrt[F], $MachinePrecision]) / N[Sqrt[N[(0.5 * 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(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_1 := -t\_0\\
t_2 := C \cdot \left(A \cdot 4\right)\\
t_3 := \frac{\sqrt{\left(\left(C + A\right) + \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_2\right)\right) \cdot 2\right)}}{t\_2 - {B\_m}^{2}}\\
t_4 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
t_5 := \sqrt{C \cdot 2}\\
t_6 := \sqrt{\left(F \cdot 2\right) \cdot t\_0}\\
\mathbf{if}\;t\_3 \leq -0.0005:\\
\;\;\;\;\frac{t\_5}{t\_1} \cdot \left(\sqrt{t\_4} \cdot \sqrt{F \cdot 2}\right)\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-177}:\\
\;\;\;\;t\_6 \cdot \frac{\sqrt{\left(\frac{A}{B\_m} - -1\right) \cdot B\_m + C}}{t\_1}\\
\mathbf{elif}\;t\_3 \leq 10^{+112}:\\
\;\;\;\;\frac{\sqrt{\left(\left(t\_4 \cdot F\right) \cdot 2\right) \cdot \mathsf{fma}\left(\frac{B\_m \cdot B\_m}{A}, -0.5, C \cdot 2\right)}}{-t\_4}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\frac{t\_6}{t\_1} \cdot t\_5\\
\mathbf{else}:\\
\;\;\;\;\frac{-\sqrt{F}}{\sqrt{0.5 \cdot B\_m}}\\
\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))) < -5.0000000000000001e-4Initial program 29.4%
Applied rewrites51.1%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites64.8%
Taylor expanded in C around inf
lower-*.f6435.6
Applied rewrites35.6%
if -5.0000000000000001e-4 < (/.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.9999999999999999e-177Initial program 99.0%
Applied rewrites98.9%
Taylor expanded in B around inf
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f6447.6
Applied rewrites47.6%
if -1.9999999999999999e-177 < (/.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.9999999999999993e111Initial program 21.5%
Taylor expanded in A around -inf
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6428.3
Applied rewrites28.3%
Applied rewrites28.3%
if 9.9999999999999993e111 < (/.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 16.7%
Applied rewrites82.0%
Taylor expanded in C around inf
lower-*.f6448.0
Applied rewrites48.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%
Taylor expanded in B around inf
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.3
Applied rewrites15.3%
Applied rewrites15.4%
Applied rewrites15.4%
Applied rewrites21.3%
Final simplification30.9%
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 -4.0 (* C A) (* B_m B_m)))
(t_1 (- t_0))
(t_2 (sqrt (* C 2.0)))
(t_3 (* C (* A 4.0)))
(t_4
(/
(sqrt
(*
(+ (+ C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))
(* (* F (- (pow B_m 2.0) t_3)) 2.0)))
(- t_3 (pow B_m 2.0))))
(t_5 (fma (* C A) -4.0 (* B_m B_m))))
(if (<= t_4 -0.0005)
(* (/ t_2 t_1) (* (sqrt t_5) (sqrt (* F 2.0))))
(if (<= t_4 -2e-177)
(*
(- (sqrt (+ (* (- (/ A B_m) -1.0) B_m) C)))
(* (/ (sqrt 2.0) B_m) (sqrt F)))
(if (<= t_4 1e+112)
(/
(sqrt (* (* (* t_5 F) 2.0) (fma (/ (* B_m B_m) A) -0.5 (* C 2.0))))
(- t_5))
(if (<= t_4 INFINITY)
(* (/ (sqrt (* (* F 2.0) t_0)) t_1) t_2)
(/ (- (sqrt F)) (sqrt (* 0.5 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(-4.0, (C * A), (B_m * B_m));
double t_1 = -t_0;
double t_2 = sqrt((C * 2.0));
double t_3 = C * (A * 4.0);
double t_4 = sqrt((((C + A) + sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))) * ((F * (pow(B_m, 2.0) - t_3)) * 2.0))) / (t_3 - pow(B_m, 2.0));
double t_5 = fma((C * A), -4.0, (B_m * B_m));
double tmp;
if (t_4 <= -0.0005) {
tmp = (t_2 / t_1) * (sqrt(t_5) * sqrt((F * 2.0)));
} else if (t_4 <= -2e-177) {
tmp = -sqrt(((((A / B_m) - -1.0) * B_m) + C)) * ((sqrt(2.0) / B_m) * sqrt(F));
} else if (t_4 <= 1e+112) {
tmp = sqrt((((t_5 * F) * 2.0) * fma(((B_m * B_m) / A), -0.5, (C * 2.0)))) / -t_5;
} else if (t_4 <= ((double) INFINITY)) {
tmp = (sqrt(((F * 2.0) * t_0)) / t_1) * t_2;
} else {
tmp = -sqrt(F) / sqrt((0.5 * 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(-4.0, Float64(C * A), Float64(B_m * B_m)) t_1 = Float64(-t_0) t_2 = sqrt(Float64(C * 2.0)) t_3 = Float64(C * Float64(A * 4.0)) t_4 = Float64(sqrt(Float64(Float64(Float64(C + A) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_3)) * 2.0))) / Float64(t_3 - (B_m ^ 2.0))) t_5 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) tmp = 0.0 if (t_4 <= -0.0005) tmp = Float64(Float64(t_2 / t_1) * Float64(sqrt(t_5) * sqrt(Float64(F * 2.0)))); elseif (t_4 <= -2e-177) tmp = Float64(Float64(-sqrt(Float64(Float64(Float64(Float64(A / B_m) - -1.0) * B_m) + C))) * Float64(Float64(sqrt(2.0) / B_m) * sqrt(F))); elseif (t_4 <= 1e+112) tmp = Float64(sqrt(Float64(Float64(Float64(t_5 * F) * 2.0) * fma(Float64(Float64(B_m * B_m) / A), -0.5, Float64(C * 2.0)))) / Float64(-t_5)); elseif (t_4 <= Inf) tmp = Float64(Float64(sqrt(Float64(Float64(F * 2.0) * t_0)) / t_1) * t_2); else tmp = Float64(Float64(-sqrt(F)) / sqrt(Float64(0.5 * 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[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = (-t$95$0)}, Block[{t$95$2 = N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$3 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[Sqrt[N[(N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$3), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$3 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$4, -0.0005], N[(N[(t$95$2 / t$95$1), $MachinePrecision] * N[(N[Sqrt[t$95$5], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, -2e-177], N[((-N[Sqrt[N[(N[(N[(N[(A / B$95$m), $MachinePrecision] - -1.0), $MachinePrecision] * B$95$m), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision]) * N[(N[(N[Sqrt[2.0], $MachinePrecision] / B$95$m), $MachinePrecision] * N[Sqrt[F], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, 1e+112], N[(N[Sqrt[N[(N[(N[(t$95$5 * F), $MachinePrecision] * 2.0), $MachinePrecision] * N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5 + N[(C * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$5)), $MachinePrecision], If[LessEqual[t$95$4, Infinity], N[(N[(N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] * t$95$0), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision] * t$95$2), $MachinePrecision], N[((-N[Sqrt[F], $MachinePrecision]) / N[Sqrt[N[(0.5 * 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(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_1 := -t\_0\\
t_2 := \sqrt{C \cdot 2}\\
t_3 := C \cdot \left(A \cdot 4\right)\\
t_4 := \frac{\sqrt{\left(\left(C + A\right) + \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_3\right)\right) \cdot 2\right)}}{t\_3 - {B\_m}^{2}}\\
t_5 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
\mathbf{if}\;t\_4 \leq -0.0005:\\
\;\;\;\;\frac{t\_2}{t\_1} \cdot \left(\sqrt{t\_5} \cdot \sqrt{F \cdot 2}\right)\\
\mathbf{elif}\;t\_4 \leq -2 \cdot 10^{-177}:\\
\;\;\;\;\left(-\sqrt{\left(\frac{A}{B\_m} - -1\right) \cdot B\_m + C}\right) \cdot \left(\frac{\sqrt{2}}{B\_m} \cdot \sqrt{F}\right)\\
\mathbf{elif}\;t\_4 \leq 10^{+112}:\\
\;\;\;\;\frac{\sqrt{\left(\left(t\_5 \cdot F\right) \cdot 2\right) \cdot \mathsf{fma}\left(\frac{B\_m \cdot B\_m}{A}, -0.5, C \cdot 2\right)}}{-t\_5}\\
\mathbf{elif}\;t\_4 \leq \infty:\\
\;\;\;\;\frac{\sqrt{\left(F \cdot 2\right) \cdot t\_0}}{t\_1} \cdot t\_2\\
\mathbf{else}:\\
\;\;\;\;\frac{-\sqrt{F}}{\sqrt{0.5 \cdot B\_m}}\\
\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))) < -5.0000000000000001e-4Initial program 29.4%
Applied rewrites51.1%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites64.8%
Taylor expanded in C around inf
lower-*.f6435.6
Applied rewrites35.6%
if -5.0000000000000001e-4 < (/.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.9999999999999999e-177Initial program 99.0%
Applied rewrites98.8%
Taylor expanded in C around 0
lower-*.f64N/A
lower-/.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6445.3
Applied rewrites45.3%
Taylor expanded in B around inf
lower-*.f64N/A
+-commutativeN/A
lower-+.f64N/A
lower-/.f6443.3
Applied rewrites43.3%
if -1.9999999999999999e-177 < (/.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.9999999999999993e111Initial program 21.5%
Taylor expanded in A around -inf
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6428.3
Applied rewrites28.3%
Applied rewrites28.3%
if 9.9999999999999993e111 < (/.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 16.7%
Applied rewrites82.0%
Taylor expanded in C around inf
lower-*.f6448.0
Applied rewrites48.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%
Taylor expanded in B around inf
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.3
Applied rewrites15.3%
Applied rewrites15.4%
Applied rewrites15.4%
Applied rewrites21.3%
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 -4.0 (* C A) (* B_m B_m)))
(t_1 (- t_0))
(t_2 (* C (* A 4.0)))
(t_3
(/
(sqrt
(*
(+ (+ C A) (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))))
(* (* F (- (pow B_m 2.0) t_2)) 2.0)))
(- t_2 (pow B_m 2.0))))
(t_4 (sqrt (* C 2.0)))
(t_5 (- (sqrt F))))
(if (<= t_3 -0.0005)
(* (/ t_4 t_1) (* (sqrt (fma (* C A) -4.0 (* B_m B_m))) (sqrt (* F 2.0))))
(if (<= t_3 0.0)
(* t_5 (sqrt (/ 2.0 B_m)))
(if (<= t_3 INFINITY)
(* (/ (sqrt (* (* F 2.0) t_0)) t_1) t_4)
(/ t_5 (sqrt (* 0.5 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(-4.0, (C * A), (B_m * B_m));
double t_1 = -t_0;
double t_2 = C * (A * 4.0);
double t_3 = sqrt((((C + A) + sqrt((pow((A - C), 2.0) + pow(B_m, 2.0)))) * ((F * (pow(B_m, 2.0) - t_2)) * 2.0))) / (t_2 - pow(B_m, 2.0));
double t_4 = sqrt((C * 2.0));
double t_5 = -sqrt(F);
double tmp;
if (t_3 <= -0.0005) {
tmp = (t_4 / t_1) * (sqrt(fma((C * A), -4.0, (B_m * B_m))) * sqrt((F * 2.0)));
} else if (t_3 <= 0.0) {
tmp = t_5 * sqrt((2.0 / B_m));
} else if (t_3 <= ((double) INFINITY)) {
tmp = (sqrt(((F * 2.0) * t_0)) / t_1) * t_4;
} else {
tmp = t_5 / sqrt((0.5 * 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(-4.0, Float64(C * A), Float64(B_m * B_m)) t_1 = Float64(-t_0) t_2 = Float64(C * Float64(A * 4.0)) t_3 = Float64(sqrt(Float64(Float64(Float64(C + A) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0)))) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_2)) * 2.0))) / Float64(t_2 - (B_m ^ 2.0))) t_4 = sqrt(Float64(C * 2.0)) t_5 = Float64(-sqrt(F)) tmp = 0.0 if (t_3 <= -0.0005) tmp = Float64(Float64(t_4 / t_1) * Float64(sqrt(fma(Float64(C * A), -4.0, Float64(B_m * B_m))) * sqrt(Float64(F * 2.0)))); elseif (t_3 <= 0.0) tmp = Float64(t_5 * sqrt(Float64(2.0 / B_m))); elseif (t_3 <= Inf) tmp = Float64(Float64(sqrt(Float64(Float64(F * 2.0) * t_0)) / t_1) * t_4); else tmp = Float64(t_5 / sqrt(Float64(0.5 * 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[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = (-t$95$0)}, Block[{t$95$2 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(N[(N[(C + A), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$2), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$2 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$5 = (-N[Sqrt[F], $MachinePrecision])}, If[LessEqual[t$95$3, -0.0005], N[(N[(t$95$4 / t$95$1), $MachinePrecision] * N[(N[Sqrt[N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 0.0], N[(t$95$5 * N[Sqrt[N[(2.0 / B$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[(N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] * t$95$0), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision] * t$95$4), $MachinePrecision], N[(t$95$5 / N[Sqrt[N[(0.5 * 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(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_1 := -t\_0\\
t_2 := C \cdot \left(A \cdot 4\right)\\
t_3 := \frac{\sqrt{\left(\left(C + A\right) + \sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}}\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_2\right)\right) \cdot 2\right)}}{t\_2 - {B\_m}^{2}}\\
t_4 := \sqrt{C \cdot 2}\\
t_5 := -\sqrt{F}\\
\mathbf{if}\;t\_3 \leq -0.0005:\\
\;\;\;\;\frac{t\_4}{t\_1} \cdot \left(\sqrt{\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)} \cdot \sqrt{F \cdot 2}\right)\\
\mathbf{elif}\;t\_3 \leq 0:\\
\;\;\;\;t\_5 \cdot \sqrt{\frac{2}{B\_m}}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\frac{\sqrt{\left(F \cdot 2\right) \cdot t\_0}}{t\_1} \cdot t\_4\\
\mathbf{else}:\\
\;\;\;\;\frac{t\_5}{\sqrt{0.5 \cdot B\_m}}\\
\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))) < -5.0000000000000001e-4Initial program 29.4%
Applied rewrites51.1%
lift-/.f64N/A
frac-2negN/A
metadata-evalN/A
/-rgt-identityN/A
lift-sqrt.f64N/A
pow1/2N/A
lift-*.f64N/A
unpow-prod-downN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
pow1/2N/A
lower-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lower-*.f64N/A
lower-neg.f64N/A
pow1/2N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
Applied rewrites64.8%
Taylor expanded in C around inf
lower-*.f6435.6
Applied rewrites35.6%
if -5.0000000000000001e-4 < (/.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))) < -0.0Initial program 45.1%
Taylor expanded in B around inf
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6417.2
Applied rewrites17.2%
Applied rewrites17.4%
Applied rewrites19.8%
if -0.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))) < +inf.0Initial program 36.7%
Applied rewrites86.2%
Taylor expanded in C around inf
lower-*.f6447.7
Applied rewrites47.7%
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
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6415.3
Applied rewrites15.3%
Applied rewrites15.4%
Applied rewrites15.4%
Applied rewrites21.3%
Final simplification27.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
(let* ((t_0 (fma -4.0 (* C A) (* B_m B_m))))
(if (<= B_m 0.054)
(* (/ (sqrt (* (* F 2.0) t_0)) (- t_0)) (sqrt (* C 2.0)))
(/ (- (sqrt F)) (sqrt (* 0.5 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(-4.0, (C * A), (B_m * B_m));
double tmp;
if (B_m <= 0.054) {
tmp = (sqrt(((F * 2.0) * t_0)) / -t_0) * sqrt((C * 2.0));
} else {
tmp = -sqrt(F) / sqrt((0.5 * 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(-4.0, Float64(C * A), Float64(B_m * B_m)) tmp = 0.0 if (B_m <= 0.054) tmp = Float64(Float64(sqrt(Float64(Float64(F * 2.0) * t_0)) / Float64(-t_0)) * sqrt(Float64(C * 2.0))); else tmp = Float64(Float64(-sqrt(F)) / sqrt(Float64(0.5 * 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[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 0.054], N[(N[(N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] * t$95$0), $MachinePrecision]], $MachinePrecision] / (-t$95$0)), $MachinePrecision] * N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[((-N[Sqrt[F], $MachinePrecision]) / N[Sqrt[N[(0.5 * 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(-4, C \cdot A, B\_m \cdot B\_m\right)\\
\mathbf{if}\;B\_m \leq 0.054:\\
\;\;\;\;\frac{\sqrt{\left(F \cdot 2\right) \cdot t\_0}}{-t\_0} \cdot \sqrt{C \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{-\sqrt{F}}{\sqrt{0.5 \cdot B\_m}}\\
\end{array}
\end{array}
if B < 0.0539999999999999994Initial program 23.5%
Applied rewrites35.9%
Taylor expanded in C around inf
lower-*.f6418.7
Applied rewrites18.7%
if 0.0539999999999999994 < B Initial program 17.9%
Taylor expanded in B around inf
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6440.3
Applied rewrites40.3%
Applied rewrites40.7%
Applied rewrites40.7%
Applied rewrites53.3%
Final simplification26.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 (if (<= C 7e+180) (* (- (sqrt F)) (sqrt (/ 2.0 B_m))) (* (- (sqrt (* C 2.0))) (* (/ (sqrt 2.0) B_m) (sqrt F)))))
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 (C <= 7e+180) {
tmp = -sqrt(F) * sqrt((2.0 / B_m));
} else {
tmp = -sqrt((C * 2.0)) * ((sqrt(2.0) / B_m) * sqrt(F));
}
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 (c <= 7d+180) then
tmp = -sqrt(f) * sqrt((2.0d0 / b_m))
else
tmp = -sqrt((c * 2.0d0)) * ((sqrt(2.0d0) / b_m) * sqrt(f))
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 (C <= 7e+180) {
tmp = -Math.sqrt(F) * Math.sqrt((2.0 / B_m));
} else {
tmp = -Math.sqrt((C * 2.0)) * ((Math.sqrt(2.0) / B_m) * Math.sqrt(F));
}
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 C <= 7e+180: tmp = -math.sqrt(F) * math.sqrt((2.0 / B_m)) else: tmp = -math.sqrt((C * 2.0)) * ((math.sqrt(2.0) / B_m) * math.sqrt(F)) 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 (C <= 7e+180) tmp = Float64(Float64(-sqrt(F)) * sqrt(Float64(2.0 / B_m))); else tmp = Float64(Float64(-sqrt(Float64(C * 2.0))) * Float64(Float64(sqrt(2.0) / B_m) * sqrt(F))); 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 (C <= 7e+180)
tmp = -sqrt(F) * sqrt((2.0 / B_m));
else
tmp = -sqrt((C * 2.0)) * ((sqrt(2.0) / B_m) * sqrt(F));
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[C, 7e+180], N[((-N[Sqrt[F], $MachinePrecision]) * N[Sqrt[N[(2.0 / B$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[((-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision]) * N[(N[(N[Sqrt[2.0], $MachinePrecision] / B$95$m), $MachinePrecision] * N[Sqrt[F], $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}\;C \leq 7 \cdot 10^{+180}:\\
\;\;\;\;\left(-\sqrt{F}\right) \cdot \sqrt{\frac{2}{B\_m}}\\
\mathbf{else}:\\
\;\;\;\;\left(-\sqrt{C \cdot 2}\right) \cdot \left(\frac{\sqrt{2}}{B\_m} \cdot \sqrt{F}\right)\\
\end{array}
\end{array}
if C < 6.9999999999999996e180Initial program 24.8%
Taylor expanded in B around inf
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6414.1
Applied rewrites14.1%
Applied rewrites14.2%
Applied rewrites17.5%
if 6.9999999999999996e180 < C Initial program 1.5%
Applied rewrites28.9%
Taylor expanded in C around 0
lower-*.f64N/A
lower-/.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f648.2
Applied rewrites8.2%
Taylor expanded in C around inf
lower-*.f648.2
Applied rewrites8.2%
Final simplification16.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 (/ (- (sqrt F)) (sqrt (* 0.5 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) / sqrt((0.5 * 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) / sqrt((0.5d0 * 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) / Math.sqrt((0.5 * 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) / math.sqrt((0.5 * 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(Float64(-sqrt(F)) / sqrt(Float64(0.5 * 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) / sqrt((0.5 * 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[((-N[Sqrt[F], $MachinePrecision]) / N[Sqrt[N[(0.5 * 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])\\
\\
\frac{-\sqrt{F}}{\sqrt{0.5 \cdot B\_m}}
\end{array}
Initial program 22.2%
Taylor expanded in B around inf
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6412.8
Applied rewrites12.8%
Applied rewrites12.9%
Applied rewrites12.9%
Applied rewrites16.1%
Final simplification16.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 (* (- (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) {
return -sqrt(F) * sqrt((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) * sqrt((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) * Math.sqrt((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) * math.sqrt((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(Float64(-sqrt(F)) * sqrt(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) * sqrt((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[((-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])\\
\\
\left(-\sqrt{F}\right) \cdot \sqrt{\frac{2}{B\_m}}
\end{array}
Initial program 22.2%
Taylor expanded in B around inf
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6412.8
Applied rewrites12.8%
Applied rewrites12.9%
Applied rewrites16.1%
Final simplification16.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 (- (sqrt (* (/ 2.0 B_m) F))))
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(((2.0 / B_m) * F));
}
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(((2.0d0 / b_m) * f))
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(((2.0 / B_m) * F));
}
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(((2.0 / B_m) * F))
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(Float64(2.0 / B_m) * F))) 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(((2.0 / B_m) * F));
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[(N[(2.0 / B$95$m), $MachinePrecision] * F), $MachinePrecision]], $MachinePrecision])
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
-\sqrt{\frac{2}{B\_m} \cdot F}
\end{array}
Initial program 22.2%
Taylor expanded in B around inf
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f6412.8
Applied rewrites12.8%
Applied rewrites12.9%
Applied rewrites12.9%
herbie shell --seed 2024264
(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))))