
(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 12 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (A B C F)
:precision binary64
(let* ((t_0 (- (pow B 2.0) (* (* 4.0 A) C))))
(/
(-
(sqrt
(*
(* 2.0 (* t_0 F))
(- (+ A C) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0)))))))
t_0)))
double code(double A, double B, double C, double F) {
double t_0 = pow(B, 2.0) - ((4.0 * A) * C);
return -sqrt(((2.0 * (t_0 * F)) * ((A + C) - sqrt((pow((A - C), 2.0) + pow(B, 2.0)))))) / t_0;
}
real(8) function code(a, b, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: t_0
t_0 = (b ** 2.0d0) - ((4.0d0 * a) * c)
code = -sqrt(((2.0d0 * (t_0 * f)) * ((a + c) - sqrt((((a - c) ** 2.0d0) + (b ** 2.0d0)))))) / t_0
end function
public static double code(double A, double B, double C, double F) {
double t_0 = Math.pow(B, 2.0) - ((4.0 * A) * C);
return -Math.sqrt(((2.0 * (t_0 * F)) * ((A + C) - Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0)))))) / t_0;
}
def code(A, B, C, F): t_0 = math.pow(B, 2.0) - ((4.0 * A) * C) return -math.sqrt(((2.0 * (t_0 * F)) * ((A + C) - math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))))) / t_0
function code(A, B, C, F) t_0 = Float64((B ^ 2.0) - Float64(Float64(4.0 * A) * C)) return Float64(Float64(-sqrt(Float64(Float64(2.0 * Float64(t_0 * F)) * Float64(Float64(A + C) - sqrt(Float64((Float64(A - C) ^ 2.0) + (B ^ 2.0))))))) / t_0) end
function tmp = code(A, B, C, F) t_0 = (B ^ 2.0) - ((4.0 * A) * C); tmp = -sqrt(((2.0 * (t_0 * F)) * ((A + C) - sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))))) / t_0; end
code[A_, B_, C_, F_] := Block[{t$95$0 = N[(N[Power[B, 2.0], $MachinePrecision] - N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]), $MachinePrecision]}, N[((-N[Sqrt[N[(N[(2.0 * N[(t$95$0 * F), $MachinePrecision]), $MachinePrecision] * N[(N[(A + C), $MachinePrecision] - N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]) / t$95$0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {B}^{2} - \left(4 \cdot A\right) \cdot C\\
\frac{-\sqrt{\left(2 \cdot \left(t\_0 \cdot F\right)\right) \cdot \left(\left(A + C\right) - \sqrt{{\left(A - C\right)}^{2} + {B}^{2}}\right)}}{t\_0}
\end{array}
\end{array}
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (fma (* -4.0 C) A (* B_m B_m))) (t_1 (- (sqrt 2.0))))
(if (<= (pow B_m 2.0) 1e-169)
(/
(sqrt (* (* t_0 (* F 2.0)) (+ (fma -0.5 (/ (* B_m B_m) C) A) A)))
(- t_0))
(if (<= (pow B_m 2.0) 5e-71)
(* t_1 (sqrt (* (/ F C) -0.5)))
(if (<= (pow B_m 2.0) 5e+305)
(- (sqrt (* (* (/ (- (+ C A) (hypot B_m (- A C))) t_0) F) 2.0)))
(* (/ (sqrt (* (- A (hypot B_m A)) F)) 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 = -sqrt(2.0);
double tmp;
if (pow(B_m, 2.0) <= 1e-169) {
tmp = sqrt(((t_0 * (F * 2.0)) * (fma(-0.5, ((B_m * B_m) / C), A) + A))) / -t_0;
} else if (pow(B_m, 2.0) <= 5e-71) {
tmp = t_1 * sqrt(((F / C) * -0.5));
} else if (pow(B_m, 2.0) <= 5e+305) {
tmp = -sqrt((((((C + A) - hypot(B_m, (A - C))) / t_0) * F) * 2.0));
} else {
tmp = (sqrt(((A - hypot(B_m, A)) * F)) / 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(-sqrt(2.0)) tmp = 0.0 if ((B_m ^ 2.0) <= 1e-169) tmp = Float64(sqrt(Float64(Float64(t_0 * Float64(F * 2.0)) * Float64(fma(-0.5, Float64(Float64(B_m * B_m) / C), A) + A))) / Float64(-t_0)); elseif ((B_m ^ 2.0) <= 5e-71) tmp = Float64(t_1 * sqrt(Float64(Float64(F / C) * -0.5))); elseif ((B_m ^ 2.0) <= 5e+305) tmp = Float64(-sqrt(Float64(Float64(Float64(Float64(Float64(C + A) - hypot(B_m, Float64(A - C))) / t_0) * F) * 2.0))); else tmp = Float64(Float64(sqrt(Float64(Float64(A - hypot(B_m, A)) * F)) / 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[Sqrt[2.0], $MachinePrecision])}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 1e-169], N[(N[Sqrt[N[(N[(t$95$0 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision] * N[(N[(-0.5 * N[(N[(B$95$m * B$95$m), $MachinePrecision] / C), $MachinePrecision] + A), $MachinePrecision] + A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$0)), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e-71], N[(t$95$1 * N[Sqrt[N[(N[(F / C), $MachinePrecision] * -0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e+305], (-N[Sqrt[N[(N[(N[(N[(N[(C + A), $MachinePrecision] - N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision] * F), $MachinePrecision] * 2.0), $MachinePrecision]], $MachinePrecision]), N[(N[(N[Sqrt[N[(N[(A - N[Sqrt[B$95$m ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision] * F), $MachinePrecision]], $MachinePrecision] / B$95$m), $MachinePrecision] * t$95$1), $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 := -\sqrt{2}\\
\mathbf{if}\;{B\_m}^{2} \leq 10^{-169}:\\
\;\;\;\;\frac{\sqrt{\left(t\_0 \cdot \left(F \cdot 2\right)\right) \cdot \left(\mathsf{fma}\left(-0.5, \frac{B\_m \cdot B\_m}{C}, A\right) + A\right)}}{-t\_0}\\
\mathbf{elif}\;{B\_m}^{2} \leq 5 \cdot 10^{-71}:\\
\;\;\;\;t\_1 \cdot \sqrt{\frac{F}{C} \cdot -0.5}\\
\mathbf{elif}\;{B\_m}^{2} \leq 5 \cdot 10^{+305}:\\
\;\;\;\;-\sqrt{\left(\frac{\left(C + A\right) - \mathsf{hypot}\left(B\_m, A - C\right)}{t\_0} \cdot F\right) \cdot 2}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{\left(A - \mathsf{hypot}\left(B\_m, A\right)\right) \cdot F}}{B\_m} \cdot t\_1\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 1.00000000000000002e-169Initial program 23.3%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6427.8
Applied rewrites27.8%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites27.8%
Taylor expanded in C around inf
sub-negN/A
mul-1-negN/A
remove-double-negN/A
lower-+.f64N/A
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6428.9
Applied rewrites28.9%
if 1.00000000000000002e-169 < (pow.f64 B #s(literal 2 binary64)) < 4.99999999999999998e-71Initial program 22.5%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6413.2
Applied rewrites13.2%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites13.2%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites23.3%
Taylor expanded in A around -inf
Applied rewrites34.3%
if 4.99999999999999998e-71 < (pow.f64 B #s(literal 2 binary64)) < 5.00000000000000009e305Initial program 33.0%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6414.6
Applied rewrites14.6%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites14.6%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites60.1%
Applied rewrites60.2%
if 5.00000000000000009e305 < (pow.f64 B #s(literal 2 binary64)) Initial program 0.0%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f640.0
Applied rewrites0.0%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites0.0%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites4.6%
Taylor expanded in C around 0
Applied rewrites23.4%
Final simplification37.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 (- A (hypot B_m A)))
(t_1 (fma (* -4.0 C) A (* B_m B_m)))
(t_2 (- t_1))
(t_3 (- (sqrt 2.0))))
(if (<= (pow B_m 2.0) 1e-169)
(/ (sqrt (* (* t_1 (* F 2.0)) (+ (fma -0.5 (/ (* B_m B_m) C) A) A))) t_2)
(if (<= (pow B_m 2.0) 2e-96)
(* t_3 (sqrt (* (/ F C) -0.5)))
(if (<= (pow B_m 2.0) 5e+53)
(/ (sqrt (* (* (* A 2.0) (* F 2.0)) t_1)) t_2)
(if (<= (pow B_m 2.0) 5e+292)
(* (sqrt (* (/ t_0 (* B_m B_m)) F)) t_3)
(* (/ (sqrt (* t_0 F)) B_m) t_3)))))))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 = A - hypot(B_m, A);
double t_1 = fma((-4.0 * C), A, (B_m * B_m));
double t_2 = -t_1;
double t_3 = -sqrt(2.0);
double tmp;
if (pow(B_m, 2.0) <= 1e-169) {
tmp = sqrt(((t_1 * (F * 2.0)) * (fma(-0.5, ((B_m * B_m) / C), A) + A))) / t_2;
} else if (pow(B_m, 2.0) <= 2e-96) {
tmp = t_3 * sqrt(((F / C) * -0.5));
} else if (pow(B_m, 2.0) <= 5e+53) {
tmp = sqrt((((A * 2.0) * (F * 2.0)) * t_1)) / t_2;
} else if (pow(B_m, 2.0) <= 5e+292) {
tmp = sqrt(((t_0 / (B_m * B_m)) * F)) * t_3;
} else {
tmp = (sqrt((t_0 * F)) / B_m) * t_3;
}
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(A - hypot(B_m, A)) t_1 = fma(Float64(-4.0 * C), A, Float64(B_m * B_m)) t_2 = Float64(-t_1) t_3 = Float64(-sqrt(2.0)) tmp = 0.0 if ((B_m ^ 2.0) <= 1e-169) tmp = Float64(sqrt(Float64(Float64(t_1 * Float64(F * 2.0)) * Float64(fma(-0.5, Float64(Float64(B_m * B_m) / C), A) + A))) / t_2); elseif ((B_m ^ 2.0) <= 2e-96) tmp = Float64(t_3 * sqrt(Float64(Float64(F / C) * -0.5))); elseif ((B_m ^ 2.0) <= 5e+53) tmp = Float64(sqrt(Float64(Float64(Float64(A * 2.0) * Float64(F * 2.0)) * t_1)) / t_2); elseif ((B_m ^ 2.0) <= 5e+292) tmp = Float64(sqrt(Float64(Float64(t_0 / Float64(B_m * B_m)) * F)) * t_3); else tmp = Float64(Float64(sqrt(Float64(t_0 * F)) / B_m) * t_3); 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[(A - N[Sqrt[B$95$m ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(-4.0 * C), $MachinePrecision] * A + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = (-t$95$1)}, Block[{t$95$3 = (-N[Sqrt[2.0], $MachinePrecision])}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 1e-169], N[(N[Sqrt[N[(N[(t$95$1 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision] * N[(N[(-0.5 * N[(N[(B$95$m * B$95$m), $MachinePrecision] / C), $MachinePrecision] + A), $MachinePrecision] + A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 2e-96], N[(t$95$3 * N[Sqrt[N[(N[(F / C), $MachinePrecision] * -0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e+53], N[(N[Sqrt[N[(N[(N[(A * 2.0), $MachinePrecision] * N[(F * 2.0), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision]], $MachinePrecision] / t$95$2), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e+292], N[(N[Sqrt[N[(N[(t$95$0 / N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] * F), $MachinePrecision]], $MachinePrecision] * t$95$3), $MachinePrecision], N[(N[(N[Sqrt[N[(t$95$0 * F), $MachinePrecision]], $MachinePrecision] / B$95$m), $MachinePrecision] * t$95$3), $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 := A - \mathsf{hypot}\left(B\_m, A\right)\\
t_1 := \mathsf{fma}\left(-4 \cdot C, A, B\_m \cdot B\_m\right)\\
t_2 := -t\_1\\
t_3 := -\sqrt{2}\\
\mathbf{if}\;{B\_m}^{2} \leq 10^{-169}:\\
\;\;\;\;\frac{\sqrt{\left(t\_1 \cdot \left(F \cdot 2\right)\right) \cdot \left(\mathsf{fma}\left(-0.5, \frac{B\_m \cdot B\_m}{C}, A\right) + A\right)}}{t\_2}\\
\mathbf{elif}\;{B\_m}^{2} \leq 2 \cdot 10^{-96}:\\
\;\;\;\;t\_3 \cdot \sqrt{\frac{F}{C} \cdot -0.5}\\
\mathbf{elif}\;{B\_m}^{2} \leq 5 \cdot 10^{+53}:\\
\;\;\;\;\frac{\sqrt{\left(\left(A \cdot 2\right) \cdot \left(F \cdot 2\right)\right) \cdot t\_1}}{t\_2}\\
\mathbf{elif}\;{B\_m}^{2} \leq 5 \cdot 10^{+292}:\\
\;\;\;\;\sqrt{\frac{t\_0}{B\_m \cdot B\_m} \cdot F} \cdot t\_3\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{t\_0 \cdot F}}{B\_m} \cdot t\_3\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 1.00000000000000002e-169Initial program 23.3%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6427.8
Applied rewrites27.8%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites27.8%
Taylor expanded in C around inf
sub-negN/A
mul-1-negN/A
remove-double-negN/A
lower-+.f64N/A
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6428.9
Applied rewrites28.9%
if 1.00000000000000002e-169 < (pow.f64 B #s(literal 2 binary64)) < 1.9999999999999998e-96Initial program 28.1%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6416.1
Applied rewrites16.1%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites16.1%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites28.7%
Taylor expanded in A around -inf
Applied rewrites38.0%
if 1.9999999999999998e-96 < (pow.f64 B #s(literal 2 binary64)) < 5.0000000000000004e53Initial program 43.6%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6423.8
Applied rewrites23.8%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites23.8%
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6423.8
Applied rewrites23.8%
if 5.0000000000000004e53 < (pow.f64 B #s(literal 2 binary64)) < 4.9999999999999996e292Initial program 23.1%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f646.9
Applied rewrites6.9%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites6.9%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites61.1%
Taylor expanded in C around 0
Applied rewrites46.8%
if 4.9999999999999996e292 < (pow.f64 B #s(literal 2 binary64)) Initial program 0.1%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f640.1
Applied rewrites0.1%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites0.1%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites7.4%
Taylor expanded in C around 0
Applied rewrites22.5%
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 (fma (* -4.0 C) A (* B_m B_m)))
(t_1 (- t_0))
(t_2 (- (sqrt 2.0))))
(if (<= (pow B_m 2.0) 1e-169)
(/ (sqrt (* (* t_0 (* F 2.0)) (+ (fma -0.5 (/ (* B_m B_m) C) A) A))) t_1)
(if (<= (pow B_m 2.0) 2e-96)
(* t_2 (sqrt (* (/ F C) -0.5)))
(if (<= (pow B_m 2.0) 5e+53)
(/ (sqrt (* (* (* A 2.0) (* F 2.0)) t_0)) t_1)
(* (sqrt (* (- A (hypot A B_m)) F)) (/ t_2 B_m)))))))B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double t_0 = fma((-4.0 * C), A, (B_m * B_m));
double t_1 = -t_0;
double t_2 = -sqrt(2.0);
double tmp;
if (pow(B_m, 2.0) <= 1e-169) {
tmp = sqrt(((t_0 * (F * 2.0)) * (fma(-0.5, ((B_m * B_m) / C), A) + A))) / t_1;
} else if (pow(B_m, 2.0) <= 2e-96) {
tmp = t_2 * sqrt(((F / C) * -0.5));
} else if (pow(B_m, 2.0) <= 5e+53) {
tmp = sqrt((((A * 2.0) * (F * 2.0)) * t_0)) / t_1;
} else {
tmp = sqrt(((A - hypot(A, B_m)) * F)) * (t_2 / 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(-4.0 * C), A, Float64(B_m * B_m)) t_1 = Float64(-t_0) t_2 = Float64(-sqrt(2.0)) tmp = 0.0 if ((B_m ^ 2.0) <= 1e-169) tmp = Float64(sqrt(Float64(Float64(t_0 * Float64(F * 2.0)) * Float64(fma(-0.5, Float64(Float64(B_m * B_m) / C), A) + A))) / t_1); elseif ((B_m ^ 2.0) <= 2e-96) tmp = Float64(t_2 * sqrt(Float64(Float64(F / C) * -0.5))); elseif ((B_m ^ 2.0) <= 5e+53) tmp = Float64(sqrt(Float64(Float64(Float64(A * 2.0) * Float64(F * 2.0)) * t_0)) / t_1); else tmp = Float64(sqrt(Float64(Float64(A - hypot(A, B_m)) * F)) * Float64(t_2 / 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[(-4.0 * C), $MachinePrecision] * A + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = (-t$95$0)}, Block[{t$95$2 = (-N[Sqrt[2.0], $MachinePrecision])}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 1e-169], N[(N[Sqrt[N[(N[(t$95$0 * N[(F * 2.0), $MachinePrecision]), $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], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 2e-96], N[(t$95$2 * N[Sqrt[N[(N[(F / C), $MachinePrecision] * -0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e+53], N[(N[Sqrt[N[(N[(N[(A * 2.0), $MachinePrecision] * N[(F * 2.0), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision], N[(N[Sqrt[N[(N[(A - N[Sqrt[A ^ 2 + B$95$m ^ 2], $MachinePrecision]), $MachinePrecision] * F), $MachinePrecision]], $MachinePrecision] * N[(t$95$2 / 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 \cdot C, A, B\_m \cdot B\_m\right)\\
t_1 := -t\_0\\
t_2 := -\sqrt{2}\\
\mathbf{if}\;{B\_m}^{2} \leq 10^{-169}:\\
\;\;\;\;\frac{\sqrt{\left(t\_0 \cdot \left(F \cdot 2\right)\right) \cdot \left(\mathsf{fma}\left(-0.5, \frac{B\_m \cdot B\_m}{C}, A\right) + A\right)}}{t\_1}\\
\mathbf{elif}\;{B\_m}^{2} \leq 2 \cdot 10^{-96}:\\
\;\;\;\;t\_2 \cdot \sqrt{\frac{F}{C} \cdot -0.5}\\
\mathbf{elif}\;{B\_m}^{2} \leq 5 \cdot 10^{+53}:\\
\;\;\;\;\frac{\sqrt{\left(\left(A \cdot 2\right) \cdot \left(F \cdot 2\right)\right) \cdot t\_0}}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\left(A - \mathsf{hypot}\left(A, B\_m\right)\right) \cdot F} \cdot \frac{t\_2}{B\_m}\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 1.00000000000000002e-169Initial program 23.3%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6427.8
Applied rewrites27.8%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites27.8%
Taylor expanded in C around inf
sub-negN/A
mul-1-negN/A
remove-double-negN/A
lower-+.f64N/A
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6428.9
Applied rewrites28.9%
if 1.00000000000000002e-169 < (pow.f64 B #s(literal 2 binary64)) < 1.9999999999999998e-96Initial program 28.1%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6416.1
Applied rewrites16.1%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites16.1%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites28.7%
Taylor expanded in A around -inf
Applied rewrites38.0%
if 1.9999999999999998e-96 < (pow.f64 B #s(literal 2 binary64)) < 5.0000000000000004e53Initial program 43.6%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6423.8
Applied rewrites23.8%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites23.8%
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6423.8
Applied rewrites23.8%
if 5.0000000000000004e53 < (pow.f64 B #s(literal 2 binary64)) Initial program 9.0%
Taylor expanded in C 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
lower--.f64N/A
unpow2N/A
unpow2N/A
lower-hypot.f6422.7
Applied rewrites22.7%
Final simplification26.3%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (fma (* -4.0 C) A (* B_m B_m)))
(t_1 (- t_0))
(t_2 (- (sqrt 2.0))))
(if (<= (pow B_m 2.0) 1e-169)
(/ (sqrt (* (* t_0 (* F 2.0)) (+ (fma -0.5 (/ (* B_m B_m) C) A) A))) t_1)
(if (<= (pow B_m 2.0) 2e-96)
(* t_2 (sqrt (* (/ F C) -0.5)))
(if (<= (pow B_m 2.0) 5e+53)
(/ (sqrt (* (* (* A 2.0) (* F 2.0)) t_0)) t_1)
(* (sqrt (* (/ (+ (- (/ C B_m) 1.0) (/ A B_m)) B_m) F)) t_2))))))B_m = fabs(B);
assert(A < B_m && B_m < C && C < F);
double code(double A, double B_m, double C, double F) {
double t_0 = fma((-4.0 * C), A, (B_m * B_m));
double t_1 = -t_0;
double t_2 = -sqrt(2.0);
double tmp;
if (pow(B_m, 2.0) <= 1e-169) {
tmp = sqrt(((t_0 * (F * 2.0)) * (fma(-0.5, ((B_m * B_m) / C), A) + A))) / t_1;
} else if (pow(B_m, 2.0) <= 2e-96) {
tmp = t_2 * sqrt(((F / C) * -0.5));
} else if (pow(B_m, 2.0) <= 5e+53) {
tmp = sqrt((((A * 2.0) * (F * 2.0)) * t_0)) / t_1;
} else {
tmp = sqrt((((((C / B_m) - 1.0) + (A / B_m)) / B_m) * F)) * t_2;
}
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(-t_0) t_2 = Float64(-sqrt(2.0)) tmp = 0.0 if ((B_m ^ 2.0) <= 1e-169) tmp = Float64(sqrt(Float64(Float64(t_0 * Float64(F * 2.0)) * Float64(fma(-0.5, Float64(Float64(B_m * B_m) / C), A) + A))) / t_1); elseif ((B_m ^ 2.0) <= 2e-96) tmp = Float64(t_2 * sqrt(Float64(Float64(F / C) * -0.5))); elseif ((B_m ^ 2.0) <= 5e+53) tmp = Float64(sqrt(Float64(Float64(Float64(A * 2.0) * Float64(F * 2.0)) * t_0)) / t_1); else tmp = Float64(sqrt(Float64(Float64(Float64(Float64(Float64(C / B_m) - 1.0) + Float64(A / B_m)) / B_m) * F)) * t_2); 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 = (-t$95$0)}, Block[{t$95$2 = (-N[Sqrt[2.0], $MachinePrecision])}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 1e-169], N[(N[Sqrt[N[(N[(t$95$0 * N[(F * 2.0), $MachinePrecision]), $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], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 2e-96], N[(t$95$2 * N[Sqrt[N[(N[(F / C), $MachinePrecision] * -0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e+53], N[(N[Sqrt[N[(N[(N[(A * 2.0), $MachinePrecision] * N[(F * 2.0), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision]], $MachinePrecision] / t$95$1), $MachinePrecision], N[(N[Sqrt[N[(N[(N[(N[(N[(C / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision] + N[(A / B$95$m), $MachinePrecision]), $MachinePrecision] / B$95$m), $MachinePrecision] * F), $MachinePrecision]], $MachinePrecision] * t$95$2), $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 := -t\_0\\
t_2 := -\sqrt{2}\\
\mathbf{if}\;{B\_m}^{2} \leq 10^{-169}:\\
\;\;\;\;\frac{\sqrt{\left(t\_0 \cdot \left(F \cdot 2\right)\right) \cdot \left(\mathsf{fma}\left(-0.5, \frac{B\_m \cdot B\_m}{C}, A\right) + A\right)}}{t\_1}\\
\mathbf{elif}\;{B\_m}^{2} \leq 2 \cdot 10^{-96}:\\
\;\;\;\;t\_2 \cdot \sqrt{\frac{F}{C} \cdot -0.5}\\
\mathbf{elif}\;{B\_m}^{2} \leq 5 \cdot 10^{+53}:\\
\;\;\;\;\frac{\sqrt{\left(\left(A \cdot 2\right) \cdot \left(F \cdot 2\right)\right) \cdot t\_0}}{t\_1}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{\left(\frac{C}{B\_m} - 1\right) + \frac{A}{B\_m}}{B\_m} \cdot F} \cdot t\_2\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 1.00000000000000002e-169Initial program 23.3%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6427.8
Applied rewrites27.8%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites27.8%
Taylor expanded in C around inf
sub-negN/A
mul-1-negN/A
remove-double-negN/A
lower-+.f64N/A
+-commutativeN/A
lower-fma.f64N/A
lower-/.f64N/A
unpow2N/A
lower-*.f6428.9
Applied rewrites28.9%
if 1.00000000000000002e-169 < (pow.f64 B #s(literal 2 binary64)) < 1.9999999999999998e-96Initial program 28.1%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6416.1
Applied rewrites16.1%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites16.1%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites28.7%
Taylor expanded in A around -inf
Applied rewrites38.0%
if 1.9999999999999998e-96 < (pow.f64 B #s(literal 2 binary64)) < 5.0000000000000004e53Initial program 43.6%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6423.8
Applied rewrites23.8%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites23.8%
lift-*.f64N/A
lift-*.f64N/A
associate-*r*N/A
*-commutativeN/A
lower-*.f64N/A
*-commutativeN/A
lower-*.f6423.8
Applied rewrites23.8%
if 5.0000000000000004e53 < (pow.f64 B #s(literal 2 binary64)) Initial program 9.0%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f642.7
Applied rewrites2.7%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites2.7%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites28.1%
Taylor expanded in B around inf
Applied rewrites23.0%
Final simplification26.4%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (- (sqrt 2.0))))
(if (<= (pow B_m 2.0) 1e-169)
(/
(sqrt (* (* (* (* C A) F) -8.0) (+ A A)))
(- (fma (* -4.0 C) A (* B_m B_m))))
(if (<= (pow B_m 2.0) 5e+130)
(* t_0 (sqrt (* (/ F C) -0.5)))
(* (sqrt (* (/ (+ (- (/ C B_m) 1.0) (/ A B_m)) 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 = -sqrt(2.0);
double tmp;
if (pow(B_m, 2.0) <= 1e-169) {
tmp = sqrt(((((C * A) * F) * -8.0) * (A + A))) / -fma((-4.0 * C), A, (B_m * B_m));
} else if (pow(B_m, 2.0) <= 5e+130) {
tmp = t_0 * sqrt(((F / C) * -0.5));
} else {
tmp = sqrt((((((C / B_m) - 1.0) + (A / B_m)) / 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(-sqrt(2.0)) tmp = 0.0 if ((B_m ^ 2.0) <= 1e-169) tmp = Float64(sqrt(Float64(Float64(Float64(Float64(C * A) * F) * -8.0) * Float64(A + A))) / Float64(-fma(Float64(-4.0 * C), A, Float64(B_m * B_m)))); elseif ((B_m ^ 2.0) <= 5e+130) tmp = Float64(t_0 * sqrt(Float64(Float64(F / C) * -0.5))); else tmp = Float64(sqrt(Float64(Float64(Float64(Float64(Float64(C / B_m) - 1.0) + Float64(A / B_m)) / 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[Sqrt[2.0], $MachinePrecision])}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 1e-169], N[(N[Sqrt[N[(N[(N[(N[(C * A), $MachinePrecision] * F), $MachinePrecision] * -8.0), $MachinePrecision] * N[(A + A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-N[(N[(-4.0 * C), $MachinePrecision] * A + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision])), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e+130], N[(t$95$0 * N[Sqrt[N[(N[(F / C), $MachinePrecision] * -0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(N[(N[(N[(N[(C / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision] + N[(A / B$95$m), $MachinePrecision]), $MachinePrecision] / B$95$m), $MachinePrecision] * F), $MachinePrecision]], $MachinePrecision] * t$95$0), $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 := -\sqrt{2}\\
\mathbf{if}\;{B\_m}^{2} \leq 10^{-169}:\\
\;\;\;\;\frac{\sqrt{\left(\left(\left(C \cdot A\right) \cdot F\right) \cdot -8\right) \cdot \left(A + A\right)}}{-\mathsf{fma}\left(-4 \cdot C, A, B\_m \cdot B\_m\right)}\\
\mathbf{elif}\;{B\_m}^{2} \leq 5 \cdot 10^{+130}:\\
\;\;\;\;t\_0 \cdot \sqrt{\frac{F}{C} \cdot -0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{\left(\frac{C}{B\_m} - 1\right) + \frac{A}{B\_m}}{B\_m} \cdot F} \cdot t\_0\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 1.00000000000000002e-169Initial program 23.3%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6427.8
Applied rewrites27.8%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites27.8%
Taylor expanded in C around inf
sub-negN/A
mul-1-negN/A
remove-double-negN/A
lower-+.f6427.8
Applied rewrites27.8%
Taylor expanded in A around inf
lower-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6427.8
Applied rewrites27.8%
if 1.00000000000000002e-169 < (pow.f64 B #s(literal 2 binary64)) < 4.9999999999999996e130Initial program 34.2%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6419.6
Applied rewrites19.6%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites19.6%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites42.9%
Taylor expanded in A around -inf
Applied rewrites21.2%
if 4.9999999999999996e130 < (pow.f64 B #s(literal 2 binary64)) Initial program 7.0%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f640.7
Applied rewrites0.7%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites0.7%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites25.2%
Taylor expanded in B around inf
Applied rewrites23.8%
Final simplification24.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 (- (sqrt 2.0))))
(if (<= (pow B_m 2.0) 1e-169)
(/
(sqrt (* (* (* (* C A) F) -8.0) (+ A A)))
(- (fma (* -4.0 C) A (* B_m B_m))))
(if (<= (pow B_m 2.0) 5e+130)
(* t_0 (sqrt (* (/ F C) -0.5)))
(* (sqrt (/ (- F) 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 = -sqrt(2.0);
double tmp;
if (pow(B_m, 2.0) <= 1e-169) {
tmp = sqrt(((((C * A) * F) * -8.0) * (A + A))) / -fma((-4.0 * C), A, (B_m * B_m));
} else if (pow(B_m, 2.0) <= 5e+130) {
tmp = t_0 * sqrt(((F / C) * -0.5));
} else {
tmp = sqrt((-F / 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(-sqrt(2.0)) tmp = 0.0 if ((B_m ^ 2.0) <= 1e-169) tmp = Float64(sqrt(Float64(Float64(Float64(Float64(C * A) * F) * -8.0) * Float64(A + A))) / Float64(-fma(Float64(-4.0 * C), A, Float64(B_m * B_m)))); elseif ((B_m ^ 2.0) <= 5e+130) tmp = Float64(t_0 * sqrt(Float64(Float64(F / C) * -0.5))); else tmp = Float64(sqrt(Float64(Float64(-F) / 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[Sqrt[2.0], $MachinePrecision])}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 1e-169], N[(N[Sqrt[N[(N[(N[(N[(C * A), $MachinePrecision] * F), $MachinePrecision] * -8.0), $MachinePrecision] * N[(A + A), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-N[(N[(-4.0 * C), $MachinePrecision] * A + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision])), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e+130], N[(t$95$0 * N[Sqrt[N[(N[(F / C), $MachinePrecision] * -0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[((-F) / B$95$m), $MachinePrecision]], $MachinePrecision] * t$95$0), $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 := -\sqrt{2}\\
\mathbf{if}\;{B\_m}^{2} \leq 10^{-169}:\\
\;\;\;\;\frac{\sqrt{\left(\left(\left(C \cdot A\right) \cdot F\right) \cdot -8\right) \cdot \left(A + A\right)}}{-\mathsf{fma}\left(-4 \cdot C, A, B\_m \cdot B\_m\right)}\\
\mathbf{elif}\;{B\_m}^{2} \leq 5 \cdot 10^{+130}:\\
\;\;\;\;t\_0 \cdot \sqrt{\frac{F}{C} \cdot -0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{-F}{B\_m}} \cdot t\_0\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 1.00000000000000002e-169Initial program 23.3%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6427.8
Applied rewrites27.8%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites27.8%
Taylor expanded in C around inf
sub-negN/A
mul-1-negN/A
remove-double-negN/A
lower-+.f6427.8
Applied rewrites27.8%
Taylor expanded in A around inf
lower-*.f64N/A
associate-*r*N/A
lower-*.f64N/A
lower-*.f6427.8
Applied rewrites27.8%
if 1.00000000000000002e-169 < (pow.f64 B #s(literal 2 binary64)) < 4.9999999999999996e130Initial program 34.2%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6419.6
Applied rewrites19.6%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites19.6%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites42.9%
Taylor expanded in A around -inf
Applied rewrites21.2%
if 4.9999999999999996e130 < (pow.f64 B #s(literal 2 binary64)) Initial program 7.0%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f640.7
Applied rewrites0.7%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites0.7%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites25.2%
Taylor expanded in B around inf
Applied rewrites22.0%
Final simplification23.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 (- (sqrt 2.0))))
(if (<= (pow B_m 2.0) 1e-173)
(/
(sqrt (* (* (* (* (+ A A) F) C) A) -8.0))
(- (fma (* -4.0 C) A (* B_m B_m))))
(if (<= (pow B_m 2.0) 5e+130)
(* t_0 (sqrt (* (/ F C) -0.5)))
(* (sqrt (/ (- F) 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 = -sqrt(2.0);
double tmp;
if (pow(B_m, 2.0) <= 1e-173) {
tmp = sqrt((((((A + A) * F) * C) * A) * -8.0)) / -fma((-4.0 * C), A, (B_m * B_m));
} else if (pow(B_m, 2.0) <= 5e+130) {
tmp = t_0 * sqrt(((F / C) * -0.5));
} else {
tmp = sqrt((-F / 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(-sqrt(2.0)) tmp = 0.0 if ((B_m ^ 2.0) <= 1e-173) tmp = Float64(sqrt(Float64(Float64(Float64(Float64(Float64(A + A) * F) * C) * A) * -8.0)) / Float64(-fma(Float64(-4.0 * C), A, Float64(B_m * B_m)))); elseif ((B_m ^ 2.0) <= 5e+130) tmp = Float64(t_0 * sqrt(Float64(Float64(F / C) * -0.5))); else tmp = Float64(sqrt(Float64(Float64(-F) / 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[Sqrt[2.0], $MachinePrecision])}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 1e-173], N[(N[Sqrt[N[(N[(N[(N[(N[(A + A), $MachinePrecision] * F), $MachinePrecision] * C), $MachinePrecision] * A), $MachinePrecision] * -8.0), $MachinePrecision]], $MachinePrecision] / (-N[(N[(-4.0 * C), $MachinePrecision] * A + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision])), $MachinePrecision], If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e+130], N[(t$95$0 * N[Sqrt[N[(N[(F / C), $MachinePrecision] * -0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[((-F) / B$95$m), $MachinePrecision]], $MachinePrecision] * t$95$0), $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 := -\sqrt{2}\\
\mathbf{if}\;{B\_m}^{2} \leq 10^{-173}:\\
\;\;\;\;\frac{\sqrt{\left(\left(\left(\left(A + A\right) \cdot F\right) \cdot C\right) \cdot A\right) \cdot -8}}{-\mathsf{fma}\left(-4 \cdot C, A, B\_m \cdot B\_m\right)}\\
\mathbf{elif}\;{B\_m}^{2} \leq 5 \cdot 10^{+130}:\\
\;\;\;\;t\_0 \cdot \sqrt{\frac{F}{C} \cdot -0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{-F}{B\_m}} \cdot t\_0\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 1e-173Initial program 23.5%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6428.1
Applied rewrites28.1%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites28.1%
Taylor expanded in C around inf
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
lower-*.f64N/A
sub-negN/A
mul-1-negN/A
remove-double-negN/A
lower-+.f6427.2
Applied rewrites27.2%
if 1e-173 < (pow.f64 B #s(literal 2 binary64)) < 4.9999999999999996e130Initial program 33.7%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6419.3
Applied rewrites19.3%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites19.3%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites42.4%
Taylor expanded in A around -inf
Applied rewrites20.9%
if 4.9999999999999996e130 < (pow.f64 B #s(literal 2 binary64)) Initial program 7.0%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f640.7
Applied rewrites0.7%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites0.7%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites25.2%
Taylor expanded in B around inf
Applied rewrites22.0%
Final simplification23.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))))
(if (<= (pow B_m 2.0) 5e+53)
(/ (sqrt (* (+ A A) (* t_0 (* F 2.0)))) (- t_0))
(* (sqrt (* (/ (+ (- (/ C B_m) 1.0) (/ A B_m)) B_m) F)) (- (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) {
double t_0 = fma((-4.0 * C), A, (B_m * B_m));
double tmp;
if (pow(B_m, 2.0) <= 5e+53) {
tmp = sqrt(((A + A) * (t_0 * (F * 2.0)))) / -t_0;
} else {
tmp = sqrt((((((C / B_m) - 1.0) + (A / B_m)) / B_m) * F)) * -sqrt(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(Float64(-4.0 * C), A, Float64(B_m * B_m)) tmp = 0.0 if ((B_m ^ 2.0) <= 5e+53) tmp = Float64(sqrt(Float64(Float64(A + A) * Float64(t_0 * Float64(F * 2.0)))) / Float64(-t_0)); else tmp = Float64(sqrt(Float64(Float64(Float64(Float64(Float64(C / B_m) - 1.0) + Float64(A / B_m)) / B_m) * F)) * Float64(-sqrt(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[(N[(-4.0 * C), $MachinePrecision] * A + N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Power[B$95$m, 2.0], $MachinePrecision], 5e+53], N[(N[Sqrt[N[(N[(A + A), $MachinePrecision] * N[(t$95$0 * N[(F * 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / (-t$95$0)), $MachinePrecision], N[(N[Sqrt[N[(N[(N[(N[(N[(C / B$95$m), $MachinePrecision] - 1.0), $MachinePrecision] + N[(A / B$95$m), $MachinePrecision]), $MachinePrecision] / B$95$m), $MachinePrecision] * F), $MachinePrecision]], $MachinePrecision] * (-N[Sqrt[2.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 := \mathsf{fma}\left(-4 \cdot C, A, B\_m \cdot B\_m\right)\\
\mathbf{if}\;{B\_m}^{2} \leq 5 \cdot 10^{+53}:\\
\;\;\;\;\frac{\sqrt{\left(A + A\right) \cdot \left(t\_0 \cdot \left(F \cdot 2\right)\right)}}{-t\_0}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{\left(\frac{C}{B\_m} - 1\right) + \frac{A}{B\_m}}{B\_m} \cdot F} \cdot \left(-\sqrt{2}\right)\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 5.0000000000000004e53Initial program 28.5%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6425.4
Applied rewrites25.4%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites25.4%
Taylor expanded in C around inf
sub-negN/A
mul-1-negN/A
remove-double-negN/A
lower-+.f6425.4
Applied rewrites25.4%
if 5.0000000000000004e53 < (pow.f64 B #s(literal 2 binary64)) Initial program 9.0%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f642.7
Applied rewrites2.7%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites2.7%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites28.1%
Taylor expanded in B around inf
Applied rewrites23.0%
Final simplification24.4%
B_m = (fabs.f64 B)
NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function.
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (- (sqrt 2.0))))
(if (<= B_m 9e+65)
(* t_0 (sqrt (* (/ F C) -0.5)))
(* (sqrt (/ (- F) 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 = -sqrt(2.0);
double tmp;
if (B_m <= 9e+65) {
tmp = t_0 * sqrt(((F / C) * -0.5));
} else {
tmp = sqrt((-F / B_m)) * 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 = -sqrt(2.0d0)
if (b_m <= 9d+65) then
tmp = t_0 * sqrt(((f / c) * (-0.5d0)))
else
tmp = sqrt((-f / b_m)) * 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 = -Math.sqrt(2.0);
double tmp;
if (B_m <= 9e+65) {
tmp = t_0 * Math.sqrt(((F / C) * -0.5));
} else {
tmp = Math.sqrt((-F / B_m)) * 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 = -math.sqrt(2.0) tmp = 0 if B_m <= 9e+65: tmp = t_0 * math.sqrt(((F / C) * -0.5)) else: tmp = math.sqrt((-F / 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(-sqrt(2.0)) tmp = 0.0 if (B_m <= 9e+65) tmp = Float64(t_0 * sqrt(Float64(Float64(F / C) * -0.5))); else tmp = Float64(sqrt(Float64(Float64(-F) / B_m)) * 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 = -sqrt(2.0);
tmp = 0.0;
if (B_m <= 9e+65)
tmp = t_0 * sqrt(((F / C) * -0.5));
else
tmp = sqrt((-F / B_m)) * 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[Sqrt[2.0], $MachinePrecision])}, If[LessEqual[B$95$m, 9e+65], N[(t$95$0 * N[Sqrt[N[(N[(F / C), $MachinePrecision] * -0.5), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[((-F) / B$95$m), $MachinePrecision]], $MachinePrecision] * t$95$0), $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 := -\sqrt{2}\\
\mathbf{if}\;B\_m \leq 9 \cdot 10^{+65}:\\
\;\;\;\;t\_0 \cdot \sqrt{\frac{F}{C} \cdot -0.5}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{-F}{B\_m}} \cdot t\_0\\
\end{array}
\end{array}
if B < 9e65Initial program 22.7%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6418.7
Applied rewrites18.7%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites18.7%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites27.7%
Taylor expanded in A around -inf
Applied rewrites16.3%
if 9e65 < B Initial program 7.6%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f641.0
Applied rewrites1.0%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites1.0%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites25.1%
Taylor expanded in B around inf
Applied rewrites45.2%
Final simplification21.1%
B_m = (fabs.f64 B) NOTE: A, B_m, C, and F should be sorted in increasing order before calling this function. (FPCore (A B_m C F) :precision binary64 (* (sqrt (/ (- F) B_m)) (- (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 sqrt((-F / B_m)) * -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 = sqrt((-f / b_m)) * -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 Math.sqrt((-F / B_m)) * -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 math.sqrt((-F / B_m)) * -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(sqrt(Float64(Float64(-F) / B_m)) * Float64(-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 = sqrt((-F / B_m)) * -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[(N[Sqrt[N[((-F) / B$95$m), $MachinePrecision]], $MachinePrecision] * (-N[Sqrt[2.0], $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}{B\_m}} \cdot \left(-\sqrt{2}\right)
\end{array}
Initial program 20.2%
Taylor expanded in C around inf
cancel-sign-sub-invN/A
metadata-evalN/A
*-lft-identityN/A
lower-+.f6415.7
Applied rewrites15.7%
lift-/.f64N/A
frac-2negN/A
lift-neg.f64N/A
remove-double-negN/A
Applied rewrites15.7%
Taylor expanded in F around 0
mul-1-negN/A
distribute-rgt-neg-inN/A
lower-*.f64N/A
Applied rewrites27.2%
Taylor expanded in B around inf
Applied rewrites11.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 (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 20.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
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f642.1
Applied rewrites2.1%
Applied rewrites2.1%
Applied rewrites2.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 (* (/ 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 20.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
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
lower-*.f64N/A
lower-sqrt.f64N/A
lower-sqrt.f64N/A
lower-/.f642.1
Applied rewrites2.1%
Applied rewrites2.1%
Applied rewrites2.1%
Final simplification2.1%
herbie shell --seed 2024325
(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))))