
(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 11 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 (* (* 4.0 A) C)) (t_1 (/ 1.0 (sqrt 2.0))))
(if (<= B_m 3.2e-283)
(/ -1.0 (* t_1 (sqrt (* (/ C F) -2.0))))
(if (<= B_m 5.2e-60)
(/
(sqrt (* (+ A A) (* (* (- (pow B_m 2.0) t_0) F) 2.0)))
(- t_0 (pow B_m 2.0)))
(if (<= B_m 1.55e+149)
(*
(sqrt
(*
(/ (- (+ A C) (hypot (- A C) B_m)) (fma (* A -4.0) C (* B_m B_m)))
F))
(- (sqrt 2.0)))
(/ -1.0 (* (sqrt (/ (- B_m) F)) t_1)))))))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 = (4.0 * A) * C;
double t_1 = 1.0 / sqrt(2.0);
double tmp;
if (B_m <= 3.2e-283) {
tmp = -1.0 / (t_1 * sqrt(((C / F) * -2.0)));
} else if (B_m <= 5.2e-60) {
tmp = sqrt(((A + A) * (((pow(B_m, 2.0) - t_0) * F) * 2.0))) / (t_0 - pow(B_m, 2.0));
} else if (B_m <= 1.55e+149) {
tmp = sqrt(((((A + C) - hypot((A - C), B_m)) / fma((A * -4.0), C, (B_m * B_m))) * F)) * -sqrt(2.0);
} else {
tmp = -1.0 / (sqrt((-B_m / F)) * t_1);
}
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(4.0 * A) * C) t_1 = Float64(1.0 / sqrt(2.0)) tmp = 0.0 if (B_m <= 3.2e-283) tmp = Float64(-1.0 / Float64(t_1 * sqrt(Float64(Float64(C / F) * -2.0)))); elseif (B_m <= 5.2e-60) tmp = Float64(sqrt(Float64(Float64(A + A) * Float64(Float64(Float64((B_m ^ 2.0) - t_0) * F) * 2.0))) / Float64(t_0 - (B_m ^ 2.0))); elseif (B_m <= 1.55e+149) tmp = Float64(sqrt(Float64(Float64(Float64(Float64(A + C) - hypot(Float64(A - C), B_m)) / fma(Float64(A * -4.0), C, Float64(B_m * B_m))) * F)) * Float64(-sqrt(2.0))); else tmp = Float64(-1.0 / Float64(sqrt(Float64(Float64(-B_m) / F)) * t_1)); 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[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]}, Block[{t$95$1 = N[(1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 3.2e-283], N[(-1.0 / N[(t$95$1 * N[Sqrt[N[(N[(C / F), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 5.2e-60], N[(N[Sqrt[N[(N[(A + A), $MachinePrecision] * N[(N[(N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$0), $MachinePrecision] * F), $MachinePrecision] * 2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$0 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 1.55e+149], N[(N[Sqrt[N[(N[(N[(N[(A + C), $MachinePrecision] - N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision]), $MachinePrecision] / N[(N[(A * -4.0), $MachinePrecision] * C + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * F), $MachinePrecision]], $MachinePrecision] * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision], N[(-1.0 / N[(N[Sqrt[N[((-B$95$m) / F), $MachinePrecision]], $MachinePrecision] * t$95$1), $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(4 \cdot A\right) \cdot C\\
t_1 := \frac{1}{\sqrt{2}}\\
\mathbf{if}\;B\_m \leq 3.2 \cdot 10^{-283}:\\
\;\;\;\;\frac{-1}{t\_1 \cdot \sqrt{\frac{C}{F} \cdot -2}}\\
\mathbf{elif}\;B\_m \leq 5.2 \cdot 10^{-60}:\\
\;\;\;\;\frac{\sqrt{\left(A + A\right) \cdot \left(\left(\left({B\_m}^{2} - t\_0\right) \cdot F\right) \cdot 2\right)}}{t\_0 - {B\_m}^{2}}\\
\mathbf{elif}\;B\_m \leq 1.55 \cdot 10^{+149}:\\
\;\;\;\;\sqrt{\frac{\left(A + C\right) - \mathsf{hypot}\left(A - C, B\_m\right)}{\mathsf{fma}\left(A \cdot -4, C, B\_m \cdot B\_m\right)} \cdot F} \cdot \left(-\sqrt{2}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\sqrt{\frac{-B\_m}{F}} \cdot t\_1}\\
\end{array}
\end{array}
if B < 3.20000000000000012e-283Initial program 21.7%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites28.9%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites5.2%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites27.1%
Taylor expanded in A around -inf
Applied rewrites14.2%
if 3.20000000000000012e-283 < B < 5.1999999999999995e-60Initial program 13.9%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6426.7
Applied rewrites26.7%
if 5.1999999999999995e-60 < B < 1.54999999999999993e149Initial program 21.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
associate-/l*N/A
lower-*.f64N/A
Applied rewrites50.7%
if 1.54999999999999993e149 < B Initial program 0.1%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites0.1%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites0.0%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites7.3%
Taylor expanded in B around inf
Applied rewrites63.9%
Final simplification28.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 (/ 1.0 (sqrt 2.0))))
(if (<= B_m 3.2e-283)
(/ -1.0 (* t_0 (sqrt (* (/ C F) -2.0))))
(if (<= B_m 8e-61)
(/
-1.0
(/
(fma (* -4.0 C) A (* B_m B_m))
(sqrt
(*
(* (* (* A C) -4.0) (* 2.0 F))
(+ (fma -0.5 (/ (* B_m B_m) C) A) A)))))
(if (<= B_m 1.55e+149)
(*
(sqrt
(*
(/ (- (+ A C) (hypot (- A C) B_m)) (fma (* A -4.0) C (* B_m B_m)))
F))
(- (sqrt 2.0)))
(/ -1.0 (* (sqrt (/ (- B_m) F)) t_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 = 1.0 / sqrt(2.0);
double tmp;
if (B_m <= 3.2e-283) {
tmp = -1.0 / (t_0 * sqrt(((C / F) * -2.0)));
} else if (B_m <= 8e-61) {
tmp = -1.0 / (fma((-4.0 * C), A, (B_m * B_m)) / sqrt(((((A * C) * -4.0) * (2.0 * F)) * (fma(-0.5, ((B_m * B_m) / C), A) + A))));
} else if (B_m <= 1.55e+149) {
tmp = sqrt(((((A + C) - hypot((A - C), B_m)) / fma((A * -4.0), C, (B_m * B_m))) * F)) * -sqrt(2.0);
} else {
tmp = -1.0 / (sqrt((-B_m / F)) * t_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(1.0 / sqrt(2.0)) tmp = 0.0 if (B_m <= 3.2e-283) tmp = Float64(-1.0 / Float64(t_0 * sqrt(Float64(Float64(C / F) * -2.0)))); elseif (B_m <= 8e-61) tmp = Float64(-1.0 / Float64(fma(Float64(-4.0 * C), A, Float64(B_m * B_m)) / sqrt(Float64(Float64(Float64(Float64(A * C) * -4.0) * Float64(2.0 * F)) * Float64(fma(-0.5, Float64(Float64(B_m * B_m) / C), A) + A))))); elseif (B_m <= 1.55e+149) tmp = Float64(sqrt(Float64(Float64(Float64(Float64(A + C) - hypot(Float64(A - C), B_m)) / fma(Float64(A * -4.0), C, Float64(B_m * B_m))) * F)) * Float64(-sqrt(2.0))); else tmp = Float64(-1.0 / Float64(sqrt(Float64(Float64(-B_m) / F)) * t_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[(1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 3.2e-283], N[(-1.0 / N[(t$95$0 * N[Sqrt[N[(N[(C / F), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 8e-61], N[(-1.0 / N[(N[(N[(-4.0 * C), $MachinePrecision] * A + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] / N[Sqrt[N[(N[(N[(N[(A * C), $MachinePrecision] * -4.0), $MachinePrecision] * N[(2.0 * F), $MachinePrecision]), $MachinePrecision] * N[(N[(-0.5 * N[(N[(B$95$m * B$95$m), $MachinePrecision] / C), $MachinePrecision] + A), $MachinePrecision] + A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 1.55e+149], N[(N[Sqrt[N[(N[(N[(N[(A + C), $MachinePrecision] - N[Sqrt[N[(A - C), $MachinePrecision] ^ 2 + B$95$m ^ 2], $MachinePrecision]), $MachinePrecision] / N[(N[(A * -4.0), $MachinePrecision] * C + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * F), $MachinePrecision]], $MachinePrecision] * (-N[Sqrt[2.0], $MachinePrecision])), $MachinePrecision], N[(-1.0 / N[(N[Sqrt[N[((-B$95$m) / F), $MachinePrecision]], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
t_0 := \frac{1}{\sqrt{2}}\\
\mathbf{if}\;B\_m \leq 3.2 \cdot 10^{-283}:\\
\;\;\;\;\frac{-1}{t\_0 \cdot \sqrt{\frac{C}{F} \cdot -2}}\\
\mathbf{elif}\;B\_m \leq 8 \cdot 10^{-61}:\\
\;\;\;\;\frac{-1}{\frac{\mathsf{fma}\left(-4 \cdot C, A, B\_m \cdot B\_m\right)}{\sqrt{\left(\left(\left(A \cdot C\right) \cdot -4\right) \cdot \left(2 \cdot F\right)\right) \cdot \left(\mathsf{fma}\left(-0.5, \frac{B\_m \cdot B\_m}{C}, A\right) + A\right)}}}\\
\mathbf{elif}\;B\_m \leq 1.55 \cdot 10^{+149}:\\
\;\;\;\;\sqrt{\frac{\left(A + C\right) - \mathsf{hypot}\left(A - C, B\_m\right)}{\mathsf{fma}\left(A \cdot -4, C, B\_m \cdot B\_m\right)} \cdot F} \cdot \left(-\sqrt{2}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\sqrt{\frac{-B\_m}{F}} \cdot t\_0}\\
\end{array}
\end{array}
if B < 3.20000000000000012e-283Initial program 21.7%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites28.9%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites5.2%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites27.1%
Taylor expanded in A around -inf
Applied rewrites14.2%
if 3.20000000000000012e-283 < B < 8.0000000000000003e-61Initial program 13.9%
Taylor expanded in C around inf
sub-negN/A
mul-1-negN/A
remove-double-negN/A
lower-+.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6426.7
Applied rewrites26.7%
Applied rewrites26.7%
Taylor expanded in C around inf
lower-*.f64N/A
lower-*.f6426.7
Applied rewrites26.7%
if 8.0000000000000003e-61 < B < 1.54999999999999993e149Initial program 21.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
associate-/l*N/A
lower-*.f64N/A
Applied rewrites50.7%
if 1.54999999999999993e149 < B Initial program 0.1%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites0.1%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites0.0%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites7.3%
Taylor expanded in B around inf
Applied rewrites63.9%
Final simplification28.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 (fma (* -4.0 C) A (* B_m B_m))) (t_1 (/ 1.0 (sqrt 2.0))))
(if (<= B_m 3.2e-283)
(/ -1.0 (* t_1 (sqrt (* (/ C F) -2.0))))
(if (<= B_m 3.6e+47)
(/
-1.0
(/
t_0
(sqrt (* (* (* 2.0 F) t_0) (+ (fma -0.5 (/ (* B_m B_m) C) A) A)))))
(/
-1.0
(* (sqrt (* (- (/ -1.0 F) (/ (+ (/ A F) (/ C F)) B_m)) B_m)) t_1))))))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 = 1.0 / sqrt(2.0);
double tmp;
if (B_m <= 3.2e-283) {
tmp = -1.0 / (t_1 * sqrt(((C / F) * -2.0)));
} else if (B_m <= 3.6e+47) {
tmp = -1.0 / (t_0 / sqrt((((2.0 * F) * t_0) * (fma(-0.5, ((B_m * B_m) / C), A) + A))));
} else {
tmp = -1.0 / (sqrt((((-1.0 / F) - (((A / F) + (C / F)) / B_m)) * B_m)) * t_1);
}
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(-4.0 * C), A, Float64(B_m * B_m)) t_1 = Float64(1.0 / sqrt(2.0)) tmp = 0.0 if (B_m <= 3.2e-283) tmp = Float64(-1.0 / Float64(t_1 * sqrt(Float64(Float64(C / F) * -2.0)))); elseif (B_m <= 3.6e+47) tmp = Float64(-1.0 / Float64(t_0 / sqrt(Float64(Float64(Float64(2.0 * F) * t_0) * Float64(fma(-0.5, Float64(Float64(B_m * B_m) / C), A) + A))))); else tmp = Float64(-1.0 / Float64(sqrt(Float64(Float64(Float64(-1.0 / F) - Float64(Float64(Float64(A / F) + Float64(C / F)) / B_m)) * B_m)) * t_1)); 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[(-4.0 * C), $MachinePrecision] * A + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 3.2e-283], N[(-1.0 / N[(t$95$1 * N[Sqrt[N[(N[(C / F), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 3.6e+47], N[(-1.0 / N[(t$95$0 / N[Sqrt[N[(N[(N[(2.0 * F), $MachinePrecision] * t$95$0), $MachinePrecision] * N[(N[(-0.5 * N[(N[(B$95$m * B$95$m), $MachinePrecision] / C), $MachinePrecision] + A), $MachinePrecision] + A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 / N[(N[Sqrt[N[(N[(N[(-1.0 / F), $MachinePrecision] - N[(N[(N[(A / F), $MachinePrecision] + N[(C / F), $MachinePrecision]), $MachinePrecision] / B$95$m), $MachinePrecision]), $MachinePrecision] * B$95$m), $MachinePrecision]], $MachinePrecision] * t$95$1), $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 \cdot C, A, B\_m \cdot B\_m\right)\\
t_1 := \frac{1}{\sqrt{2}}\\
\mathbf{if}\;B\_m \leq 3.2 \cdot 10^{-283}:\\
\;\;\;\;\frac{-1}{t\_1 \cdot \sqrt{\frac{C}{F} \cdot -2}}\\
\mathbf{elif}\;B\_m \leq 3.6 \cdot 10^{+47}:\\
\;\;\;\;\frac{-1}{\frac{t\_0}{\sqrt{\left(\left(2 \cdot F\right) \cdot t\_0\right) \cdot \left(\mathsf{fma}\left(-0.5, \frac{B\_m \cdot B\_m}{C}, A\right) + A\right)}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\sqrt{\left(\frac{-1}{F} - \frac{\frac{A}{F} + \frac{C}{F}}{B\_m}\right) \cdot B\_m} \cdot t\_1}\\
\end{array}
\end{array}
if B < 3.20000000000000012e-283Initial program 21.7%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites28.9%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites5.2%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites27.1%
Taylor expanded in A around -inf
Applied rewrites14.2%
if 3.20000000000000012e-283 < B < 3.60000000000000008e47Initial program 18.3%
Taylor expanded in C around inf
sub-negN/A
mul-1-negN/A
remove-double-negN/A
lower-+.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6428.4
Applied rewrites28.4%
Applied rewrites28.4%
if 3.60000000000000008e47 < B Initial program 6.7%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites6.9%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites0.1%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites22.1%
Taylor expanded in B around inf
Applied rewrites54.1%
Final simplification25.9%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (/ 1.0 (sqrt 2.0))) (t_1 (fma (* -4.0 C) A (* B_m B_m))))
(if (<= B_m 3.2e-283)
(/ -1.0 (* t_0 (sqrt (* (/ C F) -2.0))))
(if (<= B_m 3.6e+47)
(/
(sqrt (* (* (* 2.0 F) t_1) (+ (fma -0.5 (/ (* B_m B_m) C) A) A)))
(- t_1))
(/
-1.0
(* (sqrt (* (- (/ -1.0 F) (/ (+ (/ A F) (/ C F)) B_m)) B_m)) t_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 = 1.0 / sqrt(2.0);
double t_1 = fma((-4.0 * C), A, (B_m * B_m));
double tmp;
if (B_m <= 3.2e-283) {
tmp = -1.0 / (t_0 * sqrt(((C / F) * -2.0)));
} else if (B_m <= 3.6e+47) {
tmp = sqrt((((2.0 * F) * t_1) * (fma(-0.5, ((B_m * B_m) / C), A) + A))) / -t_1;
} else {
tmp = -1.0 / (sqrt((((-1.0 / F) - (((A / F) + (C / F)) / B_m)) * B_m)) * t_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(1.0 / sqrt(2.0)) t_1 = fma(Float64(-4.0 * C), A, Float64(B_m * B_m)) tmp = 0.0 if (B_m <= 3.2e-283) tmp = Float64(-1.0 / Float64(t_0 * sqrt(Float64(Float64(C / F) * -2.0)))); elseif (B_m <= 3.6e+47) tmp = Float64(sqrt(Float64(Float64(Float64(2.0 * F) * t_1) * Float64(fma(-0.5, Float64(Float64(B_m * B_m) / C), A) + A))) / Float64(-t_1)); else tmp = Float64(-1.0 / Float64(sqrt(Float64(Float64(Float64(-1.0 / F) - Float64(Float64(Float64(A / F) + Float64(C / F)) / B_m)) * B_m)) * t_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[(1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(-4.0 * C), $MachinePrecision] * A + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 3.2e-283], N[(-1.0 / N[(t$95$0 * N[Sqrt[N[(N[(C / F), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 3.6e+47], N[(N[Sqrt[N[(N[(N[(2.0 * F), $MachinePrecision] * t$95$1), $MachinePrecision] * N[(N[(-0.5 * N[(N[(B$95$m * B$95$m), $MachinePrecision] / C), $MachinePrecision] + A), $MachinePrecision] + A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$1)), $MachinePrecision], N[(-1.0 / N[(N[Sqrt[N[(N[(N[(-1.0 / F), $MachinePrecision] - N[(N[(N[(A / F), $MachinePrecision] + N[(C / F), $MachinePrecision]), $MachinePrecision] / B$95$m), $MachinePrecision]), $MachinePrecision] * B$95$m), $MachinePrecision]], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
t_0 := \frac{1}{\sqrt{2}}\\
t_1 := \mathsf{fma}\left(-4 \cdot C, A, B\_m \cdot B\_m\right)\\
\mathbf{if}\;B\_m \leq 3.2 \cdot 10^{-283}:\\
\;\;\;\;\frac{-1}{t\_0 \cdot \sqrt{\frac{C}{F} \cdot -2}}\\
\mathbf{elif}\;B\_m \leq 3.6 \cdot 10^{+47}:\\
\;\;\;\;\frac{\sqrt{\left(\left(2 \cdot F\right) \cdot t\_1\right) \cdot \left(\mathsf{fma}\left(-0.5, \frac{B\_m \cdot B\_m}{C}, A\right) + A\right)}}{-t\_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\sqrt{\left(\frac{-1}{F} - \frac{\frac{A}{F} + \frac{C}{F}}{B\_m}\right) \cdot B\_m} \cdot t\_0}\\
\end{array}
\end{array}
if B < 3.20000000000000012e-283Initial program 21.7%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites28.9%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites5.2%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites27.1%
Taylor expanded in A around -inf
Applied rewrites14.2%
if 3.20000000000000012e-283 < B < 3.60000000000000008e47Initial program 18.3%
Taylor expanded in C around inf
sub-negN/A
mul-1-negN/A
remove-double-negN/A
lower-+.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6428.4
Applied rewrites28.4%
Applied rewrites28.4%
if 3.60000000000000008e47 < B Initial program 6.7%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites6.9%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites0.1%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites22.1%
Taylor expanded in B around inf
Applied rewrites54.1%
Final simplification25.9%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (/ 1.0 (sqrt 2.0))) (t_1 (fma (* -4.0 C) A (* B_m B_m))))
(if (<= B_m 3.2e-283)
(/ -1.0 (* t_0 (sqrt (* (/ C F) -2.0))))
(if (<= B_m 3.6e+47)
(/
(sqrt (* (* (* 2.0 F) t_1) (+ (fma -0.5 (/ (* B_m B_m) C) A) A)))
(- t_1))
(/ -1.0 (* (sqrt (/ (- B_m) F)) t_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 = 1.0 / sqrt(2.0);
double t_1 = fma((-4.0 * C), A, (B_m * B_m));
double tmp;
if (B_m <= 3.2e-283) {
tmp = -1.0 / (t_0 * sqrt(((C / F) * -2.0)));
} else if (B_m <= 3.6e+47) {
tmp = sqrt((((2.0 * F) * t_1) * (fma(-0.5, ((B_m * B_m) / C), A) + A))) / -t_1;
} else {
tmp = -1.0 / (sqrt((-B_m / F)) * t_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(1.0 / sqrt(2.0)) t_1 = fma(Float64(-4.0 * C), A, Float64(B_m * B_m)) tmp = 0.0 if (B_m <= 3.2e-283) tmp = Float64(-1.0 / Float64(t_0 * sqrt(Float64(Float64(C / F) * -2.0)))); elseif (B_m <= 3.6e+47) tmp = Float64(sqrt(Float64(Float64(Float64(2.0 * F) * t_1) * Float64(fma(-0.5, Float64(Float64(B_m * B_m) / C), A) + A))) / Float64(-t_1)); else tmp = Float64(-1.0 / Float64(sqrt(Float64(Float64(-B_m) / F)) * t_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[(1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(-4.0 * C), $MachinePrecision] * A + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 3.2e-283], N[(-1.0 / N[(t$95$0 * N[Sqrt[N[(N[(C / F), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 3.6e+47], N[(N[Sqrt[N[(N[(N[(2.0 * F), $MachinePrecision] * t$95$1), $MachinePrecision] * N[(N[(-0.5 * N[(N[(B$95$m * B$95$m), $MachinePrecision] / C), $MachinePrecision] + A), $MachinePrecision] + A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$1)), $MachinePrecision], N[(-1.0 / N[(N[Sqrt[N[((-B$95$m) / F), $MachinePrecision]], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
t_0 := \frac{1}{\sqrt{2}}\\
t_1 := \mathsf{fma}\left(-4 \cdot C, A, B\_m \cdot B\_m\right)\\
\mathbf{if}\;B\_m \leq 3.2 \cdot 10^{-283}:\\
\;\;\;\;\frac{-1}{t\_0 \cdot \sqrt{\frac{C}{F} \cdot -2}}\\
\mathbf{elif}\;B\_m \leq 3.6 \cdot 10^{+47}:\\
\;\;\;\;\frac{\sqrt{\left(\left(2 \cdot F\right) \cdot t\_1\right) \cdot \left(\mathsf{fma}\left(-0.5, \frac{B\_m \cdot B\_m}{C}, A\right) + A\right)}}{-t\_1}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\sqrt{\frac{-B\_m}{F}} \cdot t\_0}\\
\end{array}
\end{array}
if B < 3.20000000000000012e-283Initial program 21.7%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites28.9%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites5.2%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites27.1%
Taylor expanded in A around -inf
Applied rewrites14.2%
if 3.20000000000000012e-283 < B < 3.60000000000000008e47Initial program 18.3%
Taylor expanded in C around inf
sub-negN/A
mul-1-negN/A
remove-double-negN/A
lower-+.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6428.4
Applied rewrites28.4%
Applied rewrites28.4%
if 3.60000000000000008e47 < B Initial program 6.7%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites6.9%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites0.1%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites22.1%
Taylor expanded in B around inf
Applied rewrites54.2%
Final simplification25.9%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (/ 1.0 (sqrt 2.0))))
(if (<= B_m 3.2e-283)
(/ -1.0 (* t_0 (sqrt (* (/ C F) -2.0))))
(if (<= B_m 2.6e+47)
(/
-1.0
(/
(fma (* -4.0 C) A (* B_m B_m))
(sqrt
(* (* (* (* A C) F) -8.0) (+ (fma -0.5 (/ (* B_m B_m) C) A) A)))))
(/ -1.0 (* (sqrt (/ (- B_m) F)) t_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 = 1.0 / sqrt(2.0);
double tmp;
if (B_m <= 3.2e-283) {
tmp = -1.0 / (t_0 * sqrt(((C / F) * -2.0)));
} else if (B_m <= 2.6e+47) {
tmp = -1.0 / (fma((-4.0 * C), A, (B_m * B_m)) / sqrt(((((A * C) * F) * -8.0) * (fma(-0.5, ((B_m * B_m) / C), A) + A))));
} else {
tmp = -1.0 / (sqrt((-B_m / F)) * t_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(1.0 / sqrt(2.0)) tmp = 0.0 if (B_m <= 3.2e-283) tmp = Float64(-1.0 / Float64(t_0 * sqrt(Float64(Float64(C / F) * -2.0)))); elseif (B_m <= 2.6e+47) tmp = Float64(-1.0 / Float64(fma(Float64(-4.0 * C), A, Float64(B_m * B_m)) / sqrt(Float64(Float64(Float64(Float64(A * C) * F) * -8.0) * Float64(fma(-0.5, Float64(Float64(B_m * B_m) / C), A) + A))))); else tmp = Float64(-1.0 / Float64(sqrt(Float64(Float64(-B_m) / F)) * t_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[(1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 3.2e-283], N[(-1.0 / N[(t$95$0 * N[Sqrt[N[(N[(C / F), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 2.6e+47], N[(-1.0 / N[(N[(N[(-4.0 * C), $MachinePrecision] * A + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] / N[Sqrt[N[(N[(N[(N[(A * C), $MachinePrecision] * F), $MachinePrecision] * -8.0), $MachinePrecision] * N[(N[(-0.5 * N[(N[(B$95$m * B$95$m), $MachinePrecision] / C), $MachinePrecision] + A), $MachinePrecision] + A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 / N[(N[Sqrt[N[((-B$95$m) / F), $MachinePrecision]], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
t_0 := \frac{1}{\sqrt{2}}\\
\mathbf{if}\;B\_m \leq 3.2 \cdot 10^{-283}:\\
\;\;\;\;\frac{-1}{t\_0 \cdot \sqrt{\frac{C}{F} \cdot -2}}\\
\mathbf{elif}\;B\_m \leq 2.6 \cdot 10^{+47}:\\
\;\;\;\;\frac{-1}{\frac{\mathsf{fma}\left(-4 \cdot C, A, B\_m \cdot B\_m\right)}{\sqrt{\left(\left(\left(A \cdot C\right) \cdot F\right) \cdot -8\right) \cdot \left(\mathsf{fma}\left(-0.5, \frac{B\_m \cdot B\_m}{C}, A\right) + A\right)}}}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\sqrt{\frac{-B\_m}{F}} \cdot t\_0}\\
\end{array}
\end{array}
if B < 3.20000000000000012e-283Initial program 21.7%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites28.9%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites5.2%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites27.1%
Taylor expanded in A around -inf
Applied rewrites14.2%
if 3.20000000000000012e-283 < B < 2.60000000000000003e47Initial program 18.3%
Taylor expanded in C around inf
sub-negN/A
mul-1-negN/A
remove-double-negN/A
lower-+.f64N/A
+-commutativeN/A
*-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6428.4
Applied rewrites28.4%
Applied rewrites28.4%
Taylor expanded in C around inf
lower-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6425.9
Applied rewrites25.9%
if 2.60000000000000003e47 < B Initial program 6.7%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites6.9%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites0.1%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites22.1%
Taylor expanded in B around inf
Applied rewrites54.2%
Final simplification25.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 (/ 1.0 (sqrt 2.0))))
(if (<= B_m 1.55e+90)
(/ -1.0 (* t_0 (sqrt (* (/ C F) -2.0))))
(/ -1.0 (* (sqrt (/ (- B_m) F)) t_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 = 1.0 / sqrt(2.0);
double tmp;
if (B_m <= 1.55e+90) {
tmp = -1.0 / (t_0 * sqrt(((C / F) * -2.0)));
} else {
tmp = -1.0 / (sqrt((-B_m / F)) * t_0);
}
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) :: t_0
real(8) :: tmp
t_0 = 1.0d0 / sqrt(2.0d0)
if (b_m <= 1.55d+90) then
tmp = (-1.0d0) / (t_0 * sqrt(((c / f) * (-2.0d0))))
else
tmp = (-1.0d0) / (sqrt((-b_m / f)) * t_0)
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 t_0 = 1.0 / Math.sqrt(2.0);
double tmp;
if (B_m <= 1.55e+90) {
tmp = -1.0 / (t_0 * Math.sqrt(((C / F) * -2.0)));
} else {
tmp = -1.0 / (Math.sqrt((-B_m / F)) * t_0);
}
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): t_0 = 1.0 / math.sqrt(2.0) tmp = 0 if B_m <= 1.55e+90: tmp = -1.0 / (t_0 * math.sqrt(((C / F) * -2.0))) else: tmp = -1.0 / (math.sqrt((-B_m / F)) * t_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(1.0 / sqrt(2.0)) tmp = 0.0 if (B_m <= 1.55e+90) tmp = Float64(-1.0 / Float64(t_0 * sqrt(Float64(Float64(C / F) * -2.0)))); else tmp = Float64(-1.0 / Float64(sqrt(Float64(Float64(-B_m) / F)) * t_0)); 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)
t_0 = 1.0 / sqrt(2.0);
tmp = 0.0;
if (B_m <= 1.55e+90)
tmp = -1.0 / (t_0 * sqrt(((C / F) * -2.0)));
else
tmp = -1.0 / (sqrt((-B_m / F)) * t_0);
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_] := Block[{t$95$0 = N[(1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 1.55e+90], N[(-1.0 / N[(t$95$0 * N[Sqrt[N[(N[(C / F), $MachinePrecision] * -2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 / N[(N[Sqrt[N[((-B$95$m) / F), $MachinePrecision]], $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\begin{array}{l}
t_0 := \frac{1}{\sqrt{2}}\\
\mathbf{if}\;B\_m \leq 1.55 \cdot 10^{+90}:\\
\;\;\;\;\frac{-1}{t\_0 \cdot \sqrt{\frac{C}{F} \cdot -2}}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\sqrt{\frac{-B\_m}{F}} \cdot t\_0}\\
\end{array}
\end{array}
if B < 1.54999999999999994e90Initial program 20.6%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites28.7%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites5.7%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites23.9%
Taylor expanded in A around -inf
Applied rewrites15.9%
if 1.54999999999999994e90 < B Initial program 5.3%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites5.5%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites0.1%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites22.5%
Taylor expanded in B around inf
Applied rewrites58.5%
Final simplification23.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 (/ -1.0 (* (sqrt (/ (- B_m) F)) (/ 1.0 (sqrt 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) {
return -1.0 / (sqrt((-B_m / F)) * (1.0 / sqrt(2.0)));
}
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 = (-1.0d0) / (sqrt((-b_m / f)) * (1.0d0 / sqrt(2.0d0)))
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 -1.0 / (Math.sqrt((-B_m / F)) * (1.0 / Math.sqrt(2.0)));
}
B_m = math.fabs(B) [A, B_m, C, F] = sort([A, B_m, C, F]) def code(A, B_m, C, F): return -1.0 / (math.sqrt((-B_m / F)) * (1.0 / math.sqrt(2.0)))
B_m = abs(B) A, B_m, C, F = sort([A, B_m, C, F]) function code(A, B_m, C, F) return Float64(-1.0 / Float64(sqrt(Float64(Float64(-B_m) / F)) * Float64(1.0 / sqrt(2.0)))) 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 = -1.0 / (sqrt((-B_m / F)) * (1.0 / sqrt(2.0)));
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[(-1.0 / N[(N[Sqrt[N[((-B$95$m) / F), $MachinePrecision]], $MachinePrecision] * N[(1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\frac{-1}{\sqrt{\frac{-B\_m}{F}} \cdot \frac{1}{\sqrt{2}}}
\end{array}
Initial program 17.8%
lift-/.f64N/A
lift-neg.f64N/A
distribute-frac-negN/A
neg-mul-1N/A
clear-numN/A
un-div-invN/A
Applied rewrites24.6%
lift-sqrt.f64N/A
lift-*.f64N/A
lift-*.f64N/A
lift-fma.f64N/A
+-commutativeN/A
metadata-evalN/A
cancel-sign-sub-invN/A
lift-*.f64N/A
pow2N/A
lift-pow.f64N/A
lift-*.f64N/A
*-commutativeN/A
associate-*l*N/A
lift-*.f64N/A
lift-*.f64N/A
lift--.f64N/A
*-commutativeN/A
Applied rewrites4.7%
Taylor expanded in F around 0
lower-*.f64N/A
Applied rewrites23.7%
Taylor expanded in B around inf
Applied rewrites13.1%
Final simplification13.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 (/ 1.0 (sqrt (/ B_m (* 2.0 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 1.0 / sqrt((B_m / (2.0 * 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 = 1.0d0 / sqrt((b_m / (2.0d0 * 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 1.0 / Math.sqrt((B_m / (2.0 * 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 1.0 / math.sqrt((B_m / (2.0 * 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(1.0 / sqrt(Float64(B_m / Float64(2.0 * 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 = 1.0 / sqrt((B_m / (2.0 * 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[(1.0 / N[Sqrt[N[(B$95$m / N[(2.0 * F), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
B_m = \left|B\right|
\\
[A, B_m, C, F] = \mathsf{sort}([A, B_m, C, F])\\
\\
\frac{1}{\sqrt{\frac{B\_m}{2 \cdot F}}}
\end{array}
Initial program 17.8%
Taylor expanded in B around -inf
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f641.7
Applied rewrites1.7%
Applied rewrites1.7%
Applied rewrites1.7%
Final simplification1.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 (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 sqrt(Float64(2.0 / Float64(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[(2.0 / N[(B$95$m / F), $MachinePrecision]), $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}{\frac{B\_m}{F}}}
\end{array}
Initial program 17.8%
Taylor expanded in B around -inf
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f641.7
Applied rewrites1.7%
Applied rewrites1.7%
Applied rewrites1.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 (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 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 17.8%
Taylor expanded in B around -inf
mul-1-negN/A
*-commutativeN/A
distribute-lft-neg-inN/A
lower-*.f64N/A
lower-neg.f64N/A
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f641.7
Applied rewrites1.7%
Applied rewrites1.7%
Applied rewrites1.7%
Final simplification1.7%
herbie shell --seed 2024284
(FPCore (A B C F)
:name "ABCF->ab-angle b"
: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))))