
(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 29 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 -4.0 (* C A) (* B_m B_m)))
(t_3
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_0)) 2.0)))
t_1))
(t_4 (hypot (- A C) B_m)))
(if (<= t_3 (- INFINITY))
(/
(- (sqrt (* C 2.0)))
(pow
(* (pow (fma (* C A) -4.0 (* B_m B_m)) -0.5) (sqrt (* F 2.0)))
-1.0))
(if (<= t_3 -2e-227)
(*
(sqrt (- C (/ (- (pow t_4 2.0) (* A A)) (- A t_4))))
(/ (sqrt (* t_2 (* F 2.0))) (- t_2)))
(if (<= t_3 0.0)
(/
(*
(sqrt F)
(sqrt (* (* t_2 2.0) (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C))))
t_1)
(if (<= t_3 INFINITY)
(/ (* (sqrt (* t_2 F)) (sqrt (* (+ (+ t_4 A) C) 2.0))) t_1)
(*
(* (/ -1.0 B_m) (sqrt (* (+ (hypot C B_m) C) 2.0)))
(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 t_0 = C * (A * 4.0);
double t_1 = t_0 - pow(B_m, 2.0);
double t_2 = fma(-4.0, (C * A), (B_m * B_m));
double t_3 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_0)) * 2.0))) / t_1;
double t_4 = hypot((A - C), B_m);
double tmp;
if (t_3 <= -((double) INFINITY)) {
tmp = -sqrt((C * 2.0)) / pow((pow(fma((C * A), -4.0, (B_m * B_m)), -0.5) * sqrt((F * 2.0))), -1.0);
} else if (t_3 <= -2e-227) {
tmp = sqrt((C - ((pow(t_4, 2.0) - (A * A)) / (A - t_4)))) * (sqrt((t_2 * (F * 2.0))) / -t_2);
} else if (t_3 <= 0.0) {
tmp = (sqrt(F) * sqrt(((t_2 * 2.0) * (((((B_m * B_m) / A) * -0.5) + C) + C)))) / t_1;
} else if (t_3 <= ((double) INFINITY)) {
tmp = (sqrt((t_2 * F)) * sqrt((((t_4 + A) + C) * 2.0))) / t_1;
} else {
tmp = ((-1.0 / B_m) * sqrt(((hypot(C, B_m) + C) * 2.0))) * 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) t_0 = Float64(C * Float64(A * 4.0)) t_1 = Float64(t_0 - (B_m ^ 2.0)) t_2 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_3 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_0)) * 2.0))) / t_1) t_4 = hypot(Float64(A - C), B_m) tmp = 0.0 if (t_3 <= Float64(-Inf)) tmp = Float64(Float64(-sqrt(Float64(C * 2.0))) / (Float64((fma(Float64(C * A), -4.0, Float64(B_m * B_m)) ^ -0.5) * sqrt(Float64(F * 2.0))) ^ -1.0)); elseif (t_3 <= -2e-227) tmp = Float64(sqrt(Float64(C - Float64(Float64((t_4 ^ 2.0) - Float64(A * A)) / Float64(A - t_4)))) * Float64(sqrt(Float64(t_2 * Float64(F * 2.0))) / Float64(-t_2))); elseif (t_3 <= 0.0) tmp = Float64(Float64(sqrt(F) * sqrt(Float64(Float64(t_2 * 2.0) * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C)))) / t_1); elseif (t_3 <= Inf) tmp = Float64(Float64(sqrt(Float64(t_2 * F)) * sqrt(Float64(Float64(Float64(t_4 + A) + C) * 2.0))) / t_1); else tmp = Float64(Float64(Float64(-1.0 / B_m) * sqrt(Float64(Float64(hypot(C, B_m) + C) * 2.0))) * sqrt(F)); 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[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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$4 = N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision]}, If[LessEqual[t$95$3, (-Infinity)], N[((-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision]) / N[Power[N[(N[Power[N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -2e-227], N[(N[Sqrt[N[(C - N[(N[(N[Power[t$95$4, 2.0], $MachinePrecision] - N[(A * A), $MachinePrecision]), $MachinePrecision] / N[(A - t$95$4), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Sqrt[N[(t$95$2 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$2)), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 0.0], N[(N[(N[Sqrt[F], $MachinePrecision] * N[Sqrt[N[(N[(t$95$2 * 2.0), $MachinePrecision] * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[(N[Sqrt[N[(t$95$2 * F), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(N[(N[(t$95$4 + A), $MachinePrecision] + C), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], N[(N[(N[(-1.0 / B$95$m), $MachinePrecision] * N[Sqrt[N[(N[(N[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[F], $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(-4, C \cdot A, B\_m \cdot B\_m\right)\\
t_3 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_0\right)\right) \cdot 2\right)}}{t\_1}\\
t_4 := \mathsf{hypot}\left(A - C, B\_m\right)\\
\mathbf{if}\;t\_3 \leq -\infty:\\
\;\;\;\;\frac{-\sqrt{C \cdot 2}}{{\left({\left(\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\right)}^{-0.5} \cdot \sqrt{F \cdot 2}\right)}^{-1}}\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\sqrt{C - \frac{{t\_4}^{2} - A \cdot A}{A - t\_4}} \cdot \frac{\sqrt{t\_2 \cdot \left(F \cdot 2\right)}}{-t\_2}\\
\mathbf{elif}\;t\_3 \leq 0:\\
\;\;\;\;\frac{\sqrt{F} \cdot \sqrt{\left(t\_2 \cdot 2\right) \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{t\_1}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_2 \cdot F} \cdot \sqrt{\left(\left(t\_4 + A\right) + C\right) \cdot 2}}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{-1}{B\_m} \cdot \sqrt{\left(\mathsf{hypot}\left(C, B\_m\right) + C\right) \cdot 2}\right) \cdot \sqrt{F}\\
\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 rewrites33.8%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.4
Applied rewrites22.4%
Applied rewrites32.5%
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.99999999999999989e-227Initial program 97.2%
Applied rewrites97.2%
lift-+.f64N/A
flip-+N/A
lower-/.f64N/A
lower--.f64N/A
pow2N/A
lower-pow.f64N/A
lower-*.f64N/A
lower--.f6490.3
Applied rewrites90.3%
if -1.99999999999999989e-227 < (/.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.5%
lift-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*r*N/A
sqrt-prodN/A
pow1/2N/A
Applied rewrites16.4%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6429.3
Applied rewrites29.3%
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 34.1%
lift-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
sqrt-prodN/A
pow1/2N/A
lower-*.f64N/A
Applied rewrites86.6%
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 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.f6416.9
Applied rewrites16.9%
Applied rewrites24.8%
Applied rewrites24.9%
Final simplification40.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
(let* ((t_0 (fma -4.0 (* C A) (* B_m B_m)))
(t_1 (+ (+ (hypot (- A C) B_m) A) C))
(t_2 (* C (* A 4.0)))
(t_3 (- t_2 (pow B_m 2.0)))
(t_4
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_2)) 2.0)))
t_3)))
(if (<= t_4 -5e+202)
(/
(- (sqrt (* C 2.0)))
(pow
(* (pow (fma (* C A) -4.0 (* B_m B_m)) -0.5) (sqrt (* F 2.0)))
-1.0))
(if (<= t_4 -2e-227)
(* (/ -1.0 t_0) (sqrt (* t_1 (* t_0 (* F 2.0)))))
(if (<= t_4 0.0)
(/
(*
(sqrt F)
(sqrt (* (* t_0 2.0) (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C))))
t_3)
(if (<= t_4 INFINITY)
(/ (* (sqrt (* t_0 F)) (sqrt (* t_1 2.0))) t_3)
(*
(* (/ -1.0 B_m) (sqrt (* (+ (hypot C B_m) C) 2.0)))
(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 t_0 = fma(-4.0, (C * A), (B_m * B_m));
double t_1 = (hypot((A - C), B_m) + A) + C;
double t_2 = C * (A * 4.0);
double t_3 = t_2 - pow(B_m, 2.0);
double t_4 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_2)) * 2.0))) / t_3;
double tmp;
if (t_4 <= -5e+202) {
tmp = -sqrt((C * 2.0)) / pow((pow(fma((C * A), -4.0, (B_m * B_m)), -0.5) * sqrt((F * 2.0))), -1.0);
} else if (t_4 <= -2e-227) {
tmp = (-1.0 / t_0) * sqrt((t_1 * (t_0 * (F * 2.0))));
} else if (t_4 <= 0.0) {
tmp = (sqrt(F) * sqrt(((t_0 * 2.0) * (((((B_m * B_m) / A) * -0.5) + C) + C)))) / t_3;
} else if (t_4 <= ((double) INFINITY)) {
tmp = (sqrt((t_0 * F)) * sqrt((t_1 * 2.0))) / t_3;
} else {
tmp = ((-1.0 / B_m) * sqrt(((hypot(C, B_m) + C) * 2.0))) * 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) t_0 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_1 = Float64(Float64(hypot(Float64(A - C), B_m) + A) + C) t_2 = Float64(C * Float64(A * 4.0)) t_3 = Float64(t_2 - (B_m ^ 2.0)) t_4 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_2)) * 2.0))) / t_3) tmp = 0.0 if (t_4 <= -5e+202) tmp = Float64(Float64(-sqrt(Float64(C * 2.0))) / (Float64((fma(Float64(C * A), -4.0, Float64(B_m * B_m)) ^ -0.5) * sqrt(Float64(F * 2.0))) ^ -1.0)); elseif (t_4 <= -2e-227) tmp = Float64(Float64(-1.0 / t_0) * sqrt(Float64(t_1 * Float64(t_0 * Float64(F * 2.0))))); elseif (t_4 <= 0.0) tmp = Float64(Float64(sqrt(F) * sqrt(Float64(Float64(t_0 * 2.0) * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C)))) / t_3); elseif (t_4 <= Inf) tmp = Float64(Float64(sqrt(Float64(t_0 * F)) * sqrt(Float64(t_1 * 2.0))) / t_3); else tmp = Float64(Float64(Float64(-1.0 / B_m) * sqrt(Float64(Float64(hypot(C, B_m) + C) * 2.0))) * sqrt(F)); 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 = N[(N[(N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision] + A), $MachinePrecision] + C), $MachinePrecision]}, Block[{t$95$2 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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$3), $MachinePrecision]}, If[LessEqual[t$95$4, -5e+202], N[((-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision]) / N[Power[N[(N[Power[N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, -2e-227], N[(N[(-1.0 / t$95$0), $MachinePrecision] * N[Sqrt[N[(t$95$1 * N[(t$95$0 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, 0.0], N[(N[(N[Sqrt[F], $MachinePrecision] * N[Sqrt[N[(N[(t$95$0 * 2.0), $MachinePrecision] * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$3), $MachinePrecision], If[LessEqual[t$95$4, Infinity], N[(N[(N[Sqrt[N[(t$95$0 * F), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(t$95$1 * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$3), $MachinePrecision], N[(N[(N[(-1.0 / B$95$m), $MachinePrecision] * N[Sqrt[N[(N[(N[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[F], $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 := \left(\mathsf{hypot}\left(A - C, B\_m\right) + A\right) + C\\
t_2 := C \cdot \left(A \cdot 4\right)\\
t_3 := t\_2 - {B\_m}^{2}\\
t_4 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_2\right)\right) \cdot 2\right)}}{t\_3}\\
\mathbf{if}\;t\_4 \leq -5 \cdot 10^{+202}:\\
\;\;\;\;\frac{-\sqrt{C \cdot 2}}{{\left({\left(\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\right)}^{-0.5} \cdot \sqrt{F \cdot 2}\right)}^{-1}}\\
\mathbf{elif}\;t\_4 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{-1}{t\_0} \cdot \sqrt{t\_1 \cdot \left(t\_0 \cdot \left(F \cdot 2\right)\right)}\\
\mathbf{elif}\;t\_4 \leq 0:\\
\;\;\;\;\frac{\sqrt{F} \cdot \sqrt{\left(t\_0 \cdot 2\right) \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{t\_3}\\
\mathbf{elif}\;t\_4 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_0 \cdot F} \cdot \sqrt{t\_1 \cdot 2}}{t\_3}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{-1}{B\_m} \cdot \sqrt{\left(\mathsf{hypot}\left(C, B\_m\right) + C\right) \cdot 2}\right) \cdot \sqrt{F}\\
\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))) < -4.9999999999999999e202Initial program 4.7%
Applied rewrites34.9%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.1
Applied rewrites22.1%
Applied rewrites32.0%
if -4.9999999999999999e202 < (/.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.99999999999999989e-227Initial program 97.1%
Applied rewrites97.3%
if -1.99999999999999989e-227 < (/.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.5%
lift-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*r*N/A
sqrt-prodN/A
pow1/2N/A
Applied rewrites16.4%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6429.3
Applied rewrites29.3%
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 34.1%
lift-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
associate-*r*N/A
sqrt-prodN/A
pow1/2N/A
lower-*.f64N/A
Applied rewrites86.6%
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 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.f6416.9
Applied rewrites16.9%
Applied rewrites24.8%
Applied rewrites24.9%
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 (fma -4.0 (* C A) (* B_m B_m)))
(t_1 (* C (* A 4.0)))
(t_2 (- t_1 (pow B_m 2.0)))
(t_3
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_1)) 2.0)))
t_2))
(t_4 (fma (* C A) -4.0 (* B_m B_m)))
(t_5 (+ (+ (hypot (- A C) B_m) A) C)))
(if (<= t_3 -5e+202)
(/ (- (sqrt (* C 2.0))) (pow (* (pow t_4 -0.5) (sqrt (* F 2.0))) -1.0))
(if (<= t_3 -2e-227)
(* (/ -1.0 t_0) (sqrt (* t_5 (* t_0 (* F 2.0)))))
(if (<= t_3 0.0)
(/
(*
(sqrt F)
(sqrt (* (* t_0 2.0) (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C))))
t_2)
(if (<= t_3 INFINITY)
(* (sqrt t_5) (/ (* (- (sqrt 2.0)) (sqrt (* t_4 F))) t_0))
(*
(* (/ -1.0 B_m) (sqrt (* (+ (hypot C B_m) C) 2.0)))
(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 t_0 = fma(-4.0, (C * A), (B_m * B_m));
double t_1 = C * (A * 4.0);
double t_2 = t_1 - pow(B_m, 2.0);
double t_3 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_1)) * 2.0))) / t_2;
double t_4 = fma((C * A), -4.0, (B_m * B_m));
double t_5 = (hypot((A - C), B_m) + A) + C;
double tmp;
if (t_3 <= -5e+202) {
tmp = -sqrt((C * 2.0)) / pow((pow(t_4, -0.5) * sqrt((F * 2.0))), -1.0);
} else if (t_3 <= -2e-227) {
tmp = (-1.0 / t_0) * sqrt((t_5 * (t_0 * (F * 2.0))));
} else if (t_3 <= 0.0) {
tmp = (sqrt(F) * sqrt(((t_0 * 2.0) * (((((B_m * B_m) / A) * -0.5) + C) + C)))) / t_2;
} else if (t_3 <= ((double) INFINITY)) {
tmp = sqrt(t_5) * ((-sqrt(2.0) * sqrt((t_4 * F))) / t_0);
} else {
tmp = ((-1.0 / B_m) * sqrt(((hypot(C, B_m) + C) * 2.0))) * 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) t_0 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_1 = Float64(C * Float64(A * 4.0)) t_2 = Float64(t_1 - (B_m ^ 2.0)) t_3 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_1)) * 2.0))) / t_2) t_4 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) t_5 = Float64(Float64(hypot(Float64(A - C), B_m) + A) + C) tmp = 0.0 if (t_3 <= -5e+202) tmp = Float64(Float64(-sqrt(Float64(C * 2.0))) / (Float64((t_4 ^ -0.5) * sqrt(Float64(F * 2.0))) ^ -1.0)); elseif (t_3 <= -2e-227) tmp = Float64(Float64(-1.0 / t_0) * sqrt(Float64(t_5 * Float64(t_0 * Float64(F * 2.0))))); elseif (t_3 <= 0.0) tmp = Float64(Float64(sqrt(F) * sqrt(Float64(Float64(t_0 * 2.0) * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C)))) / t_2); elseif (t_3 <= Inf) tmp = Float64(sqrt(t_5) * Float64(Float64(Float64(-sqrt(2.0)) * sqrt(Float64(t_4 * F))) / t_0)); else tmp = Float64(Float64(Float64(-1.0 / B_m) * sqrt(Float64(Float64(hypot(C, B_m) + C) * 2.0))) * sqrt(F)); 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 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$2), $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[(N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision] + A), $MachinePrecision] + C), $MachinePrecision]}, If[LessEqual[t$95$3, -5e+202], N[((-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision]) / N[Power[N[(N[Power[t$95$4, -0.5], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], -1.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -2e-227], N[(N[(-1.0 / t$95$0), $MachinePrecision] * N[Sqrt[N[(t$95$5 * N[(t$95$0 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 0.0], N[(N[(N[Sqrt[F], $MachinePrecision] * N[Sqrt[N[(N[(t$95$0 * 2.0), $MachinePrecision] * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[Sqrt[t$95$5], $MachinePrecision] * N[(N[((-N[Sqrt[2.0], $MachinePrecision]) * N[Sqrt[N[(t$95$4 * F), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision], N[(N[(N[(-1.0 / B$95$m), $MachinePrecision] * N[Sqrt[N[(N[(N[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[F], $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 := C \cdot \left(A \cdot 4\right)\\
t_2 := t\_1 - {B\_m}^{2}\\
t_3 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_1\right)\right) \cdot 2\right)}}{t\_2}\\
t_4 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
t_5 := \left(\mathsf{hypot}\left(A - C, B\_m\right) + A\right) + C\\
\mathbf{if}\;t\_3 \leq -5 \cdot 10^{+202}:\\
\;\;\;\;\frac{-\sqrt{C \cdot 2}}{{\left({t\_4}^{-0.5} \cdot \sqrt{F \cdot 2}\right)}^{-1}}\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{-1}{t\_0} \cdot \sqrt{t\_5 \cdot \left(t\_0 \cdot \left(F \cdot 2\right)\right)}\\
\mathbf{elif}\;t\_3 \leq 0:\\
\;\;\;\;\frac{\sqrt{F} \cdot \sqrt{\left(t\_0 \cdot 2\right) \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{t\_2}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\sqrt{t\_5} \cdot \frac{\left(-\sqrt{2}\right) \cdot \sqrt{t\_4 \cdot F}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{-1}{B\_m} \cdot \sqrt{\left(\mathsf{hypot}\left(C, B\_m\right) + C\right) \cdot 2}\right) \cdot \sqrt{F}\\
\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))) < -4.9999999999999999e202Initial program 4.7%
Applied rewrites34.9%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.1
Applied rewrites22.1%
Applied rewrites32.0%
if -4.9999999999999999e202 < (/.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.99999999999999989e-227Initial program 97.1%
Applied rewrites97.3%
if -1.99999999999999989e-227 < (/.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.5%
lift-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*r*N/A
sqrt-prodN/A
pow1/2N/A
Applied rewrites16.4%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6429.3
Applied rewrites29.3%
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 34.1%
Applied rewrites86.2%
Applied rewrites86.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 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.f6416.9
Applied rewrites16.9%
Applied rewrites24.8%
Applied rewrites24.9%
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 (+ (+ (hypot (- A C) B_m) A) C))
(t_1 (* C (* A 4.0)))
(t_2 (- t_1 (pow B_m 2.0)))
(t_3
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_1)) 2.0)))
t_2))
(t_4 (fma (* C A) -4.0 (* B_m B_m)))
(t_5 (fma -4.0 (* C A) (* B_m B_m))))
(if (<= t_3 -5e+202)
(* (* (pow t_4 -0.5) (sqrt (* F 2.0))) (- (sqrt (* C 2.0))))
(if (<= t_3 -2e-227)
(* (/ -1.0 t_5) (sqrt (* t_0 (* t_5 (* F 2.0)))))
(if (<= t_3 0.0)
(/
(*
(sqrt F)
(sqrt (* (* t_5 2.0) (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C))))
t_2)
(if (<= t_3 INFINITY)
(* (sqrt t_0) (/ (* (- (sqrt 2.0)) (sqrt (* t_4 F))) t_5))
(*
(* (/ -1.0 B_m) (sqrt (* (+ (hypot C B_m) C) 2.0)))
(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 t_0 = (hypot((A - C), B_m) + A) + C;
double t_1 = C * (A * 4.0);
double t_2 = t_1 - pow(B_m, 2.0);
double t_3 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_1)) * 2.0))) / t_2;
double t_4 = fma((C * A), -4.0, (B_m * B_m));
double t_5 = fma(-4.0, (C * A), (B_m * B_m));
double tmp;
if (t_3 <= -5e+202) {
tmp = (pow(t_4, -0.5) * sqrt((F * 2.0))) * -sqrt((C * 2.0));
} else if (t_3 <= -2e-227) {
tmp = (-1.0 / t_5) * sqrt((t_0 * (t_5 * (F * 2.0))));
} else if (t_3 <= 0.0) {
tmp = (sqrt(F) * sqrt(((t_5 * 2.0) * (((((B_m * B_m) / A) * -0.5) + C) + C)))) / t_2;
} else if (t_3 <= ((double) INFINITY)) {
tmp = sqrt(t_0) * ((-sqrt(2.0) * sqrt((t_4 * F))) / t_5);
} else {
tmp = ((-1.0 / B_m) * sqrt(((hypot(C, B_m) + C) * 2.0))) * 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) t_0 = Float64(Float64(hypot(Float64(A - C), B_m) + A) + C) t_1 = Float64(C * Float64(A * 4.0)) t_2 = Float64(t_1 - (B_m ^ 2.0)) t_3 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_1)) * 2.0))) / t_2) t_4 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) t_5 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) tmp = 0.0 if (t_3 <= -5e+202) tmp = Float64(Float64((t_4 ^ -0.5) * sqrt(Float64(F * 2.0))) * Float64(-sqrt(Float64(C * 2.0)))); elseif (t_3 <= -2e-227) tmp = Float64(Float64(-1.0 / t_5) * sqrt(Float64(t_0 * Float64(t_5 * Float64(F * 2.0))))); elseif (t_3 <= 0.0) tmp = Float64(Float64(sqrt(F) * sqrt(Float64(Float64(t_5 * 2.0) * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C)))) / t_2); elseif (t_3 <= Inf) tmp = Float64(sqrt(t_0) * Float64(Float64(Float64(-sqrt(2.0)) * sqrt(Float64(t_4 * F))) / t_5)); else tmp = Float64(Float64(Float64(-1.0 / B_m) * sqrt(Float64(Float64(hypot(C, B_m) + C) * 2.0))) * sqrt(F)); 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[(N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision] + A), $MachinePrecision] + C), $MachinePrecision]}, Block[{t$95$1 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(t$95$1 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$1), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$2), $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[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$3, -5e+202], N[(N[(N[Power[t$95$4, -0.5], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * (-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], If[LessEqual[t$95$3, -2e-227], N[(N[(-1.0 / t$95$5), $MachinePrecision] * N[Sqrt[N[(t$95$0 * N[(t$95$5 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 0.0], N[(N[(N[Sqrt[F], $MachinePrecision] * N[Sqrt[N[(N[(t$95$5 * 2.0), $MachinePrecision] * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[Sqrt[t$95$0], $MachinePrecision] * N[(N[((-N[Sqrt[2.0], $MachinePrecision]) * N[Sqrt[N[(t$95$4 * F), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$5), $MachinePrecision]), $MachinePrecision], N[(N[(N[(-1.0 / B$95$m), $MachinePrecision] * N[Sqrt[N[(N[(N[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[F], $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 := \left(\mathsf{hypot}\left(A - C, B\_m\right) + A\right) + C\\
t_1 := C \cdot \left(A \cdot 4\right)\\
t_2 := t\_1 - {B\_m}^{2}\\
t_3 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_1\right)\right) \cdot 2\right)}}{t\_2}\\
t_4 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
t_5 := \mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)\\
\mathbf{if}\;t\_3 \leq -5 \cdot 10^{+202}:\\
\;\;\;\;\left({t\_4}^{-0.5} \cdot \sqrt{F \cdot 2}\right) \cdot \left(-\sqrt{C \cdot 2}\right)\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{-1}{t\_5} \cdot \sqrt{t\_0 \cdot \left(t\_5 \cdot \left(F \cdot 2\right)\right)}\\
\mathbf{elif}\;t\_3 \leq 0:\\
\;\;\;\;\frac{\sqrt{F} \cdot \sqrt{\left(t\_5 \cdot 2\right) \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{t\_2}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\sqrt{t\_0} \cdot \frac{\left(-\sqrt{2}\right) \cdot \sqrt{t\_4 \cdot F}}{t\_5}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{-1}{B\_m} \cdot \sqrt{\left(\mathsf{hypot}\left(C, B\_m\right) + C\right) \cdot 2}\right) \cdot \sqrt{F}\\
\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))) < -4.9999999999999999e202Initial program 4.7%
Applied rewrites34.9%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.1
Applied rewrites22.1%
Applied rewrites32.0%
if -4.9999999999999999e202 < (/.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.99999999999999989e-227Initial program 97.1%
Applied rewrites97.3%
if -1.99999999999999989e-227 < (/.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.5%
lift-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*r*N/A
sqrt-prodN/A
pow1/2N/A
Applied rewrites16.4%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6429.3
Applied rewrites29.3%
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 34.1%
Applied rewrites86.2%
Applied rewrites86.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 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.f6416.9
Applied rewrites16.9%
Applied rewrites24.8%
Applied rewrites24.9%
Final simplification40.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 (- (sqrt (* C 2.0))))
(t_2 (* C (* A 4.0)))
(t_3 (- t_2 (pow B_m 2.0)))
(t_4
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_2)) 2.0)))
t_3))
(t_5 (* t_0 (* F 2.0))))
(if (<= t_4 -5e+202)
(* (* (pow (fma (* C A) -4.0 (* B_m B_m)) -0.5) (sqrt (* F 2.0))) t_1)
(if (<= t_4 -2e-227)
(* (/ -1.0 t_0) (sqrt (* (+ (+ (hypot (- A C) B_m) A) C) t_5)))
(if (<= t_4 0.0)
(/
(*
(sqrt F)
(sqrt (* (* t_0 2.0) (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C))))
t_3)
(if (<= t_4 INFINITY)
(* (/ (sqrt t_5) t_0) t_1)
(*
(* (/ -1.0 B_m) (sqrt (* (+ (hypot C B_m) C) 2.0)))
(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 t_0 = fma(-4.0, (C * A), (B_m * B_m));
double t_1 = -sqrt((C * 2.0));
double t_2 = C * (A * 4.0);
double t_3 = t_2 - pow(B_m, 2.0);
double t_4 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_2)) * 2.0))) / t_3;
double t_5 = t_0 * (F * 2.0);
double tmp;
if (t_4 <= -5e+202) {
tmp = (pow(fma((C * A), -4.0, (B_m * B_m)), -0.5) * sqrt((F * 2.0))) * t_1;
} else if (t_4 <= -2e-227) {
tmp = (-1.0 / t_0) * sqrt((((hypot((A - C), B_m) + A) + C) * t_5));
} else if (t_4 <= 0.0) {
tmp = (sqrt(F) * sqrt(((t_0 * 2.0) * (((((B_m * B_m) / A) * -0.5) + C) + C)))) / t_3;
} else if (t_4 <= ((double) INFINITY)) {
tmp = (sqrt(t_5) / t_0) * t_1;
} else {
tmp = ((-1.0 / B_m) * sqrt(((hypot(C, B_m) + C) * 2.0))) * 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) t_0 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_1 = Float64(-sqrt(Float64(C * 2.0))) t_2 = Float64(C * Float64(A * 4.0)) t_3 = Float64(t_2 - (B_m ^ 2.0)) t_4 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_2)) * 2.0))) / t_3) t_5 = Float64(t_0 * Float64(F * 2.0)) tmp = 0.0 if (t_4 <= -5e+202) tmp = Float64(Float64((fma(Float64(C * A), -4.0, Float64(B_m * B_m)) ^ -0.5) * sqrt(Float64(F * 2.0))) * t_1); elseif (t_4 <= -2e-227) tmp = Float64(Float64(-1.0 / t_0) * sqrt(Float64(Float64(Float64(hypot(Float64(A - C), B_m) + A) + C) * t_5))); elseif (t_4 <= 0.0) tmp = Float64(Float64(sqrt(F) * sqrt(Float64(Float64(t_0 * 2.0) * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C)))) / t_3); elseif (t_4 <= Inf) tmp = Float64(Float64(sqrt(t_5) / t_0) * t_1); else tmp = Float64(Float64(Float64(-1.0 / B_m) * sqrt(Float64(Float64(hypot(C, B_m) + C) * 2.0))) * sqrt(F)); 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 = (-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision])}, Block[{t$95$2 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(t$95$2 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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$3), $MachinePrecision]}, Block[{t$95$5 = N[(t$95$0 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$4, -5e+202], N[(N[(N[Power[N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision], If[LessEqual[t$95$4, -2e-227], N[(N[(-1.0 / t$95$0), $MachinePrecision] * N[Sqrt[N[(N[(N[(N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision] + A), $MachinePrecision] + C), $MachinePrecision] * t$95$5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, 0.0], N[(N[(N[Sqrt[F], $MachinePrecision] * N[Sqrt[N[(N[(t$95$0 * 2.0), $MachinePrecision] * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$3), $MachinePrecision], If[LessEqual[t$95$4, Infinity], N[(N[(N[Sqrt[t$95$5], $MachinePrecision] / t$95$0), $MachinePrecision] * t$95$1), $MachinePrecision], N[(N[(N[(-1.0 / B$95$m), $MachinePrecision] * N[Sqrt[N[(N[(N[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[F], $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 := -\sqrt{C \cdot 2}\\
t_2 := C \cdot \left(A \cdot 4\right)\\
t_3 := t\_2 - {B\_m}^{2}\\
t_4 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_2\right)\right) \cdot 2\right)}}{t\_3}\\
t_5 := t\_0 \cdot \left(F \cdot 2\right)\\
\mathbf{if}\;t\_4 \leq -5 \cdot 10^{+202}:\\
\;\;\;\;\left({\left(\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\right)}^{-0.5} \cdot \sqrt{F \cdot 2}\right) \cdot t\_1\\
\mathbf{elif}\;t\_4 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{-1}{t\_0} \cdot \sqrt{\left(\left(\mathsf{hypot}\left(A - C, B\_m\right) + A\right) + C\right) \cdot t\_5}\\
\mathbf{elif}\;t\_4 \leq 0:\\
\;\;\;\;\frac{\sqrt{F} \cdot \sqrt{\left(t\_0 \cdot 2\right) \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{t\_3}\\
\mathbf{elif}\;t\_4 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_5}}{t\_0} \cdot t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{-1}{B\_m} \cdot \sqrt{\left(\mathsf{hypot}\left(C, B\_m\right) + C\right) \cdot 2}\right) \cdot \sqrt{F}\\
\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))) < -4.9999999999999999e202Initial program 4.7%
Applied rewrites34.9%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.1
Applied rewrites22.1%
Applied rewrites32.0%
if -4.9999999999999999e202 < (/.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.99999999999999989e-227Initial program 97.1%
Applied rewrites97.3%
if -1.99999999999999989e-227 < (/.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.5%
lift-sqrt.f64N/A
lift-*.f64N/A
*-commutativeN/A
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
associate-*r*N/A
sqrt-prodN/A
pow1/2N/A
Applied rewrites16.4%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6429.3
Applied rewrites29.3%
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 34.1%
Applied rewrites86.2%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6439.7
Applied rewrites39.7%
Applied rewrites39.9%
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 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.f6416.9
Applied rewrites16.9%
Applied rewrites24.8%
Applied rewrites24.9%
Final simplification36.6%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (fma -4.0 (* C A) (* B_m B_m)))
(t_1 (- (sqrt (* C 2.0))))
(t_2 (* C (* A 4.0)))
(t_3
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_2)) 2.0)))
(- t_2 (pow B_m 2.0))))
(t_4 (* t_0 (* F 2.0))))
(if (<= t_3 -5e+202)
(* (* (pow (fma (* C A) -4.0 (* B_m B_m)) -0.5) (sqrt (* F 2.0))) t_1)
(if (<= t_3 -2e-227)
(* (/ -1.0 t_0) (sqrt (* (+ (+ (hypot (- A C) B_m) A) C) t_4)))
(if (<= t_3 5.0)
(*
(/
(sqrt (* (* t_0 F) (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C)))
(- t_0))
(sqrt 2.0))
(if (<= t_3 INFINITY)
(* (/ (sqrt t_4) t_0) t_1)
(*
(* (/ -1.0 B_m) (sqrt (* (+ (hypot C B_m) C) 2.0)))
(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 t_0 = fma(-4.0, (C * A), (B_m * B_m));
double t_1 = -sqrt((C * 2.0));
double t_2 = C * (A * 4.0);
double t_3 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_2)) * 2.0))) / (t_2 - pow(B_m, 2.0));
double t_4 = t_0 * (F * 2.0);
double tmp;
if (t_3 <= -5e+202) {
tmp = (pow(fma((C * A), -4.0, (B_m * B_m)), -0.5) * sqrt((F * 2.0))) * t_1;
} else if (t_3 <= -2e-227) {
tmp = (-1.0 / t_0) * sqrt((((hypot((A - C), B_m) + A) + C) * t_4));
} else if (t_3 <= 5.0) {
tmp = (sqrt(((t_0 * F) * (((((B_m * B_m) / A) * -0.5) + C) + C))) / -t_0) * sqrt(2.0);
} else if (t_3 <= ((double) INFINITY)) {
tmp = (sqrt(t_4) / t_0) * t_1;
} else {
tmp = ((-1.0 / B_m) * sqrt(((hypot(C, B_m) + C) * 2.0))) * 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) t_0 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_1 = Float64(-sqrt(Float64(C * 2.0))) t_2 = Float64(C * Float64(A * 4.0)) t_3 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_2)) * 2.0))) / Float64(t_2 - (B_m ^ 2.0))) t_4 = Float64(t_0 * Float64(F * 2.0)) tmp = 0.0 if (t_3 <= -5e+202) tmp = Float64(Float64((fma(Float64(C * A), -4.0, Float64(B_m * B_m)) ^ -0.5) * sqrt(Float64(F * 2.0))) * t_1); elseif (t_3 <= -2e-227) tmp = Float64(Float64(-1.0 / t_0) * sqrt(Float64(Float64(Float64(hypot(Float64(A - C), B_m) + A) + C) * t_4))); elseif (t_3 <= 5.0) tmp = Float64(Float64(sqrt(Float64(Float64(t_0 * F) * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C))) / Float64(-t_0)) * sqrt(2.0)); elseif (t_3 <= Inf) tmp = Float64(Float64(sqrt(t_4) / t_0) * t_1); else tmp = Float64(Float64(Float64(-1.0 / B_m) * sqrt(Float64(Float64(hypot(C, B_m) + C) * 2.0))) * sqrt(F)); 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 = (-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision])}, Block[{t$95$2 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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[(t$95$0 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$3, -5e+202], N[(N[(N[Power[N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision], If[LessEqual[t$95$3, -2e-227], N[(N[(-1.0 / t$95$0), $MachinePrecision] * N[Sqrt[N[(N[(N[(N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision] + A), $MachinePrecision] + C), $MachinePrecision] * t$95$4), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 5.0], N[(N[(N[Sqrt[N[(N[(t$95$0 * F), $MachinePrecision] * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$0)), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[(N[Sqrt[t$95$4], $MachinePrecision] / t$95$0), $MachinePrecision] * t$95$1), $MachinePrecision], N[(N[(N[(-1.0 / B$95$m), $MachinePrecision] * N[Sqrt[N[(N[(N[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[F], $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 := -\sqrt{C \cdot 2}\\
t_2 := C \cdot \left(A \cdot 4\right)\\
t_3 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_2\right)\right) \cdot 2\right)}}{t\_2 - {B\_m}^{2}}\\
t_4 := t\_0 \cdot \left(F \cdot 2\right)\\
\mathbf{if}\;t\_3 \leq -5 \cdot 10^{+202}:\\
\;\;\;\;\left({\left(\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\right)}^{-0.5} \cdot \sqrt{F \cdot 2}\right) \cdot t\_1\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{-1}{t\_0} \cdot \sqrt{\left(\left(\mathsf{hypot}\left(A - C, B\_m\right) + A\right) + C\right) \cdot t\_4}\\
\mathbf{elif}\;t\_3 \leq 5:\\
\;\;\;\;\frac{\sqrt{\left(t\_0 \cdot F\right) \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{-t\_0} \cdot \sqrt{2}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_4}}{t\_0} \cdot t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{-1}{B\_m} \cdot \sqrt{\left(\mathsf{hypot}\left(C, B\_m\right) + C\right) \cdot 2}\right) \cdot \sqrt{F}\\
\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))) < -4.9999999999999999e202Initial program 4.7%
Applied rewrites34.9%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.1
Applied rewrites22.1%
Applied rewrites32.0%
if -4.9999999999999999e202 < (/.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.99999999999999989e-227Initial program 97.1%
Applied rewrites97.3%
if -1.99999999999999989e-227 < (/.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))) < 5Initial program 7.6%
Applied rewrites11.9%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6429.5
Applied rewrites29.5%
if 5 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 27.5%
Applied rewrites85.0%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6442.5
Applied rewrites42.5%
Applied rewrites42.8%
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 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.f6416.9
Applied rewrites16.9%
Applied rewrites24.8%
Applied rewrites24.9%
Final simplification36.7%
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 (* F 2.0)))
(t_2 (- t_0))
(t_3 (* C (* A 4.0)))
(t_4
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_3)) 2.0)))
(- t_3 (pow B_m 2.0))))
(t_5 (- (sqrt (* C 2.0)))))
(if (<= t_4 (- INFINITY))
(* (* (pow (fma (* C A) -4.0 (* B_m B_m)) -0.5) (sqrt (* F 2.0))) t_5)
(if (<= t_4 -2e-227)
(/ (sqrt (* (+ (+ (hypot (- A C) B_m) A) C) t_1)) t_2)
(if (<= t_4 5.0)
(*
(/ (sqrt (* (* t_0 F) (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C))) t_2)
(sqrt 2.0))
(if (<= t_4 INFINITY)
(* (/ (sqrt t_1) t_0) t_5)
(*
(* (/ -1.0 B_m) (sqrt (* (+ (hypot C B_m) C) 2.0)))
(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 t_0 = fma(-4.0, (C * A), (B_m * B_m));
double t_1 = t_0 * (F * 2.0);
double t_2 = -t_0;
double t_3 = C * (A * 4.0);
double t_4 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_3)) * 2.0))) / (t_3 - pow(B_m, 2.0));
double t_5 = -sqrt((C * 2.0));
double tmp;
if (t_4 <= -((double) INFINITY)) {
tmp = (pow(fma((C * A), -4.0, (B_m * B_m)), -0.5) * sqrt((F * 2.0))) * t_5;
} else if (t_4 <= -2e-227) {
tmp = sqrt((((hypot((A - C), B_m) + A) + C) * t_1)) / t_2;
} else if (t_4 <= 5.0) {
tmp = (sqrt(((t_0 * F) * (((((B_m * B_m) / A) * -0.5) + C) + C))) / t_2) * sqrt(2.0);
} else if (t_4 <= ((double) INFINITY)) {
tmp = (sqrt(t_1) / t_0) * t_5;
} else {
tmp = ((-1.0 / B_m) * sqrt(((hypot(C, B_m) + C) * 2.0))) * 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) t_0 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_1 = Float64(t_0 * Float64(F * 2.0)) t_2 = Float64(-t_0) t_3 = Float64(C * Float64(A * 4.0)) t_4 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_3)) * 2.0))) / Float64(t_3 - (B_m ^ 2.0))) t_5 = Float64(-sqrt(Float64(C * 2.0))) tmp = 0.0 if (t_4 <= Float64(-Inf)) tmp = Float64(Float64((fma(Float64(C * A), -4.0, Float64(B_m * B_m)) ^ -0.5) * sqrt(Float64(F * 2.0))) * t_5); elseif (t_4 <= -2e-227) tmp = Float64(sqrt(Float64(Float64(Float64(hypot(Float64(A - C), B_m) + A) + C) * t_1)) / t_2); elseif (t_4 <= 5.0) tmp = Float64(Float64(sqrt(Float64(Float64(t_0 * F) * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C))) / t_2) * sqrt(2.0)); elseif (t_4 <= Inf) tmp = Float64(Float64(sqrt(t_1) / t_0) * t_5); else tmp = Float64(Float64(Float64(-1.0 / B_m) * sqrt(Float64(Float64(hypot(C, B_m) + C) * 2.0))) * sqrt(F)); 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 = N[(t$95$0 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = (-t$95$0)}, Block[{t$95$3 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision])}, If[LessEqual[t$95$4, (-Infinity)], N[(N[(N[Power[N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * t$95$5), $MachinePrecision], If[LessEqual[t$95$4, -2e-227], N[(N[Sqrt[N[(N[(N[(N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision] + A), $MachinePrecision] + C), $MachinePrecision] * t$95$1), $MachinePrecision]], $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[t$95$4, 5.0], N[(N[(N[Sqrt[N[(N[(t$95$0 * F), $MachinePrecision] * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$2), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$4, Infinity], N[(N[(N[Sqrt[t$95$1], $MachinePrecision] / t$95$0), $MachinePrecision] * t$95$5), $MachinePrecision], N[(N[(N[(-1.0 / B$95$m), $MachinePrecision] * N[Sqrt[N[(N[(N[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[F], $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 \cdot \left(F \cdot 2\right)\\
t_2 := -t\_0\\
t_3 := C \cdot \left(A \cdot 4\right)\\
t_4 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_3\right)\right) \cdot 2\right)}}{t\_3 - {B\_m}^{2}}\\
t_5 := -\sqrt{C \cdot 2}\\
\mathbf{if}\;t\_4 \leq -\infty:\\
\;\;\;\;\left({\left(\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\right)}^{-0.5} \cdot \sqrt{F \cdot 2}\right) \cdot t\_5\\
\mathbf{elif}\;t\_4 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{\sqrt{\left(\left(\mathsf{hypot}\left(A - C, B\_m\right) + A\right) + C\right) \cdot t\_1}}{t\_2}\\
\mathbf{elif}\;t\_4 \leq 5:\\
\;\;\;\;\frac{\sqrt{\left(t\_0 \cdot F\right) \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{t\_2} \cdot \sqrt{2}\\
\mathbf{elif}\;t\_4 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_1}}{t\_0} \cdot t\_5\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{-1}{B\_m} \cdot \sqrt{\left(\mathsf{hypot}\left(C, B\_m\right) + C\right) \cdot 2}\right) \cdot \sqrt{F}\\
\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 rewrites33.8%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.4
Applied rewrites22.4%
Applied rewrites32.5%
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.99999999999999989e-227Initial program 97.2%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
lower-/.f64N/A
Applied rewrites97.2%
if -1.99999999999999989e-227 < (/.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))) < 5Initial program 7.6%
Applied rewrites11.9%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6429.5
Applied rewrites29.5%
if 5 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 27.5%
Applied rewrites85.0%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6442.5
Applied rewrites42.5%
Applied rewrites42.8%
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 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.f6416.9
Applied rewrites16.9%
Applied rewrites24.8%
Applied rewrites24.9%
Final simplification37.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
(let* ((t_0 (fma -4.0 (* C A) (* B_m B_m)))
(t_1 (* C (* A 4.0)))
(t_2
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_1)) 2.0)))
(- t_1 (pow B_m 2.0))))
(t_3 (- (sqrt (* C 2.0)))))
(if (<= t_2 (- INFINITY))
(* (* (pow (fma (* C A) -4.0 (* B_m B_m)) -0.5) (sqrt (* F 2.0))) t_3)
(if (<= t_2 -2e-227)
(*
(* (/ (sqrt 2.0) B_m) (sqrt F))
(- (sqrt (+ (+ (hypot (- A C) B_m) A) C))))
(if (<= t_2 5.0)
(*
(/
(sqrt (* (* t_0 F) (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C)))
(- t_0))
(sqrt 2.0))
(if (<= t_2 INFINITY)
(* (/ (sqrt (* t_0 (* F 2.0))) t_0) t_3)
(*
(* (/ -1.0 B_m) (sqrt (* (+ (hypot C B_m) C) 2.0)))
(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 t_0 = fma(-4.0, (C * A), (B_m * B_m));
double t_1 = C * (A * 4.0);
double t_2 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_1)) * 2.0))) / (t_1 - pow(B_m, 2.0));
double t_3 = -sqrt((C * 2.0));
double tmp;
if (t_2 <= -((double) INFINITY)) {
tmp = (pow(fma((C * A), -4.0, (B_m * B_m)), -0.5) * sqrt((F * 2.0))) * t_3;
} else if (t_2 <= -2e-227) {
tmp = ((sqrt(2.0) / B_m) * sqrt(F)) * -sqrt(((hypot((A - C), B_m) + A) + C));
} else if (t_2 <= 5.0) {
tmp = (sqrt(((t_0 * F) * (((((B_m * B_m) / A) * -0.5) + C) + C))) / -t_0) * sqrt(2.0);
} else if (t_2 <= ((double) INFINITY)) {
tmp = (sqrt((t_0 * (F * 2.0))) / t_0) * t_3;
} else {
tmp = ((-1.0 / B_m) * sqrt(((hypot(C, B_m) + C) * 2.0))) * 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) t_0 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_1 = Float64(C * Float64(A * 4.0)) t_2 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_1)) * 2.0))) / Float64(t_1 - (B_m ^ 2.0))) t_3 = Float64(-sqrt(Float64(C * 2.0))) tmp = 0.0 if (t_2 <= Float64(-Inf)) tmp = Float64(Float64((fma(Float64(C * A), -4.0, Float64(B_m * B_m)) ^ -0.5) * sqrt(Float64(F * 2.0))) * t_3); elseif (t_2 <= -2e-227) tmp = Float64(Float64(Float64(sqrt(2.0) / B_m) * sqrt(F)) * Float64(-sqrt(Float64(Float64(hypot(Float64(A - C), B_m) + A) + C)))); elseif (t_2 <= 5.0) tmp = Float64(Float64(sqrt(Float64(Float64(t_0 * F) * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C))) / Float64(-t_0)) * sqrt(2.0)); elseif (t_2 <= Inf) tmp = Float64(Float64(sqrt(Float64(t_0 * Float64(F * 2.0))) / t_0) * t_3); else tmp = Float64(Float64(Float64(-1.0 / B_m) * sqrt(Float64(Float64(hypot(C, B_m) + C) * 2.0))) * sqrt(F)); 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 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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$3 = (-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision])}, If[LessEqual[t$95$2, (-Infinity)], N[(N[(N[Power[N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * t$95$3), $MachinePrecision], If[LessEqual[t$95$2, -2e-227], N[(N[(N[(N[Sqrt[2.0], $MachinePrecision] / B$95$m), $MachinePrecision] * N[Sqrt[F], $MachinePrecision]), $MachinePrecision] * (-N[Sqrt[N[(N[(N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision] + A), $MachinePrecision] + C), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], If[LessEqual[t$95$2, 5.0], N[(N[(N[Sqrt[N[(N[(t$95$0 * F), $MachinePrecision] * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$0)), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, Infinity], N[(N[(N[Sqrt[N[(t$95$0 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision] * t$95$3), $MachinePrecision], N[(N[(N[(-1.0 / B$95$m), $MachinePrecision] * N[Sqrt[N[(N[(N[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[F], $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 := C \cdot \left(A \cdot 4\right)\\
t_2 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_1\right)\right) \cdot 2\right)}}{t\_1 - {B\_m}^{2}}\\
t_3 := -\sqrt{C \cdot 2}\\
\mathbf{if}\;t\_2 \leq -\infty:\\
\;\;\;\;\left({\left(\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\right)}^{-0.5} \cdot \sqrt{F \cdot 2}\right) \cdot t\_3\\
\mathbf{elif}\;t\_2 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\left(\frac{\sqrt{2}}{B\_m} \cdot \sqrt{F}\right) \cdot \left(-\sqrt{\left(\mathsf{hypot}\left(A - C, B\_m\right) + A\right) + C}\right)\\
\mathbf{elif}\;t\_2 \leq 5:\\
\;\;\;\;\frac{\sqrt{\left(t\_0 \cdot F\right) \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{-t\_0} \cdot \sqrt{2}\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_0 \cdot \left(F \cdot 2\right)}}{t\_0} \cdot t\_3\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{-1}{B\_m} \cdot \sqrt{\left(\mathsf{hypot}\left(C, B\_m\right) + C\right) \cdot 2}\right) \cdot \sqrt{F}\\
\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 rewrites33.8%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.4
Applied rewrites22.4%
Applied rewrites32.5%
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.99999999999999989e-227Initial program 97.2%
Applied rewrites97.2%
Taylor expanded in A around 0
lower-*.f64N/A
lower-/.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6438.9
Applied rewrites38.9%
if -1.99999999999999989e-227 < (/.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))) < 5Initial program 7.6%
Applied rewrites11.9%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6429.5
Applied rewrites29.5%
if 5 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 27.5%
Applied rewrites85.0%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6442.5
Applied rewrites42.5%
Applied rewrites42.8%
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 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.f6416.9
Applied rewrites16.9%
Applied rewrites24.8%
Applied rewrites24.9%
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 (- (sqrt (* C 2.0))))
(t_2 (* C (* A 4.0)))
(t_3
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_2)) 2.0)))
(- t_2 (pow B_m 2.0)))))
(if (<= t_3 -5e+202)
(* (* (pow (fma (* C A) -4.0 (* B_m B_m)) -0.5) (sqrt (* F 2.0))) t_1)
(if (<= t_3 -2e-153)
(* (sqrt (/ (* (+ (+ (hypot (- A C) B_m) C) A) F) t_0)) (- (sqrt 2.0)))
(if (<= t_3 5.0)
(*
(/
(sqrt (* (* t_0 F) (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C)))
(- t_0))
(sqrt 2.0))
(if (<= t_3 INFINITY)
(* (/ (sqrt (* t_0 (* F 2.0))) t_0) t_1)
(*
(* (/ -1.0 B_m) (sqrt (* (+ (hypot C B_m) C) 2.0)))
(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 t_0 = fma(-4.0, (C * A), (B_m * B_m));
double t_1 = -sqrt((C * 2.0));
double t_2 = C * (A * 4.0);
double t_3 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_2)) * 2.0))) / (t_2 - pow(B_m, 2.0));
double tmp;
if (t_3 <= -5e+202) {
tmp = (pow(fma((C * A), -4.0, (B_m * B_m)), -0.5) * sqrt((F * 2.0))) * t_1;
} else if (t_3 <= -2e-153) {
tmp = sqrt(((((hypot((A - C), B_m) + C) + A) * F) / t_0)) * -sqrt(2.0);
} else if (t_3 <= 5.0) {
tmp = (sqrt(((t_0 * F) * (((((B_m * B_m) / A) * -0.5) + C) + C))) / -t_0) * sqrt(2.0);
} else if (t_3 <= ((double) INFINITY)) {
tmp = (sqrt((t_0 * (F * 2.0))) / t_0) * t_1;
} else {
tmp = ((-1.0 / B_m) * sqrt(((hypot(C, B_m) + C) * 2.0))) * 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) t_0 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_1 = Float64(-sqrt(Float64(C * 2.0))) t_2 = Float64(C * Float64(A * 4.0)) t_3 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_2)) * 2.0))) / Float64(t_2 - (B_m ^ 2.0))) tmp = 0.0 if (t_3 <= -5e+202) tmp = Float64(Float64((fma(Float64(C * A), -4.0, Float64(B_m * B_m)) ^ -0.5) * sqrt(Float64(F * 2.0))) * t_1); elseif (t_3 <= -2e-153) tmp = Float64(sqrt(Float64(Float64(Float64(Float64(hypot(Float64(A - C), B_m) + C) + A) * F) / t_0)) * Float64(-sqrt(2.0))); elseif (t_3 <= 5.0) tmp = Float64(Float64(sqrt(Float64(Float64(t_0 * F) * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C))) / Float64(-t_0)) * sqrt(2.0)); elseif (t_3 <= Inf) tmp = Float64(Float64(sqrt(Float64(t_0 * Float64(F * 2.0))) / t_0) * t_1); else tmp = Float64(Float64(Float64(-1.0 / B_m) * sqrt(Float64(Float64(hypot(C, B_m) + C) * 2.0))) * sqrt(F)); 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 = (-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision])}, Block[{t$95$2 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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]}, If[LessEqual[t$95$3, -5e+202], N[(N[(N[Power[N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision], If[LessEqual[t$95$3, -2e-153], 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] / t$95$0), $MachinePrecision]], $MachinePrecision] * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision], If[LessEqual[t$95$3, 5.0], N[(N[(N[Sqrt[N[(N[(t$95$0 * F), $MachinePrecision] * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$0)), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[(N[Sqrt[N[(t$95$0 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision] * t$95$1), $MachinePrecision], N[(N[(N[(-1.0 / B$95$m), $MachinePrecision] * N[Sqrt[N[(N[(N[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[F], $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 := -\sqrt{C \cdot 2}\\
t_2 := C \cdot \left(A \cdot 4\right)\\
t_3 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_2\right)\right) \cdot 2\right)}}{t\_2 - {B\_m}^{2}}\\
\mathbf{if}\;t\_3 \leq -5 \cdot 10^{+202}:\\
\;\;\;\;\left({\left(\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\right)}^{-0.5} \cdot \sqrt{F \cdot 2}\right) \cdot t\_1\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-153}:\\
\;\;\;\;\sqrt{\frac{\left(\left(\mathsf{hypot}\left(A - C, B\_m\right) + C\right) + A\right) \cdot F}{t\_0}} \cdot \left(-\sqrt{2}\right)\\
\mathbf{elif}\;t\_3 \leq 5:\\
\;\;\;\;\frac{\sqrt{\left(t\_0 \cdot F\right) \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{-t\_0} \cdot \sqrt{2}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_0 \cdot \left(F \cdot 2\right)}}{t\_0} \cdot t\_1\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{-1}{B\_m} \cdot \sqrt{\left(\mathsf{hypot}\left(C, B\_m\right) + C\right) \cdot 2}\right) \cdot \sqrt{F}\\
\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))) < -4.9999999999999999e202Initial program 4.7%
Applied rewrites34.9%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.1
Applied rewrites22.1%
Applied rewrites32.0%
if -4.9999999999999999e202 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < -2.00000000000000008e-153Initial program 97.0%
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 rewrites97.0%
if -2.00000000000000008e-153 < (/.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))) < 5Initial program 11.3%
Applied rewrites15.4%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6428.5
Applied rewrites28.5%
if 5 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 27.5%
Applied rewrites85.0%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6442.5
Applied rewrites42.5%
Applied rewrites42.8%
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 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.f6416.9
Applied rewrites16.9%
Applied rewrites24.8%
Applied rewrites24.9%
Final simplification36.0%
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 (+ (hypot C B_m) C))
(t_1 (fma -4.0 (* C A) (* B_m B_m)))
(t_2 (* C (* A 4.0)))
(t_3
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_2)) 2.0)))
(- t_2 (pow B_m 2.0))))
(t_4 (- (sqrt (* C 2.0)))))
(if (<= t_3 (- INFINITY))
(* (* (pow (fma (* C A) -4.0 (* B_m B_m)) -0.5) (sqrt (* F 2.0))) t_4)
(if (<= t_3 -2e-227)
(/ (sqrt (* (* t_0 F) 2.0)) (- B_m))
(if (<= t_3 5.0)
(*
(/
(sqrt (* (* t_1 F) (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C)))
(- t_1))
(sqrt 2.0))
(if (<= t_3 INFINITY)
(* (/ (sqrt (* t_1 (* F 2.0))) t_1) t_4)
(* (* (/ -1.0 B_m) (sqrt (* t_0 2.0))) (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 t_0 = hypot(C, B_m) + C;
double t_1 = fma(-4.0, (C * A), (B_m * B_m));
double t_2 = C * (A * 4.0);
double t_3 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((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 tmp;
if (t_3 <= -((double) INFINITY)) {
tmp = (pow(fma((C * A), -4.0, (B_m * B_m)), -0.5) * sqrt((F * 2.0))) * t_4;
} else if (t_3 <= -2e-227) {
tmp = sqrt(((t_0 * F) * 2.0)) / -B_m;
} else if (t_3 <= 5.0) {
tmp = (sqrt(((t_1 * F) * (((((B_m * B_m) / A) * -0.5) + C) + C))) / -t_1) * sqrt(2.0);
} else if (t_3 <= ((double) INFINITY)) {
tmp = (sqrt((t_1 * (F * 2.0))) / t_1) * t_4;
} else {
tmp = ((-1.0 / B_m) * sqrt((t_0 * 2.0))) * 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) t_0 = Float64(hypot(C, B_m) + C) t_1 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_2 = Float64(C * Float64(A * 4.0)) t_3 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_2)) * 2.0))) / Float64(t_2 - (B_m ^ 2.0))) t_4 = Float64(-sqrt(Float64(C * 2.0))) tmp = 0.0 if (t_3 <= Float64(-Inf)) tmp = Float64(Float64((fma(Float64(C * A), -4.0, Float64(B_m * B_m)) ^ -0.5) * sqrt(Float64(F * 2.0))) * t_4); elseif (t_3 <= -2e-227) tmp = Float64(sqrt(Float64(Float64(t_0 * F) * 2.0)) / Float64(-B_m)); elseif (t_3 <= 5.0) tmp = Float64(Float64(sqrt(Float64(Float64(t_1 * F) * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C))) / Float64(-t_1)) * sqrt(2.0)); elseif (t_3 <= Inf) tmp = Float64(Float64(sqrt(Float64(t_1 * Float64(F * 2.0))) / t_1) * t_4); else tmp = Float64(Float64(Float64(-1.0 / B_m) * sqrt(Float64(t_0 * 2.0))) * sqrt(F)); 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[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $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[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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])}, If[LessEqual[t$95$3, (-Infinity)], N[(N[(N[Power[N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision] * N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * t$95$4), $MachinePrecision], If[LessEqual[t$95$3, -2e-227], N[(N[Sqrt[N[(N[(t$95$0 * F), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / (-B$95$m)), $MachinePrecision], If[LessEqual[t$95$3, 5.0], N[(N[(N[Sqrt[N[(N[(t$95$1 * F), $MachinePrecision] * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$1)), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[(N[Sqrt[N[(t$95$1 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision] * t$95$4), $MachinePrecision], N[(N[(N[(-1.0 / B$95$m), $MachinePrecision] * N[Sqrt[N[(t$95$0 * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[F], $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{hypot}\left(C, B\_m\right) + C\\
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 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\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}\\
\mathbf{if}\;t\_3 \leq -\infty:\\
\;\;\;\;\left({\left(\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\right)}^{-0.5} \cdot \sqrt{F \cdot 2}\right) \cdot t\_4\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{\sqrt{\left(t\_0 \cdot F\right) \cdot 2}}{-B\_m}\\
\mathbf{elif}\;t\_3 \leq 5:\\
\;\;\;\;\frac{\sqrt{\left(t\_1 \cdot F\right) \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{-t\_1} \cdot \sqrt{2}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_1 \cdot \left(F \cdot 2\right)}}{t\_1} \cdot t\_4\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{-1}{B\_m} \cdot \sqrt{t\_0 \cdot 2}\right) \cdot \sqrt{F}\\
\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 rewrites33.8%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.4
Applied rewrites22.4%
Applied rewrites32.5%
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.99999999999999989e-227Initial program 97.2%
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.f6436.1
Applied rewrites36.1%
Applied rewrites36.2%
if -1.99999999999999989e-227 < (/.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))) < 5Initial program 7.6%
Applied rewrites11.9%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6429.5
Applied rewrites29.5%
if 5 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 27.5%
Applied rewrites85.0%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6442.5
Applied rewrites42.5%
Applied rewrites42.8%
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 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.f6416.9
Applied rewrites16.9%
Applied rewrites24.8%
Applied rewrites24.9%
Final simplification30.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 (+ (hypot C B_m) C))
(t_1 (* C (* A 4.0)))
(t_2
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_1)) 2.0)))
(- t_1 (pow B_m 2.0))))
(t_3 (fma -4.0 (* C A) (* B_m B_m))))
(if (<= t_2 (- INFINITY))
(*
(/ (* (sqrt (* (fma (* C A) -4.0 (* B_m B_m)) 2.0)) (sqrt F)) t_3)
(* (sqrt C) (- (sqrt 2.0))))
(if (<= t_2 -2e-227)
(/ (sqrt (* (* t_0 F) 2.0)) (- B_m))
(if (<= t_2 5.0)
(*
(/
(sqrt (* (* t_3 F) (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C)))
(- t_3))
(sqrt 2.0))
(if (<= t_2 INFINITY)
(* (/ (sqrt (* t_3 (* F 2.0))) t_3) (- (sqrt (* C 2.0))))
(* (* (/ -1.0 B_m) (sqrt (* t_0 2.0))) (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 t_0 = hypot(C, B_m) + C;
double t_1 = C * (A * 4.0);
double t_2 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_1)) * 2.0))) / (t_1 - pow(B_m, 2.0));
double t_3 = fma(-4.0, (C * A), (B_m * B_m));
double tmp;
if (t_2 <= -((double) INFINITY)) {
tmp = ((sqrt((fma((C * A), -4.0, (B_m * B_m)) * 2.0)) * sqrt(F)) / t_3) * (sqrt(C) * -sqrt(2.0));
} else if (t_2 <= -2e-227) {
tmp = sqrt(((t_0 * F) * 2.0)) / -B_m;
} else if (t_2 <= 5.0) {
tmp = (sqrt(((t_3 * F) * (((((B_m * B_m) / A) * -0.5) + C) + C))) / -t_3) * sqrt(2.0);
} else if (t_2 <= ((double) INFINITY)) {
tmp = (sqrt((t_3 * (F * 2.0))) / t_3) * -sqrt((C * 2.0));
} else {
tmp = ((-1.0 / B_m) * sqrt((t_0 * 2.0))) * 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) t_0 = Float64(hypot(C, B_m) + C) t_1 = Float64(C * Float64(A * 4.0)) t_2 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_1)) * 2.0))) / Float64(t_1 - (B_m ^ 2.0))) t_3 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) tmp = 0.0 if (t_2 <= Float64(-Inf)) tmp = Float64(Float64(Float64(sqrt(Float64(fma(Float64(C * A), -4.0, Float64(B_m * B_m)) * 2.0)) * sqrt(F)) / t_3) * Float64(sqrt(C) * Float64(-sqrt(2.0)))); elseif (t_2 <= -2e-227) tmp = Float64(sqrt(Float64(Float64(t_0 * F) * 2.0)) / Float64(-B_m)); elseif (t_2 <= 5.0) tmp = Float64(Float64(sqrt(Float64(Float64(t_3 * F) * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C))) / Float64(-t_3)) * sqrt(2.0)); elseif (t_2 <= Inf) tmp = Float64(Float64(sqrt(Float64(t_3 * Float64(F * 2.0))) / t_3) * Float64(-sqrt(Float64(C * 2.0)))); else tmp = Float64(Float64(Float64(-1.0 / B_m) * sqrt(Float64(t_0 * 2.0))) * sqrt(F)); 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[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $MachinePrecision]}, Block[{t$95$1 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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$3 = N[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, (-Infinity)], N[(N[(N[(N[Sqrt[N[(N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[F], $MachinePrecision]), $MachinePrecision] / t$95$3), $MachinePrecision] * N[(N[Sqrt[C], $MachinePrecision] * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, -2e-227], N[(N[Sqrt[N[(N[(t$95$0 * F), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / (-B$95$m)), $MachinePrecision], If[LessEqual[t$95$2, 5.0], N[(N[(N[Sqrt[N[(N[(t$95$3 * F), $MachinePrecision] * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$3)), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, Infinity], N[(N[(N[Sqrt[N[(t$95$3 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$3), $MachinePrecision] * (-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], N[(N[(N[(-1.0 / B$95$m), $MachinePrecision] * N[Sqrt[N[(t$95$0 * 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[Sqrt[F], $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{hypot}\left(C, B\_m\right) + C\\
t_1 := C \cdot \left(A \cdot 4\right)\\
t_2 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_1\right)\right) \cdot 2\right)}}{t\_1 - {B\_m}^{2}}\\
t_3 := \mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)\\
\mathbf{if}\;t\_2 \leq -\infty:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right) \cdot 2} \cdot \sqrt{F}}{t\_3} \cdot \left(\sqrt{C} \cdot \left(-\sqrt{2}\right)\right)\\
\mathbf{elif}\;t\_2 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{\sqrt{\left(t\_0 \cdot F\right) \cdot 2}}{-B\_m}\\
\mathbf{elif}\;t\_2 \leq 5:\\
\;\;\;\;\frac{\sqrt{\left(t\_3 \cdot F\right) \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{-t\_3} \cdot \sqrt{2}\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_3 \cdot \left(F \cdot 2\right)}}{t\_3} \cdot \left(-\sqrt{C \cdot 2}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{-1}{B\_m} \cdot \sqrt{t\_0 \cdot 2}\right) \cdot \sqrt{F}\\
\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 rewrites33.8%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.4
Applied rewrites22.4%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
sqrt-prodN/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
sqrt-prodN/A
associate-*r*N/A
Applied rewrites32.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))) < -1.99999999999999989e-227Initial program 97.2%
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.f6436.1
Applied rewrites36.1%
Applied rewrites36.2%
if -1.99999999999999989e-227 < (/.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))) < 5Initial program 7.6%
Applied rewrites11.9%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6429.5
Applied rewrites29.5%
if 5 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 27.5%
Applied rewrites85.0%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6442.5
Applied rewrites42.5%
Applied rewrites42.8%
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 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.f6416.9
Applied rewrites16.9%
Applied rewrites24.8%
Applied rewrites24.9%
Final simplification30.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 (+ (hypot C B_m) C))
(t_1 (* C (* A 4.0)))
(t_2
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_1)) 2.0)))
(- t_1 (pow B_m 2.0))))
(t_3 (fma -4.0 (* C A) (* B_m B_m))))
(if (<= t_2 (- INFINITY))
(*
(/ (* (sqrt (* (fma (* C A) -4.0 (* B_m B_m)) 2.0)) (sqrt F)) t_3)
(* (sqrt C) (- (sqrt 2.0))))
(if (<= t_2 -2e-227)
(/ (sqrt (* (* t_0 F) 2.0)) (- B_m))
(if (<= t_2 5.0)
(*
(/
(sqrt (* (* t_3 F) (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C)))
(- t_3))
(sqrt 2.0))
(if (<= t_2 INFINITY)
(* (/ (sqrt (* t_3 (* F 2.0))) t_3) (- (sqrt (* C 2.0))))
(* (/ (sqrt (* t_0 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 t_0 = hypot(C, B_m) + C;
double t_1 = C * (A * 4.0);
double t_2 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_1)) * 2.0))) / (t_1 - pow(B_m, 2.0));
double t_3 = fma(-4.0, (C * A), (B_m * B_m));
double tmp;
if (t_2 <= -((double) INFINITY)) {
tmp = ((sqrt((fma((C * A), -4.0, (B_m * B_m)) * 2.0)) * sqrt(F)) / t_3) * (sqrt(C) * -sqrt(2.0));
} else if (t_2 <= -2e-227) {
tmp = sqrt(((t_0 * F) * 2.0)) / -B_m;
} else if (t_2 <= 5.0) {
tmp = (sqrt(((t_3 * F) * (((((B_m * B_m) / A) * -0.5) + C) + C))) / -t_3) * sqrt(2.0);
} else if (t_2 <= ((double) INFINITY)) {
tmp = (sqrt((t_3 * (F * 2.0))) / t_3) * -sqrt((C * 2.0));
} else {
tmp = (sqrt((t_0 * 2.0)) / -B_m) * 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) t_0 = Float64(hypot(C, B_m) + C) t_1 = Float64(C * Float64(A * 4.0)) t_2 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_1)) * 2.0))) / Float64(t_1 - (B_m ^ 2.0))) t_3 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) tmp = 0.0 if (t_2 <= Float64(-Inf)) tmp = Float64(Float64(Float64(sqrt(Float64(fma(Float64(C * A), -4.0, Float64(B_m * B_m)) * 2.0)) * sqrt(F)) / t_3) * Float64(sqrt(C) * Float64(-sqrt(2.0)))); elseif (t_2 <= -2e-227) tmp = Float64(sqrt(Float64(Float64(t_0 * F) * 2.0)) / Float64(-B_m)); elseif (t_2 <= 5.0) tmp = Float64(Float64(sqrt(Float64(Float64(t_3 * F) * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C))) / Float64(-t_3)) * sqrt(2.0)); elseif (t_2 <= Inf) tmp = Float64(Float64(sqrt(Float64(t_3 * Float64(F * 2.0))) / t_3) * Float64(-sqrt(Float64(C * 2.0)))); else tmp = Float64(Float64(sqrt(Float64(t_0 * 2.0)) / Float64(-B_m)) * sqrt(F)); 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[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $MachinePrecision]}, Block[{t$95$1 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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$3 = N[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, (-Infinity)], N[(N[(N[(N[Sqrt[N[(N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[F], $MachinePrecision]), $MachinePrecision] / t$95$3), $MachinePrecision] * N[(N[Sqrt[C], $MachinePrecision] * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, -2e-227], N[(N[Sqrt[N[(N[(t$95$0 * F), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / (-B$95$m)), $MachinePrecision], If[LessEqual[t$95$2, 5.0], N[(N[(N[Sqrt[N[(N[(t$95$3 * F), $MachinePrecision] * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$3)), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, Infinity], N[(N[(N[Sqrt[N[(t$95$3 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$3), $MachinePrecision] * (-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], N[(N[(N[Sqrt[N[(t$95$0 * 2.0), $MachinePrecision]], $MachinePrecision] / (-B$95$m)), $MachinePrecision] * N[Sqrt[F], $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{hypot}\left(C, B\_m\right) + C\\
t_1 := C \cdot \left(A \cdot 4\right)\\
t_2 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_1\right)\right) \cdot 2\right)}}{t\_1 - {B\_m}^{2}}\\
t_3 := \mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)\\
\mathbf{if}\;t\_2 \leq -\infty:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right) \cdot 2} \cdot \sqrt{F}}{t\_3} \cdot \left(\sqrt{C} \cdot \left(-\sqrt{2}\right)\right)\\
\mathbf{elif}\;t\_2 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{\sqrt{\left(t\_0 \cdot F\right) \cdot 2}}{-B\_m}\\
\mathbf{elif}\;t\_2 \leq 5:\\
\;\;\;\;\frac{\sqrt{\left(t\_3 \cdot F\right) \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{-t\_3} \cdot \sqrt{2}\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_3 \cdot \left(F \cdot 2\right)}}{t\_3} \cdot \left(-\sqrt{C \cdot 2}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{t\_0 \cdot 2}}{-B\_m} \cdot \sqrt{F}\\
\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 rewrites33.8%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.4
Applied rewrites22.4%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
sqrt-prodN/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
sqrt-prodN/A
associate-*r*N/A
Applied rewrites32.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))) < -1.99999999999999989e-227Initial program 97.2%
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.f6436.1
Applied rewrites36.1%
Applied rewrites36.2%
if -1.99999999999999989e-227 < (/.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))) < 5Initial program 7.6%
Applied rewrites11.9%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6429.5
Applied rewrites29.5%
if 5 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 27.5%
Applied rewrites85.0%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6442.5
Applied rewrites42.5%
Applied rewrites42.8%
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 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.f6416.9
Applied rewrites16.9%
Applied rewrites24.8%
Applied rewrites24.9%
Final simplification30.1%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (* C (* A 4.0)))
(t_1
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_0)) 2.0)))
(- t_0 (pow B_m 2.0))))
(t_2 (fma -4.0 (* C A) (* B_m B_m))))
(if (<= t_1 (- INFINITY))
(*
(/ (* (sqrt (* (fma (* C A) -4.0 (* B_m B_m)) 2.0)) (sqrt F)) t_2)
(* (sqrt C) (- (sqrt 2.0))))
(if (<= t_1 -2e-227)
(/ (sqrt (* (* (+ (hypot C B_m) C) F) 2.0)) (- B_m))
(if (<= t_1 5.0)
(*
(/
(sqrt (* (* t_2 F) (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C)))
(- t_2))
(sqrt 2.0))
(if (<= t_1 INFINITY)
(* (/ (sqrt (* t_2 (* F 2.0))) t_2) (- (sqrt (* C 2.0))))
(* (- (pow B_m -0.5)) (sqrt (* F 2.0)))))))))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 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_0)) * 2.0))) / (t_0 - pow(B_m, 2.0));
double t_2 = fma(-4.0, (C * A), (B_m * B_m));
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = ((sqrt((fma((C * A), -4.0, (B_m * B_m)) * 2.0)) * sqrt(F)) / t_2) * (sqrt(C) * -sqrt(2.0));
} else if (t_1 <= -2e-227) {
tmp = sqrt((((hypot(C, B_m) + C) * F) * 2.0)) / -B_m;
} else if (t_1 <= 5.0) {
tmp = (sqrt(((t_2 * F) * (((((B_m * B_m) / A) * -0.5) + C) + C))) / -t_2) * sqrt(2.0);
} else if (t_1 <= ((double) INFINITY)) {
tmp = (sqrt((t_2 * (F * 2.0))) / t_2) * -sqrt((C * 2.0));
} else {
tmp = -pow(B_m, -0.5) * sqrt((F * 2.0));
}
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(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_0)) * 2.0))) / Float64(t_0 - (B_m ^ 2.0))) t_2 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(Float64(Float64(sqrt(Float64(fma(Float64(C * A), -4.0, Float64(B_m * B_m)) * 2.0)) * sqrt(F)) / t_2) * Float64(sqrt(C) * Float64(-sqrt(2.0)))); elseif (t_1 <= -2e-227) tmp = Float64(sqrt(Float64(Float64(Float64(hypot(C, B_m) + C) * F) * 2.0)) / Float64(-B_m)); elseif (t_1 <= 5.0) tmp = Float64(Float64(sqrt(Float64(Float64(t_2 * F) * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C))) / Float64(-t_2)) * sqrt(2.0)); elseif (t_1 <= Inf) tmp = Float64(Float64(sqrt(Float64(t_2 * Float64(F * 2.0))) / t_2) * Float64(-sqrt(Float64(C * 2.0)))); else tmp = Float64(Float64(-(B_m ^ -0.5)) * sqrt(Float64(F * 2.0))); 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[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$0 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(N[(N[(N[Sqrt[N[(N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[F], $MachinePrecision]), $MachinePrecision] / t$95$2), $MachinePrecision] * N[(N[Sqrt[C], $MachinePrecision] * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -2e-227], N[(N[Sqrt[N[(N[(N[(N[Sqrt[C ^ 2 + B$95$m ^ 2], $MachinePrecision] + C), $MachinePrecision] * F), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / (-B$95$m)), $MachinePrecision], If[LessEqual[t$95$1, 5.0], N[(N[(N[Sqrt[N[(N[(t$95$2 * F), $MachinePrecision] * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$2)), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[(N[Sqrt[N[(t$95$2 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$2), $MachinePrecision] * (-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], N[((-N[Power[B$95$m, -0.5], $MachinePrecision]) * N[Sqrt[N[(F * 2.0), $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 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_0\right)\right) \cdot 2\right)}}{t\_0 - {B\_m}^{2}}\\
t_2 := \mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right) \cdot 2} \cdot \sqrt{F}}{t\_2} \cdot \left(\sqrt{C} \cdot \left(-\sqrt{2}\right)\right)\\
\mathbf{elif}\;t\_1 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{\sqrt{\left(\left(\mathsf{hypot}\left(C, B\_m\right) + C\right) \cdot F\right) \cdot 2}}{-B\_m}\\
\mathbf{elif}\;t\_1 \leq 5:\\
\;\;\;\;\frac{\sqrt{\left(t\_2 \cdot F\right) \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{-t\_2} \cdot \sqrt{2}\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_2 \cdot \left(F \cdot 2\right)}}{t\_2} \cdot \left(-\sqrt{C \cdot 2}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(-{B\_m}^{-0.5}\right) \cdot \sqrt{F \cdot 2}\\
\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 rewrites33.8%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.4
Applied rewrites22.4%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
sqrt-prodN/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
sqrt-prodN/A
associate-*r*N/A
Applied rewrites32.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))) < -1.99999999999999989e-227Initial program 97.2%
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.f6436.1
Applied rewrites36.1%
Applied rewrites36.2%
if -1.99999999999999989e-227 < (/.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))) < 5Initial program 7.6%
Applied rewrites11.9%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6429.5
Applied rewrites29.5%
if 5 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 27.5%
Applied rewrites85.0%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6442.5
Applied rewrites42.5%
Applied rewrites42.8%
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-/.f6414.2
Applied rewrites14.2%
Applied rewrites14.3%
Applied rewrites22.1%
Final simplification29.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
(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
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_2)) 2.0)))
(- t_2 (pow B_m 2.0))))
(t_4 (* t_0 F)))
(if (<= t_3 -5e+202)
(*
(/ (* (sqrt (* (fma (* C A) -4.0 (* B_m B_m)) 2.0)) (sqrt F)) t_0)
(* (sqrt C) (- (sqrt 2.0))))
(if (<= t_3 -2e-227)
(* (/ (sqrt (* (+ (* (- (/ A B_m) -1.0) B_m) C) t_4)) t_1) (sqrt 2.0))
(if (<= t_3 5.0)
(*
(/ (sqrt (* t_4 (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C))) t_1)
(sqrt 2.0))
(if (<= t_3 INFINITY)
(* (/ (sqrt (* t_0 (* F 2.0))) t_0) (- (sqrt (* C 2.0))))
(* (- (pow B_m -0.5)) (sqrt (* F 2.0)))))))))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(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_2)) * 2.0))) / (t_2 - pow(B_m, 2.0));
double t_4 = t_0 * F;
double tmp;
if (t_3 <= -5e+202) {
tmp = ((sqrt((fma((C * A), -4.0, (B_m * B_m)) * 2.0)) * sqrt(F)) / t_0) * (sqrt(C) * -sqrt(2.0));
} else if (t_3 <= -2e-227) {
tmp = (sqrt((((((A / B_m) - -1.0) * B_m) + C) * t_4)) / t_1) * sqrt(2.0);
} else if (t_3 <= 5.0) {
tmp = (sqrt((t_4 * (((((B_m * B_m) / A) * -0.5) + C) + C))) / t_1) * sqrt(2.0);
} else if (t_3 <= ((double) INFINITY)) {
tmp = (sqrt((t_0 * (F * 2.0))) / t_0) * -sqrt((C * 2.0));
} else {
tmp = -pow(B_m, -0.5) * sqrt((F * 2.0));
}
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(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_2)) * 2.0))) / Float64(t_2 - (B_m ^ 2.0))) t_4 = Float64(t_0 * F) tmp = 0.0 if (t_3 <= -5e+202) tmp = Float64(Float64(Float64(sqrt(Float64(fma(Float64(C * A), -4.0, Float64(B_m * B_m)) * 2.0)) * sqrt(F)) / t_0) * Float64(sqrt(C) * Float64(-sqrt(2.0)))); elseif (t_3 <= -2e-227) tmp = Float64(Float64(sqrt(Float64(Float64(Float64(Float64(Float64(A / B_m) - -1.0) * B_m) + C) * t_4)) / t_1) * sqrt(2.0)); elseif (t_3 <= 5.0) tmp = Float64(Float64(sqrt(Float64(t_4 * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C))) / t_1) * sqrt(2.0)); elseif (t_3 <= Inf) tmp = Float64(Float64(sqrt(Float64(t_0 * Float64(F * 2.0))) / t_0) * Float64(-sqrt(Float64(C * 2.0)))); else tmp = Float64(Float64(-(B_m ^ -0.5)) * sqrt(Float64(F * 2.0))); 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[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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[(t$95$0 * F), $MachinePrecision]}, If[LessEqual[t$95$3, -5e+202], N[(N[(N[(N[Sqrt[N[(N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[F], $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] * N[(N[Sqrt[C], $MachinePrecision] * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -2e-227], N[(N[(N[Sqrt[N[(N[(N[(N[(N[(A / B$95$m), $MachinePrecision] - -1.0), $MachinePrecision] * B$95$m), $MachinePrecision] + C), $MachinePrecision] * t$95$4), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 5.0], N[(N[(N[Sqrt[N[(t$95$4 * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[(N[Sqrt[N[(t$95$0 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision] * (-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], N[((-N[Power[B$95$m, -0.5], $MachinePrecision]) * N[Sqrt[N[(F * 2.0), $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(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_2\right)\right) \cdot 2\right)}}{t\_2 - {B\_m}^{2}}\\
t_4 := t\_0 \cdot F\\
\mathbf{if}\;t\_3 \leq -5 \cdot 10^{+202}:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right) \cdot 2} \cdot \sqrt{F}}{t\_0} \cdot \left(\sqrt{C} \cdot \left(-\sqrt{2}\right)\right)\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{\sqrt{\left(\left(\frac{A}{B\_m} - -1\right) \cdot B\_m + C\right) \cdot t\_4}}{t\_1} \cdot \sqrt{2}\\
\mathbf{elif}\;t\_3 \leq 5:\\
\;\;\;\;\frac{\sqrt{t\_4 \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{t\_1} \cdot \sqrt{2}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_0 \cdot \left(F \cdot 2\right)}}{t\_0} \cdot \left(-\sqrt{C \cdot 2}\right)\\
\mathbf{else}:\\
\;\;\;\;\left(-{B\_m}^{-0.5}\right) \cdot \sqrt{F \cdot 2}\\
\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))) < -4.9999999999999999e202Initial program 4.7%
Applied rewrites34.9%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.1
Applied rewrites22.1%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
sqrt-prodN/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
sqrt-prodN/A
associate-*r*N/A
Applied rewrites31.9%
if -4.9999999999999999e202 < (/.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.99999999999999989e-227Initial program 97.1%
Applied rewrites97.2%
Taylor expanded in B around inf
lower-*.f64N/A
lower-+.f64N/A
lower-/.f6433.0
Applied rewrites33.0%
if -1.99999999999999989e-227 < (/.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))) < 5Initial program 7.6%
Applied rewrites11.9%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6429.5
Applied rewrites29.5%
if 5 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 27.5%
Applied rewrites85.0%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6442.5
Applied rewrites42.5%
Applied rewrites42.8%
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-/.f6414.2
Applied rewrites14.2%
Applied rewrites14.3%
Applied rewrites22.1%
Final simplification28.6%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (fma -4.0 (* C A) (* B_m B_m)))
(t_1 (- t_0))
(t_2 (* C (* A 4.0)))
(t_3
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_2)) 2.0)))
(- t_2 (pow B_m 2.0))))
(t_4 (* t_0 F)))
(if (<= t_3 -5e+202)
(*
(/ (* (sqrt (* (fma (* C A) -4.0 (* B_m B_m)) 2.0)) (sqrt F)) t_0)
(* (sqrt C) (- (sqrt 2.0))))
(if (<= t_3 -2e-227)
(* (/ (sqrt (* (+ (* (- (/ A B_m) -1.0) B_m) C) t_4)) t_1) (sqrt 2.0))
(if (<= t_3 5.0)
(*
(/ (sqrt (* t_4 (+ (+ (* (/ (* B_m B_m) A) -0.5) C) C))) t_1)
(sqrt 2.0))
(if (<= t_3 INFINITY)
(* (/ (sqrt (* t_0 (* F 2.0))) t_0) (- (sqrt (* C 2.0))))
(/ (sqrt (* F 2.0)) (- (sqrt 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(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_2)) * 2.0))) / (t_2 - pow(B_m, 2.0));
double t_4 = t_0 * F;
double tmp;
if (t_3 <= -5e+202) {
tmp = ((sqrt((fma((C * A), -4.0, (B_m * B_m)) * 2.0)) * sqrt(F)) / t_0) * (sqrt(C) * -sqrt(2.0));
} else if (t_3 <= -2e-227) {
tmp = (sqrt((((((A / B_m) - -1.0) * B_m) + C) * t_4)) / t_1) * sqrt(2.0);
} else if (t_3 <= 5.0) {
tmp = (sqrt((t_4 * (((((B_m * B_m) / A) * -0.5) + C) + C))) / t_1) * sqrt(2.0);
} else if (t_3 <= ((double) INFINITY)) {
tmp = (sqrt((t_0 * (F * 2.0))) / t_0) * -sqrt((C * 2.0));
} else {
tmp = sqrt((F * 2.0)) / -sqrt(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(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_2)) * 2.0))) / Float64(t_2 - (B_m ^ 2.0))) t_4 = Float64(t_0 * F) tmp = 0.0 if (t_3 <= -5e+202) tmp = Float64(Float64(Float64(sqrt(Float64(fma(Float64(C * A), -4.0, Float64(B_m * B_m)) * 2.0)) * sqrt(F)) / t_0) * Float64(sqrt(C) * Float64(-sqrt(2.0)))); elseif (t_3 <= -2e-227) tmp = Float64(Float64(sqrt(Float64(Float64(Float64(Float64(Float64(A / B_m) - -1.0) * B_m) + C) * t_4)) / t_1) * sqrt(2.0)); elseif (t_3 <= 5.0) tmp = Float64(Float64(sqrt(Float64(t_4 * Float64(Float64(Float64(Float64(Float64(B_m * B_m) / A) * -0.5) + C) + C))) / t_1) * sqrt(2.0)); elseif (t_3 <= Inf) tmp = Float64(Float64(sqrt(Float64(t_0 * Float64(F * 2.0))) / t_0) * Float64(-sqrt(Float64(C * 2.0)))); else tmp = Float64(sqrt(Float64(F * 2.0)) / Float64(-sqrt(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[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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[(t$95$0 * F), $MachinePrecision]}, If[LessEqual[t$95$3, -5e+202], N[(N[(N[(N[Sqrt[N[(N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[F], $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] * N[(N[Sqrt[C], $MachinePrecision] * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -2e-227], N[(N[(N[Sqrt[N[(N[(N[(N[(N[(A / B$95$m), $MachinePrecision] - -1.0), $MachinePrecision] * B$95$m), $MachinePrecision] + C), $MachinePrecision] * t$95$4), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 5.0], N[(N[(N[Sqrt[N[(t$95$4 * N[(N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] * -0.5), $MachinePrecision] + C), $MachinePrecision] + C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[(N[Sqrt[N[(t$95$0 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision] * (-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], N[(N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision] / (-N[Sqrt[B$95$m], $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(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_2\right)\right) \cdot 2\right)}}{t\_2 - {B\_m}^{2}}\\
t_4 := t\_0 \cdot F\\
\mathbf{if}\;t\_3 \leq -5 \cdot 10^{+202}:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right) \cdot 2} \cdot \sqrt{F}}{t\_0} \cdot \left(\sqrt{C} \cdot \left(-\sqrt{2}\right)\right)\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{\sqrt{\left(\left(\frac{A}{B\_m} - -1\right) \cdot B\_m + C\right) \cdot t\_4}}{t\_1} \cdot \sqrt{2}\\
\mathbf{elif}\;t\_3 \leq 5:\\
\;\;\;\;\frac{\sqrt{t\_4 \cdot \left(\left(\frac{B\_m \cdot B\_m}{A} \cdot -0.5 + C\right) + C\right)}}{t\_1} \cdot \sqrt{2}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_0 \cdot \left(F \cdot 2\right)}}{t\_0} \cdot \left(-\sqrt{C \cdot 2}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{F \cdot 2}}{-\sqrt{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))) < -4.9999999999999999e202Initial program 4.7%
Applied rewrites34.9%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.1
Applied rewrites22.1%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
sqrt-prodN/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
sqrt-prodN/A
associate-*r*N/A
Applied rewrites31.9%
if -4.9999999999999999e202 < (/.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.99999999999999989e-227Initial program 97.1%
Applied rewrites97.2%
Taylor expanded in B around inf
lower-*.f64N/A
lower-+.f64N/A
lower-/.f6433.0
Applied rewrites33.0%
if -1.99999999999999989e-227 < (/.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))) < 5Initial program 7.6%
Applied rewrites11.9%
Taylor expanded in A around -inf
lower-+.f64N/A
lower-*.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6429.5
Applied rewrites29.5%
if 5 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 27.5%
Applied rewrites85.0%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6442.5
Applied rewrites42.5%
Applied rewrites42.8%
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-/.f6414.2
Applied rewrites14.2%
Applied rewrites14.3%
Applied rewrites22.1%
Final simplification28.6%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (fma (* C A) -4.0 (* B_m B_m)))
(t_1 (fma -4.0 (* C A) (* B_m B_m)))
(t_2 (* C (* A 4.0)))
(t_3
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_2)) 2.0)))
(- t_2 (pow B_m 2.0)))))
(if (<= t_3 -5e+202)
(* (/ (* (sqrt (* t_0 2.0)) (sqrt F)) t_1) (* (sqrt C) (- (sqrt 2.0))))
(if (<= t_3 -2e-227)
(*
(/ (sqrt (* (+ (* (- (/ A B_m) -1.0) B_m) C) (* t_1 F))) (- t_1))
(sqrt 2.0))
(if (<= t_3 5.0)
(/
(sqrt (* (* (fma -0.5 (/ (* B_m B_m) A) (* C 2.0)) t_0) (* F 2.0)))
(- t_0))
(if (<= t_3 INFINITY)
(* (/ (sqrt (* t_1 (* F 2.0))) t_1) (- (sqrt (* C 2.0))))
(/ (sqrt (* F 2.0)) (- (sqrt 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((C * A), -4.0, (B_m * B_m));
double t_1 = fma(-4.0, (C * A), (B_m * B_m));
double t_2 = C * (A * 4.0);
double t_3 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_2)) * 2.0))) / (t_2 - pow(B_m, 2.0));
double tmp;
if (t_3 <= -5e+202) {
tmp = ((sqrt((t_0 * 2.0)) * sqrt(F)) / t_1) * (sqrt(C) * -sqrt(2.0));
} else if (t_3 <= -2e-227) {
tmp = (sqrt((((((A / B_m) - -1.0) * B_m) + C) * (t_1 * F))) / -t_1) * sqrt(2.0);
} else if (t_3 <= 5.0) {
tmp = sqrt(((fma(-0.5, ((B_m * B_m) / A), (C * 2.0)) * t_0) * (F * 2.0))) / -t_0;
} else if (t_3 <= ((double) INFINITY)) {
tmp = (sqrt((t_1 * (F * 2.0))) / t_1) * -sqrt((C * 2.0));
} else {
tmp = sqrt((F * 2.0)) / -sqrt(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(Float64(C * A), -4.0, Float64(B_m * B_m)) t_1 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_2 = Float64(C * Float64(A * 4.0)) t_3 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_2)) * 2.0))) / Float64(t_2 - (B_m ^ 2.0))) tmp = 0.0 if (t_3 <= -5e+202) tmp = Float64(Float64(Float64(sqrt(Float64(t_0 * 2.0)) * sqrt(F)) / t_1) * Float64(sqrt(C) * Float64(-sqrt(2.0)))); elseif (t_3 <= -2e-227) tmp = Float64(Float64(sqrt(Float64(Float64(Float64(Float64(Float64(A / B_m) - -1.0) * B_m) + C) * Float64(t_1 * F))) / Float64(-t_1)) * sqrt(2.0)); elseif (t_3 <= 5.0) tmp = Float64(sqrt(Float64(Float64(fma(-0.5, Float64(Float64(B_m * B_m) / A), Float64(C * 2.0)) * t_0) * Float64(F * 2.0))) / Float64(-t_0)); elseif (t_3 <= Inf) tmp = Float64(Float64(sqrt(Float64(t_1 * Float64(F * 2.0))) / t_1) * Float64(-sqrt(Float64(C * 2.0)))); else tmp = Float64(sqrt(Float64(F * 2.0)) / Float64(-sqrt(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[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $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[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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]}, If[LessEqual[t$95$3, -5e+202], N[(N[(N[(N[Sqrt[N[(t$95$0 * 2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[F], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision] * N[(N[Sqrt[C], $MachinePrecision] * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -2e-227], N[(N[(N[Sqrt[N[(N[(N[(N[(N[(A / B$95$m), $MachinePrecision] - -1.0), $MachinePrecision] * B$95$m), $MachinePrecision] + C), $MachinePrecision] * N[(t$95$1 * F), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$1)), $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, 5.0], N[(N[Sqrt[N[(N[(N[(-0.5 * N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] + N[(C * 2.0), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision] * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$0)), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[(N[Sqrt[N[(t$95$1 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision] * (-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], N[(N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision] / (-N[Sqrt[B$95$m], $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(C \cdot A, -4, B\_m \cdot B\_m\right)\\
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 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_2\right)\right) \cdot 2\right)}}{t\_2 - {B\_m}^{2}}\\
\mathbf{if}\;t\_3 \leq -5 \cdot 10^{+202}:\\
\;\;\;\;\frac{\sqrt{t\_0 \cdot 2} \cdot \sqrt{F}}{t\_1} \cdot \left(\sqrt{C} \cdot \left(-\sqrt{2}\right)\right)\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{\sqrt{\left(\left(\frac{A}{B\_m} - -1\right) \cdot B\_m + C\right) \cdot \left(t\_1 \cdot F\right)}}{-t\_1} \cdot \sqrt{2}\\
\mathbf{elif}\;t\_3 \leq 5:\\
\;\;\;\;\frac{\sqrt{\left(\mathsf{fma}\left(-0.5, \frac{B\_m \cdot B\_m}{A}, C \cdot 2\right) \cdot t\_0\right) \cdot \left(F \cdot 2\right)}}{-t\_0}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_1 \cdot \left(F \cdot 2\right)}}{t\_1} \cdot \left(-\sqrt{C \cdot 2}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{F \cdot 2}}{-\sqrt{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))) < -4.9999999999999999e202Initial program 4.7%
Applied rewrites34.9%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.1
Applied rewrites22.1%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
sqrt-prodN/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
sqrt-prodN/A
associate-*r*N/A
Applied rewrites31.9%
if -4.9999999999999999e202 < (/.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.99999999999999989e-227Initial program 97.1%
Applied rewrites97.2%
Taylor expanded in B around inf
lower-*.f64N/A
lower-+.f64N/A
lower-/.f6433.0
Applied rewrites33.0%
if -1.99999999999999989e-227 < (/.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))) < 5Initial program 7.6%
Applied rewrites11.9%
Applied rewrites7.6%
Taylor expanded in A around -inf
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f6422.7
Applied rewrites22.7%
if 5 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 27.5%
Applied rewrites85.0%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6442.5
Applied rewrites42.5%
Applied rewrites42.8%
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-/.f6414.2
Applied rewrites14.2%
Applied rewrites14.3%
Applied rewrites22.1%
Final simplification27.3%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (fma (* C A) -4.0 (* B_m B_m)))
(t_1 (fma -4.0 (* C A) (* B_m B_m)))
(t_2 (* C (* A 4.0)))
(t_3
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_2)) 2.0)))
(- t_2 (pow B_m 2.0)))))
(if (<= t_3 -5e+202)
(* (/ (* (sqrt (* t_0 2.0)) (sqrt F)) t_1) (* (sqrt C) (- (sqrt 2.0))))
(if (<= t_3 -2e-227)
(* (/ (sqrt (* (+ C B_m) 2.0)) B_m) (- (sqrt F)))
(if (<= t_3 5.0)
(/
(sqrt (* (* (fma -0.5 (/ (* B_m B_m) A) (* C 2.0)) t_0) (* F 2.0)))
(- t_0))
(if (<= t_3 INFINITY)
(* (/ (sqrt (* t_1 (* F 2.0))) t_1) (- (sqrt (* C 2.0))))
(/ (sqrt (* F 2.0)) (- (sqrt 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((C * A), -4.0, (B_m * B_m));
double t_1 = fma(-4.0, (C * A), (B_m * B_m));
double t_2 = C * (A * 4.0);
double t_3 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_2)) * 2.0))) / (t_2 - pow(B_m, 2.0));
double tmp;
if (t_3 <= -5e+202) {
tmp = ((sqrt((t_0 * 2.0)) * sqrt(F)) / t_1) * (sqrt(C) * -sqrt(2.0));
} else if (t_3 <= -2e-227) {
tmp = (sqrt(((C + B_m) * 2.0)) / B_m) * -sqrt(F);
} else if (t_3 <= 5.0) {
tmp = sqrt(((fma(-0.5, ((B_m * B_m) / A), (C * 2.0)) * t_0) * (F * 2.0))) / -t_0;
} else if (t_3 <= ((double) INFINITY)) {
tmp = (sqrt((t_1 * (F * 2.0))) / t_1) * -sqrt((C * 2.0));
} else {
tmp = sqrt((F * 2.0)) / -sqrt(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(Float64(C * A), -4.0, Float64(B_m * B_m)) t_1 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) t_2 = Float64(C * Float64(A * 4.0)) t_3 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_2)) * 2.0))) / Float64(t_2 - (B_m ^ 2.0))) tmp = 0.0 if (t_3 <= -5e+202) tmp = Float64(Float64(Float64(sqrt(Float64(t_0 * 2.0)) * sqrt(F)) / t_1) * Float64(sqrt(C) * Float64(-sqrt(2.0)))); elseif (t_3 <= -2e-227) tmp = Float64(Float64(sqrt(Float64(Float64(C + B_m) * 2.0)) / B_m) * Float64(-sqrt(F))); elseif (t_3 <= 5.0) tmp = Float64(sqrt(Float64(Float64(fma(-0.5, Float64(Float64(B_m * B_m) / A), Float64(C * 2.0)) * t_0) * Float64(F * 2.0))) / Float64(-t_0)); elseif (t_3 <= Inf) tmp = Float64(Float64(sqrt(Float64(t_1 * Float64(F * 2.0))) / t_1) * Float64(-sqrt(Float64(C * 2.0)))); else tmp = Float64(sqrt(Float64(F * 2.0)) / Float64(-sqrt(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[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $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[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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]}, If[LessEqual[t$95$3, -5e+202], N[(N[(N[(N[Sqrt[N[(t$95$0 * 2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[F], $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision] * N[(N[Sqrt[C], $MachinePrecision] * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$3, -2e-227], N[(N[(N[Sqrt[N[(N[(C + B$95$m), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / B$95$m), $MachinePrecision] * (-N[Sqrt[F], $MachinePrecision])), $MachinePrecision], If[LessEqual[t$95$3, 5.0], N[(N[Sqrt[N[(N[(N[(-0.5 * N[(N[(B$95$m * B$95$m), $MachinePrecision] / A), $MachinePrecision] + N[(C * 2.0), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision] * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$0)), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[(N[Sqrt[N[(t$95$1 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision] * (-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], N[(N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision] / (-N[Sqrt[B$95$m], $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(C \cdot A, -4, B\_m \cdot B\_m\right)\\
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 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_2\right)\right) \cdot 2\right)}}{t\_2 - {B\_m}^{2}}\\
\mathbf{if}\;t\_3 \leq -5 \cdot 10^{+202}:\\
\;\;\;\;\frac{\sqrt{t\_0 \cdot 2} \cdot \sqrt{F}}{t\_1} \cdot \left(\sqrt{C} \cdot \left(-\sqrt{2}\right)\right)\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{\sqrt{\left(C + B\_m\right) \cdot 2}}{B\_m} \cdot \left(-\sqrt{F}\right)\\
\mathbf{elif}\;t\_3 \leq 5:\\
\;\;\;\;\frac{\sqrt{\left(\mathsf{fma}\left(-0.5, \frac{B\_m \cdot B\_m}{A}, C \cdot 2\right) \cdot t\_0\right) \cdot \left(F \cdot 2\right)}}{-t\_0}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_1 \cdot \left(F \cdot 2\right)}}{t\_1} \cdot \left(-\sqrt{C \cdot 2}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{F \cdot 2}}{-\sqrt{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))) < -4.9999999999999999e202Initial program 4.7%
Applied rewrites34.9%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.1
Applied rewrites22.1%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
associate-*l*N/A
sqrt-prodN/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
*-commutativeN/A
sqrt-prodN/A
associate-*r*N/A
Applied rewrites31.9%
if -4.9999999999999999e202 < (/.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.99999999999999989e-227Initial program 97.1%
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.f6437.4
Applied rewrites37.4%
Applied rewrites37.3%
Applied rewrites37.3%
Taylor expanded in C around 0
Applied rewrites30.6%
if -1.99999999999999989e-227 < (/.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))) < 5Initial program 7.6%
Applied rewrites11.9%
Applied rewrites7.6%
Taylor expanded in A around -inf
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f64N/A
lower-*.f6422.7
Applied rewrites22.7%
if 5 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 27.5%
Applied rewrites85.0%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6442.5
Applied rewrites42.5%
Applied rewrites42.8%
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-/.f6414.2
Applied rewrites14.2%
Applied rewrites14.3%
Applied rewrites22.1%
Final simplification27.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
(let* ((t_0 (fma -4.0 (* C A) (* B_m B_m)))
(t_1 (* (sqrt C) (- (sqrt 2.0))))
(t_2 (* C (* A 4.0)))
(t_3
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* 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))))
(if (<= t_3 (- INFINITY))
(* (* (sqrt (/ F t_0)) (sqrt 2.0)) t_1)
(if (<= t_3 -2e-227)
(* (/ (sqrt (* (+ C B_m) 2.0)) B_m) (- (sqrt F)))
(if (<= t_3 1e+220)
(/ (sqrt (* (* (* C 2.0) t_4) (* F 2.0))) (- t_4))
(if (<= t_3 INFINITY)
(* (/ (sqrt (* (* (* F C) A) -8.0)) t_0) t_1)
(/ (sqrt (* F 2.0)) (- (sqrt 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 = sqrt(C) * -sqrt(2.0);
double t_2 = C * (A * 4.0);
double t_3 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((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 tmp;
if (t_3 <= -((double) INFINITY)) {
tmp = (sqrt((F / t_0)) * sqrt(2.0)) * t_1;
} else if (t_3 <= -2e-227) {
tmp = (sqrt(((C + B_m) * 2.0)) / B_m) * -sqrt(F);
} else if (t_3 <= 1e+220) {
tmp = sqrt((((C * 2.0) * t_4) * (F * 2.0))) / -t_4;
} else if (t_3 <= ((double) INFINITY)) {
tmp = (sqrt((((F * C) * A) * -8.0)) / t_0) * t_1;
} else {
tmp = sqrt((F * 2.0)) / -sqrt(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(sqrt(C) * Float64(-sqrt(2.0))) t_2 = Float64(C * Float64(A * 4.0)) t_3 = Float64(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * 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)) tmp = 0.0 if (t_3 <= Float64(-Inf)) tmp = Float64(Float64(sqrt(Float64(F / t_0)) * sqrt(2.0)) * t_1); elseif (t_3 <= -2e-227) tmp = Float64(Float64(sqrt(Float64(Float64(C + B_m) * 2.0)) / B_m) * Float64(-sqrt(F))); elseif (t_3 <= 1e+220) tmp = Float64(sqrt(Float64(Float64(Float64(C * 2.0) * t_4) * Float64(F * 2.0))) / Float64(-t_4)); elseif (t_3 <= Inf) tmp = Float64(Float64(sqrt(Float64(Float64(Float64(F * C) * A) * -8.0)) / t_0) * t_1); else tmp = Float64(sqrt(Float64(F * 2.0)) / Float64(-sqrt(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 = N[(N[Sqrt[C], $MachinePrecision] * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision]}, Block[{t$95$2 = N[(C * N[(A * 4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $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]}, If[LessEqual[t$95$3, (-Infinity)], N[(N[(N[Sqrt[N[(F / t$95$0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision], If[LessEqual[t$95$3, -2e-227], N[(N[(N[Sqrt[N[(N[(C + B$95$m), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / B$95$m), $MachinePrecision] * (-N[Sqrt[F], $MachinePrecision])), $MachinePrecision], If[LessEqual[t$95$3, 1e+220], N[(N[Sqrt[N[(N[(N[(C * 2.0), $MachinePrecision] * t$95$4), $MachinePrecision] * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$4)), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[(N[Sqrt[N[(N[(N[(F * C), $MachinePrecision] * A), $MachinePrecision] * -8.0), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision] * t$95$1), $MachinePrecision], N[(N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision] / (-N[Sqrt[B$95$m], $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 := \sqrt{C} \cdot \left(-\sqrt{2}\right)\\
t_2 := C \cdot \left(A \cdot 4\right)\\
t_3 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\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)\\
\mathbf{if}\;t\_3 \leq -\infty:\\
\;\;\;\;\left(\sqrt{\frac{F}{t\_0}} \cdot \sqrt{2}\right) \cdot t\_1\\
\mathbf{elif}\;t\_3 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{\sqrt{\left(C + B\_m\right) \cdot 2}}{B\_m} \cdot \left(-\sqrt{F}\right)\\
\mathbf{elif}\;t\_3 \leq 10^{+220}:\\
\;\;\;\;\frac{\sqrt{\left(\left(C \cdot 2\right) \cdot t\_4\right) \cdot \left(F \cdot 2\right)}}{-t\_4}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\frac{\sqrt{\left(\left(F \cdot C\right) \cdot A\right) \cdot -8}}{t\_0} \cdot t\_1\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{F \cdot 2}}{-\sqrt{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 rewrites33.8%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.4
Applied rewrites22.4%
Taylor expanded in F around 0
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-sqrt.f6426.1
Applied rewrites26.1%
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.99999999999999989e-227Initial program 97.2%
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.f6436.1
Applied rewrites36.1%
Applied rewrites36.1%
Applied rewrites36.0%
Taylor expanded in C around 0
Applied rewrites29.6%
if -1.99999999999999989e-227 < (/.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))) < 1e220Initial program 16.4%
Applied rewrites20.2%
Applied rewrites16.4%
Taylor expanded in A around -inf
lower-*.f6424.7
Applied rewrites24.7%
if 1e220 < (/.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.5%
Applied rewrites80.2%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6435.9
Applied rewrites35.9%
Taylor expanded in A around inf
lower-*.f64N/A
lower-*.f64N/A
lower-*.f6436.0
Applied rewrites36.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-/.f6414.2
Applied rewrites14.2%
Applied rewrites14.3%
Applied rewrites22.1%
Final simplification25.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 (* C (* A 4.0)))
(t_1
(/
(sqrt
(*
(+ (sqrt (+ (pow (- A C) 2.0) (pow B_m 2.0))) (+ C A))
(* (* F (- (pow B_m 2.0) t_0)) 2.0)))
(- t_0 (pow B_m 2.0))))
(t_2 (fma (* C A) -4.0 (* B_m B_m))))
(if (<= t_1 (- INFINITY))
(*
(* (sqrt (/ F (fma -4.0 (* C A) (* B_m B_m)))) (sqrt 2.0))
(* (sqrt C) (- (sqrt 2.0))))
(if (<= t_1 -2e-227)
(* (/ (sqrt (* (+ C B_m) 2.0)) B_m) (- (sqrt F)))
(if (<= t_1 INFINITY)
(/ (sqrt (* (* (* C 2.0) t_2) (* F 2.0))) (- t_2))
(/ (sqrt (* F 2.0)) (- (sqrt 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 = sqrt(((sqrt((pow((A - C), 2.0) + pow(B_m, 2.0))) + (C + A)) * ((F * (pow(B_m, 2.0) - t_0)) * 2.0))) / (t_0 - pow(B_m, 2.0));
double t_2 = fma((C * A), -4.0, (B_m * B_m));
double tmp;
if (t_1 <= -((double) INFINITY)) {
tmp = (sqrt((F / fma(-4.0, (C * A), (B_m * B_m)))) * sqrt(2.0)) * (sqrt(C) * -sqrt(2.0));
} else if (t_1 <= -2e-227) {
tmp = (sqrt(((C + B_m) * 2.0)) / B_m) * -sqrt(F);
} else if (t_1 <= ((double) INFINITY)) {
tmp = sqrt((((C * 2.0) * t_2) * (F * 2.0))) / -t_2;
} else {
tmp = sqrt((F * 2.0)) / -sqrt(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(sqrt(Float64(Float64(sqrt(Float64((Float64(A - C) ^ 2.0) + (B_m ^ 2.0))) + Float64(C + A)) * Float64(Float64(F * Float64((B_m ^ 2.0) - t_0)) * 2.0))) / Float64(t_0 - (B_m ^ 2.0))) t_2 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) tmp = 0.0 if (t_1 <= Float64(-Inf)) tmp = Float64(Float64(sqrt(Float64(F / fma(-4.0, Float64(C * A), Float64(B_m * B_m)))) * sqrt(2.0)) * Float64(sqrt(C) * Float64(-sqrt(2.0)))); elseif (t_1 <= -2e-227) tmp = Float64(Float64(sqrt(Float64(Float64(C + B_m) * 2.0)) / B_m) * Float64(-sqrt(F))); elseif (t_1 <= Inf) tmp = Float64(sqrt(Float64(Float64(Float64(C * 2.0) * t_2) * Float64(F * 2.0))) / Float64(-t_2)); else tmp = Float64(sqrt(Float64(F * 2.0)) / Float64(-sqrt(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[(N[Sqrt[N[(N[(N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] + N[(C + A), $MachinePrecision]), $MachinePrecision] * N[(N[(F * N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$0 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, (-Infinity)], N[(N[(N[Sqrt[N[(F / N[(-4.0 * N[(C * A), $MachinePrecision] + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Sqrt[C], $MachinePrecision] * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, -2e-227], N[(N[(N[Sqrt[N[(N[(C + B$95$m), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / B$95$m), $MachinePrecision] * (-N[Sqrt[F], $MachinePrecision])), $MachinePrecision], If[LessEqual[t$95$1, Infinity], N[(N[Sqrt[N[(N[(N[(C * 2.0), $MachinePrecision] * t$95$2), $MachinePrecision] * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$2)), $MachinePrecision], N[(N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision] / (-N[Sqrt[B$95$m], $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 := \frac{\sqrt{\left(\sqrt{{\left(A - C\right)}^{2} + {B\_m}^{2}} + \left(C + A\right)\right) \cdot \left(\left(F \cdot \left({B\_m}^{2} - t\_0\right)\right) \cdot 2\right)}}{t\_0 - {B\_m}^{2}}\\
t_2 := \mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)\\
\mathbf{if}\;t\_1 \leq -\infty:\\
\;\;\;\;\left(\sqrt{\frac{F}{\mathsf{fma}\left(-4, C \cdot A, B\_m \cdot B\_m\right)}} \cdot \sqrt{2}\right) \cdot \left(\sqrt{C} \cdot \left(-\sqrt{2}\right)\right)\\
\mathbf{elif}\;t\_1 \leq -2 \cdot 10^{-227}:\\
\;\;\;\;\frac{\sqrt{\left(C + B\_m\right) \cdot 2}}{B\_m} \cdot \left(-\sqrt{F}\right)\\
\mathbf{elif}\;t\_1 \leq \infty:\\
\;\;\;\;\frac{\sqrt{\left(\left(C \cdot 2\right) \cdot t\_2\right) \cdot \left(F \cdot 2\right)}}{-t\_2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{F \cdot 2}}{-\sqrt{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 rewrites33.8%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6422.4
Applied rewrites22.4%
Taylor expanded in F around 0
lower-*.f64N/A
lower-sqrt.f64N/A
lower-/.f64N/A
lower-fma.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f64N/A
lower-sqrt.f6426.1
Applied rewrites26.1%
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.99999999999999989e-227Initial program 97.2%
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.f6436.1
Applied rewrites36.1%
Applied rewrites36.1%
Applied rewrites36.0%
Taylor expanded in C around 0
Applied rewrites29.6%
if -1.99999999999999989e-227 < (/.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 13.5%
Applied rewrites25.1%
Applied rewrites20.8%
Taylor expanded in A around -inf
lower-*.f6422.9
Applied rewrites22.9%
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-/.f6414.2
Applied rewrites14.2%
Applied rewrites14.3%
Applied rewrites22.1%
Final simplification24.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
(let* ((t_0 (fma -4.0 (* C A) (* B_m B_m))))
(if (<= (pow B_m 2.0) 2e+151)
(* (/ (sqrt (* t_0 (* F 2.0))) t_0) (- (sqrt (* C 2.0))))
(* (/ (sqrt (* (+ C B_m) 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 t_0 = fma(-4.0, (C * A), (B_m * B_m));
double tmp;
if (pow(B_m, 2.0) <= 2e+151) {
tmp = (sqrt((t_0 * (F * 2.0))) / t_0) * -sqrt((C * 2.0));
} else {
tmp = (sqrt(((C + B_m) * 2.0)) / B_m) * -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) t_0 = fma(-4.0, Float64(C * A), Float64(B_m * B_m)) tmp = 0.0 if ((B_m ^ 2.0) <= 2e+151) tmp = Float64(Float64(sqrt(Float64(t_0 * Float64(F * 2.0))) / t_0) * Float64(-sqrt(Float64(C * 2.0)))); else tmp = Float64(Float64(sqrt(Float64(Float64(C + B_m) * 2.0)) / B_m) * Float64(-sqrt(F))); 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[N[Power[B$95$m, 2.0], $MachinePrecision], 2e+151], N[(N[(N[Sqrt[N[(t$95$0 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision] * (-N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision])), $MachinePrecision], N[(N[(N[Sqrt[N[(N[(C + B$95$m), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / B$95$m), $MachinePrecision] * (-N[Sqrt[F], $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}^{2} \leq 2 \cdot 10^{+151}:\\
\;\;\;\;\frac{\sqrt{t\_0 \cdot \left(F \cdot 2\right)}}{t\_0} \cdot \left(-\sqrt{C \cdot 2}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{\left(C + B\_m\right) \cdot 2}}{B\_m} \cdot \left(-\sqrt{F}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 2.00000000000000003e151Initial program 19.6%
Applied rewrites35.8%
Taylor expanded in A around -inf
mul-1-negN/A
lower-neg.f64N/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f6418.1
Applied rewrites18.1%
Applied rewrites18.2%
if 2.00000000000000003e151 < (pow.f64 B #s(literal 2 binary64)) Initial program 7.2%
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.f6424.0
Applied rewrites24.0%
Applied rewrites35.6%
Applied rewrites35.7%
Taylor expanded in C around 0
Applied rewrites32.0%
Final simplification23.1%
B_m = (fabs.f64 B) NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. (FPCore (A B_m C F) :precision binary64 (if (<= (pow B_m 2.0) 4e-216) (/ (sqrt (* (* (* (* C C) F) A) -16.0)) (- (fma (* C A) -4.0 (* B_m B_m)))) (* (/ (sqrt (* (+ C B_m) 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 (pow(B_m, 2.0) <= 4e-216) {
tmp = sqrt(((((C * C) * F) * A) * -16.0)) / -fma((C * A), -4.0, (B_m * B_m));
} else {
tmp = (sqrt(((C + B_m) * 2.0)) / B_m) * -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 ((B_m ^ 2.0) <= 4e-216) tmp = Float64(sqrt(Float64(Float64(Float64(Float64(C * C) * F) * A) * -16.0)) / Float64(-fma(Float64(C * A), -4.0, Float64(B_m * B_m)))); else tmp = Float64(Float64(sqrt(Float64(Float64(C + B_m) * 2.0)) / B_m) * Float64(-sqrt(F))); end return tmp end
B_m = N[Abs[B], $MachinePrecision] NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. code[A_, B$95$m_, C_, F_] := If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 4e-216], N[(N[Sqrt[N[(N[(N[(N[(C * C), $MachinePrecision] * F), $MachinePrecision] * A), $MachinePrecision] * -16.0), $MachinePrecision]], $MachinePrecision] / (-N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision])), $MachinePrecision], N[(N[(N[Sqrt[N[(N[(C + B$95$m), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / B$95$m), $MachinePrecision] * (-N[Sqrt[F], $MachinePrecision])), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
\mathbf{if}\;{B\_m}^{2} \leq 4 \cdot 10^{-216}:\\
\;\;\;\;\frac{\sqrt{\left(\left(\left(C \cdot C\right) \cdot F\right) \cdot A\right) \cdot -16}}{-\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{\left(C + B\_m\right) \cdot 2}}{B\_m} \cdot \left(-\sqrt{F}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 4.0000000000000002e-216Initial program 9.3%
Applied rewrites17.7%
Applied rewrites11.2%
Taylor expanded in A around -inf
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f6412.8
Applied rewrites12.8%
if 4.0000000000000002e-216 < (pow.f64 B #s(literal 2 binary64)) Initial program 17.8%
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.f6419.3
Applied rewrites19.3%
Applied rewrites25.6%
Applied rewrites25.7%
Taylor expanded in C around 0
Applied rewrites21.8%
Final simplification19.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
(let* ((t_0 (fma (* C A) -4.0 (* B_m B_m))))
(if (<= B_m 8.8e+22)
(/ (sqrt (* (* (* C 2.0) t_0) (* F 2.0))) (- t_0))
(* (/ (sqrt (* (+ C B_m) 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 t_0 = fma((C * A), -4.0, (B_m * B_m));
double tmp;
if (B_m <= 8.8e+22) {
tmp = sqrt((((C * 2.0) * t_0) * (F * 2.0))) / -t_0;
} else {
tmp = (sqrt(((C + B_m) * 2.0)) / B_m) * -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) t_0 = fma(Float64(C * A), -4.0, Float64(B_m * B_m)) tmp = 0.0 if (B_m <= 8.8e+22) tmp = Float64(sqrt(Float64(Float64(Float64(C * 2.0) * t_0) * Float64(F * 2.0))) / Float64(-t_0)); else tmp = Float64(Float64(sqrt(Float64(Float64(C + B_m) * 2.0)) / B_m) * Float64(-sqrt(F))); 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[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 8.8e+22], N[(N[Sqrt[N[(N[(N[(C * 2.0), $MachinePrecision] * t$95$0), $MachinePrecision] * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$0)), $MachinePrecision], N[(N[(N[Sqrt[N[(N[(C + B$95$m), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / B$95$m), $MachinePrecision] * (-N[Sqrt[F], $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(C \cdot A, -4, B\_m \cdot B\_m\right)\\
\mathbf{if}\;B\_m \leq 8.8 \cdot 10^{+22}:\\
\;\;\;\;\frac{\sqrt{\left(\left(C \cdot 2\right) \cdot t\_0\right) \cdot \left(F \cdot 2\right)}}{-t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{\left(C + B\_m\right) \cdot 2}}{B\_m} \cdot \left(-\sqrt{F}\right)\\
\end{array}
\end{array}
if B < 8.8e22Initial program 17.9%
Applied rewrites24.8%
Applied rewrites19.8%
Taylor expanded in A around -inf
lower-*.f6414.1
Applied rewrites14.1%
if 8.8e22 < B Initial program 4.8%
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.f6443.6
Applied rewrites43.6%
Applied rewrites64.0%
Applied rewrites64.3%
Taylor expanded in C around 0
Applied rewrites58.8%
Final simplification23.0%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 5.6e-107)
(/
(sqrt (* (* (* (* C C) A) -8.0) (* F 2.0)))
(- (fma (* C A) -4.0 (* B_m B_m))))
(* (/ (sqrt (* (+ C B_m) 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 (B_m <= 5.6e-107) {
tmp = sqrt(((((C * C) * A) * -8.0) * (F * 2.0))) / -fma((C * A), -4.0, (B_m * B_m));
} else {
tmp = (sqrt(((C + B_m) * 2.0)) / B_m) * -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 (B_m <= 5.6e-107) tmp = Float64(sqrt(Float64(Float64(Float64(Float64(C * C) * A) * -8.0) * Float64(F * 2.0))) / Float64(-fma(Float64(C * A), -4.0, Float64(B_m * B_m)))); else tmp = Float64(Float64(sqrt(Float64(Float64(C + B_m) * 2.0)) / B_m) * Float64(-sqrt(F))); end return tmp end
B_m = N[Abs[B], $MachinePrecision] NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 5.6e-107], N[(N[Sqrt[N[(N[(N[(N[(C * C), $MachinePrecision] * A), $MachinePrecision] * -8.0), $MachinePrecision] * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-N[(N[(C * A), $MachinePrecision] * -4.0 + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision])), $MachinePrecision], N[(N[(N[Sqrt[N[(N[(C + B$95$m), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / B$95$m), $MachinePrecision] * (-N[Sqrt[F], $MachinePrecision])), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 5.6 \cdot 10^{-107}:\\
\;\;\;\;\frac{\sqrt{\left(\left(\left(C \cdot C\right) \cdot A\right) \cdot -8\right) \cdot \left(F \cdot 2\right)}}{-\mathsf{fma}\left(C \cdot A, -4, B\_m \cdot B\_m\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{\left(C + B\_m\right) \cdot 2}}{B\_m} \cdot \left(-\sqrt{F}\right)\\
\end{array}
\end{array}
if B < 5.5999999999999998e-107Initial program 14.6%
Applied rewrites21.3%
Applied rewrites15.7%
Taylor expanded in A around -inf
lower-*.f64N/A
lower-*.f64N/A
unpow2N/A
lower-*.f649.3
Applied rewrites9.3%
if 5.5999999999999998e-107 < B Initial program 16.8%
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.f6441.5
Applied rewrites41.5%
Applied rewrites56.1%
Applied rewrites56.2%
Taylor expanded in C around 0
Applied rewrites50.3%
Final simplification21.7%
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 2.35e+145) (/ (sqrt (* F 2.0)) (- (sqrt 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 <= 2.35e+145) {
tmp = sqrt((F * 2.0)) / -sqrt(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 <= 2.35d+145) then
tmp = sqrt((f * 2.0d0)) / -sqrt(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 <= 2.35e+145) {
tmp = Math.sqrt((F * 2.0)) / -Math.sqrt(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 <= 2.35e+145: tmp = math.sqrt((F * 2.0)) / -math.sqrt(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 <= 2.35e+145) tmp = Float64(sqrt(Float64(F * 2.0)) / Float64(-sqrt(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 <= 2.35e+145)
tmp = sqrt((F * 2.0)) / -sqrt(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, 2.35e+145], N[(N[Sqrt[N[(F * 2.0), $MachinePrecision]], $MachinePrecision] / (-N[Sqrt[B$95$m], $MachinePrecision])), $MachinePrecision], N[(N[(N[Sqrt[N[(C * 2.0), $MachinePrecision]], $MachinePrecision] * N[((-N[Sqrt[2.0], $MachinePrecision]) / B$95$m), $MachinePrecision]), $MachinePrecision] * N[Sqrt[F], $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 2.35 \cdot 10^{+145}:\\
\;\;\;\;\frac{\sqrt{F \cdot 2}}{-\sqrt{B\_m}}\\
\mathbf{else}:\\
\;\;\;\;\left(\sqrt{C \cdot 2} \cdot \frac{-\sqrt{2}}{B\_m}\right) \cdot \sqrt{F}\\
\end{array}
\end{array}
if C < 2.3500000000000001e145Initial program 17.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-/.f6414.7
Applied rewrites14.7%
Applied rewrites14.8%
Applied rewrites18.3%
if 2.3500000000000001e145 < C Initial program 1.7%
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.f647.7
Applied rewrites7.7%
Applied rewrites10.7%
Taylor expanded in B around 0
Applied rewrites10.7%
Final simplification17.4%
B_m = (fabs.f64 B) NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. (FPCore (A B_m C F) :precision binary64 (* (/ (sqrt (* (+ C B_m) 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) {
return (sqrt(((C + B_m) * 2.0)) / B_m) * -sqrt(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(((c + b_m) * 2.0d0)) / b_m) * -sqrt(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(((C + B_m) * 2.0)) / B_m) * -Math.sqrt(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(((C + B_m) * 2.0)) / B_m) * -math.sqrt(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(Float64(sqrt(Float64(Float64(C + B_m) * 2.0)) / B_m) * Float64(-sqrt(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(((C + B_m) * 2.0)) / B_m) * -sqrt(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[(N[(N[Sqrt[N[(N[(C + B$95$m), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision] / B$95$m), $MachinePrecision] * (-N[Sqrt[F], $MachinePrecision])), $MachinePrecision]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\frac{\sqrt{\left(C + B\_m\right) \cdot 2}}{B\_m} \cdot \left(-\sqrt{F}\right)
\end{array}
Initial program 15.3%
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.f6415.2
Applied rewrites15.2%
Applied rewrites19.6%
Applied rewrites19.7%
Taylor expanded in C around 0
Applied rewrites15.9%
Final simplification15.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 (/ (sqrt (* F 2.0)) (- (sqrt B_m))))
B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
return sqrt((F * 2.0)) / -sqrt(B_m);
}
B_m = abs(b)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
code = sqrt((f * 2.0d0)) / -sqrt(b_m)
end function
B_m = Math.abs(B);
assert A < B_m && B_m < C && C < F;
public static double code(double A, double B_m, double C, double F) {
return Math.sqrt((F * 2.0)) / -Math.sqrt(B_m);
}
B_m = math.fabs(B) [A, B_m, C, F] = sort([A, B_m, C, F]) def code(A, B_m, C, F): return math.sqrt((F * 2.0)) / -math.sqrt(B_m)
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) return Float64(sqrt(Float64(F * 2.0)) / Float64(-sqrt(B_m))) end
B_m = abs(B);
A, B_m, C, F = num2cell(sort([A, B_m, C, F])){:}
function tmp = code(A, B_m, C, F)
tmp = sqrt((F * 2.0)) / -sqrt(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[N[(F * 2.0), $MachinePrecision]], $MachinePrecision] / (-N[Sqrt[B$95$m], $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 \cdot 2}}{-\sqrt{B\_m}}
\end{array}
Initial program 15.3%
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-/.f6413.2
Applied rewrites13.2%
Applied rewrites13.3%
Applied rewrites16.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 (* (- (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 15.3%
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-/.f6413.2
Applied rewrites13.2%
Applied rewrites13.3%
Applied rewrites16.2%
Final simplification16.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 (- (sqrt (/ (* F 2.0) B_m))))
B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
return -sqrt(((F * 2.0) / B_m));
}
B_m = abs(b)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
code = -sqrt(((f * 2.0d0) / b_m))
end function
B_m = Math.abs(B);
assert A < B_m && B_m < C && C < F;
public static double code(double A, double B_m, double C, double F) {
return -Math.sqrt(((F * 2.0) / B_m));
}
B_m = math.fabs(B) [A, B_m, C, F] = sort([A, B_m, C, F]) def code(A, B_m, C, F): return -math.sqrt(((F * 2.0) / B_m))
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) return Float64(-sqrt(Float64(Float64(F * 2.0) / B_m))) end
B_m = abs(B);
A, B_m, C, F = num2cell(sort([A, B_m, C, F])){:}
function tmp = code(A, B_m, C, F)
tmp = -sqrt(((F * 2.0) / B_m));
end
B_m = N[Abs[B], $MachinePrecision] NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. code[A_, B$95$m_, C_, F_] := (-N[Sqrt[N[(N[(F * 2.0), $MachinePrecision] / B$95$m), $MachinePrecision]], $MachinePrecision])
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
-\sqrt{\frac{F \cdot 2}{B\_m}}
\end{array}
Initial program 15.3%
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-/.f6413.2
Applied rewrites13.2%
Applied rewrites13.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 (- (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 15.3%
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-/.f6413.2
Applied rewrites13.2%
Applied rewrites13.3%
Applied rewrites13.3%
herbie shell --seed 2024304
(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))))