
(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 16 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)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (+ (* B_m B_m) (* C (* A -4.0))))
(t_1 (- A (- (hypot B_m (- A C)) C)))
(t_2 (* (* 4.0 A) C))
(t_3
(/
(sqrt
(*
(* 2.0 (* (- (pow B_m 2.0) t_2) F))
(- (+ A C) (sqrt (+ (pow B_m 2.0) (pow (- A C) 2.0))))))
(- t_2 (pow B_m 2.0))))
(t_4 (- t_2 (* B_m B_m))))
(if (<= t_3 -5e-180)
(/ (* (sqrt t_0) (sqrt (* 2.0 (* F t_1)))) t_4)
(if (<= t_3 0.0)
(/ (sqrt (* t_0 (- (* (* 2.0 F) (+ C C)) (/ (* F (* B_m B_m)) A)))) t_4)
(if (<= t_3 INFINITY)
(/
(* (sqrt (* t_1 (* F (+ (* B_m B_m) (* -4.0 (* A C)))))) (sqrt 2.0))
t_4)
(/ (* (sqrt (* F -2.0)) (sqrt B_m)) (- 0.0 B_m)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = (B_m * B_m) + (C * (A * -4.0));
double t_1 = A - (hypot(B_m, (A - C)) - C);
double t_2 = (4.0 * A) * C;
double t_3 = sqrt(((2.0 * ((pow(B_m, 2.0) - t_2) * F)) * ((A + C) - sqrt((pow(B_m, 2.0) + pow((A - C), 2.0)))))) / (t_2 - pow(B_m, 2.0));
double t_4 = t_2 - (B_m * B_m);
double tmp;
if (t_3 <= -5e-180) {
tmp = (sqrt(t_0) * sqrt((2.0 * (F * t_1)))) / t_4;
} else if (t_3 <= 0.0) {
tmp = sqrt((t_0 * (((2.0 * F) * (C + C)) - ((F * (B_m * B_m)) / A)))) / t_4;
} else if (t_3 <= ((double) INFINITY)) {
tmp = (sqrt((t_1 * (F * ((B_m * B_m) + (-4.0 * (A * C)))))) * sqrt(2.0)) / t_4;
} else {
tmp = (sqrt((F * -2.0)) * sqrt(B_m)) / (0.0 - B_m);
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = (B_m * B_m) + (C * (A * -4.0));
double t_1 = A - (Math.hypot(B_m, (A - C)) - C);
double t_2 = (4.0 * A) * C;
double t_3 = Math.sqrt(((2.0 * ((Math.pow(B_m, 2.0) - t_2) * F)) * ((A + C) - Math.sqrt((Math.pow(B_m, 2.0) + Math.pow((A - C), 2.0)))))) / (t_2 - Math.pow(B_m, 2.0));
double t_4 = t_2 - (B_m * B_m);
double tmp;
if (t_3 <= -5e-180) {
tmp = (Math.sqrt(t_0) * Math.sqrt((2.0 * (F * t_1)))) / t_4;
} else if (t_3 <= 0.0) {
tmp = Math.sqrt((t_0 * (((2.0 * F) * (C + C)) - ((F * (B_m * B_m)) / A)))) / t_4;
} else if (t_3 <= Double.POSITIVE_INFINITY) {
tmp = (Math.sqrt((t_1 * (F * ((B_m * B_m) + (-4.0 * (A * C)))))) * Math.sqrt(2.0)) / t_4;
} else {
tmp = (Math.sqrt((F * -2.0)) * Math.sqrt(B_m)) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = (B_m * B_m) + (C * (A * -4.0)) t_1 = A - (math.hypot(B_m, (A - C)) - C) t_2 = (4.0 * A) * C t_3 = math.sqrt(((2.0 * ((math.pow(B_m, 2.0) - t_2) * F)) * ((A + C) - math.sqrt((math.pow(B_m, 2.0) + math.pow((A - C), 2.0)))))) / (t_2 - math.pow(B_m, 2.0)) t_4 = t_2 - (B_m * B_m) tmp = 0 if t_3 <= -5e-180: tmp = (math.sqrt(t_0) * math.sqrt((2.0 * (F * t_1)))) / t_4 elif t_3 <= 0.0: tmp = math.sqrt((t_0 * (((2.0 * F) * (C + C)) - ((F * (B_m * B_m)) / A)))) / t_4 elif t_3 <= math.inf: tmp = (math.sqrt((t_1 * (F * ((B_m * B_m) + (-4.0 * (A * C)))))) * math.sqrt(2.0)) / t_4 else: tmp = (math.sqrt((F * -2.0)) * math.sqrt(B_m)) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0))) t_1 = Float64(A - Float64(hypot(B_m, Float64(A - C)) - C)) t_2 = Float64(Float64(4.0 * A) * C) t_3 = Float64(sqrt(Float64(Float64(2.0 * Float64(Float64((B_m ^ 2.0) - t_2) * F)) * Float64(Float64(A + C) - sqrt(Float64((B_m ^ 2.0) + (Float64(A - C) ^ 2.0)))))) / Float64(t_2 - (B_m ^ 2.0))) t_4 = Float64(t_2 - Float64(B_m * B_m)) tmp = 0.0 if (t_3 <= -5e-180) tmp = Float64(Float64(sqrt(t_0) * sqrt(Float64(2.0 * Float64(F * t_1)))) / t_4); elseif (t_3 <= 0.0) tmp = Float64(sqrt(Float64(t_0 * Float64(Float64(Float64(2.0 * F) * Float64(C + C)) - Float64(Float64(F * Float64(B_m * B_m)) / A)))) / t_4); elseif (t_3 <= Inf) tmp = Float64(Float64(sqrt(Float64(t_1 * Float64(F * Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C)))))) * sqrt(2.0)) / t_4); else tmp = Float64(Float64(sqrt(Float64(F * -2.0)) * sqrt(B_m)) / Float64(0.0 - B_m)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = (B_m * B_m) + (C * (A * -4.0)); t_1 = A - (hypot(B_m, (A - C)) - C); t_2 = (4.0 * A) * C; t_3 = sqrt(((2.0 * (((B_m ^ 2.0) - t_2) * F)) * ((A + C) - sqrt(((B_m ^ 2.0) + ((A - C) ^ 2.0)))))) / (t_2 - (B_m ^ 2.0)); t_4 = t_2 - (B_m * B_m); tmp = 0.0; if (t_3 <= -5e-180) tmp = (sqrt(t_0) * sqrt((2.0 * (F * t_1)))) / t_4; elseif (t_3 <= 0.0) tmp = sqrt((t_0 * (((2.0 * F) * (C + C)) - ((F * (B_m * B_m)) / A)))) / t_4; elseif (t_3 <= Inf) tmp = (sqrt((t_1 * (F * ((B_m * B_m) + (-4.0 * (A * C)))))) * sqrt(2.0)) / t_4; else tmp = (sqrt((F * -2.0)) * sqrt(B_m)) / (0.0 - B_m); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(A - N[(N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision] - C), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]}, Block[{t$95$3 = N[(N[Sqrt[N[(N[(2.0 * N[(N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$2), $MachinePrecision] * F), $MachinePrecision]), $MachinePrecision] * N[(N[(A + C), $MachinePrecision] - N[Sqrt[N[(N[Power[B$95$m, 2.0], $MachinePrecision] + N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$2 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$4 = N[(t$95$2 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$3, -5e-180], N[(N[(N[Sqrt[t$95$0], $MachinePrecision] * N[Sqrt[N[(2.0 * N[(F * t$95$1), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$4), $MachinePrecision], If[LessEqual[t$95$3, 0.0], N[(N[Sqrt[N[(t$95$0 * N[(N[(N[(2.0 * F), $MachinePrecision] * N[(C + C), $MachinePrecision]), $MachinePrecision] - N[(N[(F * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$4), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[(N[Sqrt[N[(t$95$1 * N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / t$95$4), $MachinePrecision], N[(N[(N[Sqrt[N[(F * -2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]]]]]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\\
t_1 := A - \left(\mathsf{hypot}\left(B\_m, A - C\right) - C\right)\\
t_2 := \left(4 \cdot A\right) \cdot C\\
t_3 := \frac{\sqrt{\left(2 \cdot \left(\left({B\_m}^{2} - t\_2\right) \cdot F\right)\right) \cdot \left(\left(A + C\right) - \sqrt{{B\_m}^{2} + {\left(A - C\right)}^{2}}\right)}}{t\_2 - {B\_m}^{2}}\\
t_4 := t\_2 - B\_m \cdot B\_m\\
\mathbf{if}\;t\_3 \leq -5 \cdot 10^{-180}:\\
\;\;\;\;\frac{\sqrt{t\_0} \cdot \sqrt{2 \cdot \left(F \cdot t\_1\right)}}{t\_4}\\
\mathbf{elif}\;t\_3 \leq 0:\\
\;\;\;\;\frac{\sqrt{t\_0 \cdot \left(\left(2 \cdot F\right) \cdot \left(C + C\right) - \frac{F \cdot \left(B\_m \cdot B\_m\right)}{A}\right)}}{t\_4}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\frac{\sqrt{t\_1 \cdot \left(F \cdot \left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right)\right)} \cdot \sqrt{2}}{t\_4}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{F \cdot -2} \cdot \sqrt{B\_m}}{0 - B\_m}\\
\end{array}
\end{array}
if (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (-.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < -5.0000000000000001e-180Initial program 40.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified46.7%
pow1/2N/A
associate-*l*N/A
unpow-prod-downN/A
*-lowering-*.f64N/A
Applied egg-rr60.4%
if -5.0000000000000001e-180 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (-.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < 0.0Initial program 3.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified3.5%
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
distribute-lft-neg-inN/A
distribute-rgt-neg-inN/A
*-commutativeN/A
sub-negN/A
pow2N/A
*-lowering-*.f64N/A
Applied egg-rr8.3%
Taylor expanded in A around inf
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cancel-sign-sub-invN/A
+-lowering-+.f64N/A
metadata-evalN/A
*-lowering-*.f6431.0%
Simplified31.0%
if 0.0 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (-.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 45.4%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified58.3%
Taylor expanded in F around 0
*-lowering-*.f64N/A
Simplified58.4%
if +inf.0 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (-.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) Initial program 0.0%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6417.2%
Simplified17.2%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr17.3%
Taylor expanded in C around 0
*-lowering-*.f64N/A
*-lowering-*.f6416.3%
Simplified16.3%
unpow1/2N/A
*-commutativeN/A
associate-*r*N/A
sqrt-prodN/A
unpow1/2N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
unpow1/2N/A
sqrt-lowering-sqrt.f6427.7%
Applied egg-rr27.7%
Final simplification43.0%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= B_m 2.8e-126)
(/ (/ 1.0 (pow (* C (* F (* -16.0 (* A C)))) -0.5)) t_0)
(if (<= B_m 3.2e+32)
(/
(*
(sqrt
(*
(- A (- (hypot B_m (- A C)) C))
(* F (+ (* B_m B_m) (* -4.0 (* A C))))))
(sqrt 2.0))
t_0)
(/ (* (sqrt (* F -2.0)) (sqrt B_m)) (- 0.0 B_m))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 2.8e-126) {
tmp = (1.0 / pow((C * (F * (-16.0 * (A * C)))), -0.5)) / t_0;
} else if (B_m <= 3.2e+32) {
tmp = (sqrt(((A - (hypot(B_m, (A - C)) - C)) * (F * ((B_m * B_m) + (-4.0 * (A * C)))))) * sqrt(2.0)) / t_0;
} else {
tmp = (sqrt((F * -2.0)) * sqrt(B_m)) / (0.0 - B_m);
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 2.8e-126) {
tmp = (1.0 / Math.pow((C * (F * (-16.0 * (A * C)))), -0.5)) / t_0;
} else if (B_m <= 3.2e+32) {
tmp = (Math.sqrt(((A - (Math.hypot(B_m, (A - C)) - C)) * (F * ((B_m * B_m) + (-4.0 * (A * C)))))) * Math.sqrt(2.0)) / t_0;
} else {
tmp = (Math.sqrt((F * -2.0)) * Math.sqrt(B_m)) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = ((4.0 * A) * C) - (B_m * B_m) tmp = 0 if B_m <= 2.8e-126: tmp = (1.0 / math.pow((C * (F * (-16.0 * (A * C)))), -0.5)) / t_0 elif B_m <= 3.2e+32: tmp = (math.sqrt(((A - (math.hypot(B_m, (A - C)) - C)) * (F * ((B_m * B_m) + (-4.0 * (A * C)))))) * math.sqrt(2.0)) / t_0 else: tmp = (math.sqrt((F * -2.0)) * math.sqrt(B_m)) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)) tmp = 0.0 if (B_m <= 2.8e-126) tmp = Float64(Float64(1.0 / (Float64(C * Float64(F * Float64(-16.0 * Float64(A * C)))) ^ -0.5)) / t_0); elseif (B_m <= 3.2e+32) tmp = Float64(Float64(sqrt(Float64(Float64(A - Float64(hypot(B_m, Float64(A - C)) - C)) * Float64(F * Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C)))))) * sqrt(2.0)) / t_0); else tmp = Float64(Float64(sqrt(Float64(F * -2.0)) * sqrt(B_m)) / Float64(0.0 - B_m)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = ((4.0 * A) * C) - (B_m * B_m); tmp = 0.0; if (B_m <= 2.8e-126) tmp = (1.0 / ((C * (F * (-16.0 * (A * C)))) ^ -0.5)) / t_0; elseif (B_m <= 3.2e+32) tmp = (sqrt(((A - (hypot(B_m, (A - C)) - C)) * (F * ((B_m * B_m) + (-4.0 * (A * C)))))) * sqrt(2.0)) / t_0; else tmp = (sqrt((F * -2.0)) * sqrt(B_m)) / (0.0 - B_m); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 2.8e-126], N[(N[(1.0 / N[Power[N[(C * N[(F * N[(-16.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[B$95$m, 3.2e+32], N[(N[(N[Sqrt[N[(N[(A - N[(N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision] - C), $MachinePrecision]), $MachinePrecision] * N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[(N[Sqrt[N[(F * -2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m\\
\mathbf{if}\;B\_m \leq 2.8 \cdot 10^{-126}:\\
\;\;\;\;\frac{\frac{1}{{\left(C \cdot \left(F \cdot \left(-16 \cdot \left(A \cdot C\right)\right)\right)\right)}^{-0.5}}}{t\_0}\\
\mathbf{elif}\;B\_m \leq 3.2 \cdot 10^{+32}:\\
\;\;\;\;\frac{\sqrt{\left(A - \left(\mathsf{hypot}\left(B\_m, A - C\right) - C\right)\right) \cdot \left(F \cdot \left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right)\right)} \cdot \sqrt{2}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{F \cdot -2} \cdot \sqrt{B\_m}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 2.79999999999999992e-126Initial program 21.0%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified24.7%
Taylor expanded in B around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.5%
Simplified11.5%
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6416.9%
Applied egg-rr16.9%
pow1/2N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
pow-powN/A
metadata-evalN/A
pow-flipN/A
pow1/2N/A
unpow-1N/A
/-lowering-/.f64N/A
pow1/2N/A
pow-flipN/A
metadata-evalN/A
pow-lowering-pow.f64N/A
Applied egg-rr17.1%
if 2.79999999999999992e-126 < B < 3.1999999999999999e32Initial program 23.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified34.1%
Taylor expanded in F around 0
*-lowering-*.f64N/A
Simplified35.8%
if 3.1999999999999999e32 < B Initial program 14.2%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6443.4%
Simplified43.4%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr43.6%
Taylor expanded in C around 0
*-lowering-*.f64N/A
*-lowering-*.f6444.0%
Simplified44.0%
unpow1/2N/A
*-commutativeN/A
associate-*r*N/A
sqrt-prodN/A
unpow1/2N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
unpow1/2N/A
sqrt-lowering-sqrt.f6473.0%
Applied egg-rr73.0%
Final simplification30.6%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= B_m 1.9e-126)
(/ (/ 1.0 (pow (* C (* F (* -16.0 (* A C)))) -0.5)) t_0)
(if (<= B_m 5e+33)
(/
(sqrt
(*
(* (+ (* B_m B_m) (* C (* A -4.0))) (* 2.0 F))
(- (+ A C) (hypot B_m (- A C)))))
t_0)
(/ (* (sqrt (* F -2.0)) (sqrt B_m)) (- 0.0 B_m))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 1.9e-126) {
tmp = (1.0 / pow((C * (F * (-16.0 * (A * C)))), -0.5)) / t_0;
} else if (B_m <= 5e+33) {
tmp = sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * F)) * ((A + C) - hypot(B_m, (A - C))))) / t_0;
} else {
tmp = (sqrt((F * -2.0)) * sqrt(B_m)) / (0.0 - B_m);
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 1.9e-126) {
tmp = (1.0 / Math.pow((C * (F * (-16.0 * (A * C)))), -0.5)) / t_0;
} else if (B_m <= 5e+33) {
tmp = Math.sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * F)) * ((A + C) - Math.hypot(B_m, (A - C))))) / t_0;
} else {
tmp = (Math.sqrt((F * -2.0)) * Math.sqrt(B_m)) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = ((4.0 * A) * C) - (B_m * B_m) tmp = 0 if B_m <= 1.9e-126: tmp = (1.0 / math.pow((C * (F * (-16.0 * (A * C)))), -0.5)) / t_0 elif B_m <= 5e+33: tmp = math.sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * F)) * ((A + C) - math.hypot(B_m, (A - C))))) / t_0 else: tmp = (math.sqrt((F * -2.0)) * math.sqrt(B_m)) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)) tmp = 0.0 if (B_m <= 1.9e-126) tmp = Float64(Float64(1.0 / (Float64(C * Float64(F * Float64(-16.0 * Float64(A * C)))) ^ -0.5)) / t_0); elseif (B_m <= 5e+33) tmp = Float64(sqrt(Float64(Float64(Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0))) * Float64(2.0 * F)) * Float64(Float64(A + C) - hypot(B_m, Float64(A - C))))) / t_0); else tmp = Float64(Float64(sqrt(Float64(F * -2.0)) * sqrt(B_m)) / Float64(0.0 - B_m)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = ((4.0 * A) * C) - (B_m * B_m); tmp = 0.0; if (B_m <= 1.9e-126) tmp = (1.0 / ((C * (F * (-16.0 * (A * C)))) ^ -0.5)) / t_0; elseif (B_m <= 5e+33) tmp = sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * F)) * ((A + C) - hypot(B_m, (A - C))))) / t_0; else tmp = (sqrt((F * -2.0)) * sqrt(B_m)) / (0.0 - B_m); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 1.9e-126], N[(N[(1.0 / N[Power[N[(C * N[(F * N[(-16.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision]), $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[B$95$m, 5e+33], N[(N[Sqrt[N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(2.0 * F), $MachinePrecision]), $MachinePrecision] * N[(N[(A + C), $MachinePrecision] - N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[(N[Sqrt[N[(F * -2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m\\
\mathbf{if}\;B\_m \leq 1.9 \cdot 10^{-126}:\\
\;\;\;\;\frac{\frac{1}{{\left(C \cdot \left(F \cdot \left(-16 \cdot \left(A \cdot C\right)\right)\right)\right)}^{-0.5}}}{t\_0}\\
\mathbf{elif}\;B\_m \leq 5 \cdot 10^{+33}:\\
\;\;\;\;\frac{\sqrt{\left(\left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right) \cdot \left(2 \cdot F\right)\right) \cdot \left(\left(A + C\right) - \mathsf{hypot}\left(B\_m, A - C\right)\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{F \cdot -2} \cdot \sqrt{B\_m}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 1.8999999999999999e-126Initial program 21.0%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified24.7%
Taylor expanded in B around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.5%
Simplified11.5%
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6416.9%
Applied egg-rr16.9%
pow1/2N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
pow-powN/A
metadata-evalN/A
pow-flipN/A
pow1/2N/A
unpow-1N/A
/-lowering-/.f64N/A
pow1/2N/A
pow-flipN/A
metadata-evalN/A
pow-lowering-pow.f64N/A
Applied egg-rr17.1%
if 1.8999999999999999e-126 < B < 4.99999999999999973e33Initial program 23.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified34.1%
if 4.99999999999999973e33 < B Initial program 14.2%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6443.4%
Simplified43.4%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr43.6%
Taylor expanded in C around 0
*-lowering-*.f64N/A
*-lowering-*.f6444.0%
Simplified44.0%
unpow1/2N/A
*-commutativeN/A
associate-*r*N/A
sqrt-prodN/A
unpow1/2N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
unpow1/2N/A
sqrt-lowering-sqrt.f6473.0%
Applied egg-rr73.0%
Final simplification30.5%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 2.2e+32)
(/
(sqrt
(*
(+ (* B_m B_m) (* C (* A -4.0)))
(* 2.0 (* F (- A (- (hypot B_m (- A C)) C))))))
(- (* (* 4.0 A) C) (* B_m B_m)))
(/ (* (sqrt (* F -2.0)) (sqrt B_m)) (- 0.0 B_m))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 2.2e+32) {
tmp = sqrt((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * (F * (A - (hypot(B_m, (A - C)) - C)))))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = (sqrt((F * -2.0)) * sqrt(B_m)) / (0.0 - B_m);
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 2.2e+32) {
tmp = Math.sqrt((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * (F * (A - (Math.hypot(B_m, (A - C)) - C)))))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = (Math.sqrt((F * -2.0)) * Math.sqrt(B_m)) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 2.2e+32: tmp = math.sqrt((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * (F * (A - (math.hypot(B_m, (A - C)) - C)))))) / (((4.0 * A) * C) - (B_m * B_m)) else: tmp = (math.sqrt((F * -2.0)) * math.sqrt(B_m)) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 2.2e+32) tmp = Float64(sqrt(Float64(Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0))) * Float64(2.0 * Float64(F * Float64(A - Float64(hypot(B_m, Float64(A - C)) - C)))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); else tmp = Float64(Float64(sqrt(Float64(F * -2.0)) * sqrt(B_m)) / Float64(0.0 - B_m)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (B_m <= 2.2e+32) tmp = sqrt((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * (F * (A - (hypot(B_m, (A - C)) - C)))))) / (((4.0 * A) * C) - (B_m * B_m)); else tmp = (sqrt((F * -2.0)) * sqrt(B_m)) / (0.0 - B_m); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 2.2e+32], N[(N[Sqrt[N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(2.0 * N[(F * N[(A - N[(N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision] - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[N[(F * -2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 2.2 \cdot 10^{+32}:\\
\;\;\;\;\frac{\sqrt{\left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right) \cdot \left(2 \cdot \left(F \cdot \left(A - \left(\mathsf{hypot}\left(B\_m, A - C\right) - C\right)\right)\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{F \cdot -2} \cdot \sqrt{B\_m}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 2.20000000000000001e32Initial program 21.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified26.0%
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
distribute-lft-neg-inN/A
distribute-rgt-neg-inN/A
*-commutativeN/A
sub-negN/A
pow2N/A
*-lowering-*.f64N/A
Applied egg-rr27.0%
if 2.20000000000000001e32 < B Initial program 14.2%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6443.4%
Simplified43.4%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr43.6%
Taylor expanded in C around 0
*-lowering-*.f64N/A
*-lowering-*.f6444.0%
Simplified44.0%
unpow1/2N/A
*-commutativeN/A
associate-*r*N/A
sqrt-prodN/A
unpow1/2N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
unpow1/2N/A
sqrt-lowering-sqrt.f6473.0%
Applied egg-rr73.0%
Final simplification36.5%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 1.28e-55)
(/
(/ 1.0 (pow (* C (* F (* -16.0 (* A C)))) -0.5))
(- (* (* 4.0 A) C) (* B_m B_m)))
(/ (* (sqrt (* F -2.0)) (sqrt B_m)) (- 0.0 B_m))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.28e-55) {
tmp = (1.0 / pow((C * (F * (-16.0 * (A * C)))), -0.5)) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = (sqrt((F * -2.0)) * sqrt(B_m)) / (0.0 - B_m);
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (b_m <= 1.28d-55) then
tmp = (1.0d0 / ((c * (f * ((-16.0d0) * (a * c)))) ** (-0.5d0))) / (((4.0d0 * a) * c) - (b_m * b_m))
else
tmp = (sqrt((f * (-2.0d0))) * sqrt(b_m)) / (0.0d0 - b_m)
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.28e-55) {
tmp = (1.0 / Math.pow((C * (F * (-16.0 * (A * C)))), -0.5)) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = (Math.sqrt((F * -2.0)) * Math.sqrt(B_m)) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 1.28e-55: tmp = (1.0 / math.pow((C * (F * (-16.0 * (A * C)))), -0.5)) / (((4.0 * A) * C) - (B_m * B_m)) else: tmp = (math.sqrt((F * -2.0)) * math.sqrt(B_m)) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 1.28e-55) tmp = Float64(Float64(1.0 / (Float64(C * Float64(F * Float64(-16.0 * Float64(A * C)))) ^ -0.5)) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); else tmp = Float64(Float64(sqrt(Float64(F * -2.0)) * sqrt(B_m)) / Float64(0.0 - B_m)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (B_m <= 1.28e-55) tmp = (1.0 / ((C * (F * (-16.0 * (A * C)))) ^ -0.5)) / (((4.0 * A) * C) - (B_m * B_m)); else tmp = (sqrt((F * -2.0)) * sqrt(B_m)) / (0.0 - B_m); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 1.28e-55], N[(N[(1.0 / N[Power[N[(C * N[(F * N[(-16.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision]), $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[N[(F * -2.0), $MachinePrecision]], $MachinePrecision] * N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 1.28 \cdot 10^{-55}:\\
\;\;\;\;\frac{\frac{1}{{\left(C \cdot \left(F \cdot \left(-16 \cdot \left(A \cdot C\right)\right)\right)\right)}^{-0.5}}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{F \cdot -2} \cdot \sqrt{B\_m}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 1.27999999999999994e-55Initial program 21.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified25.7%
Taylor expanded in B around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.8%
Simplified11.8%
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6417.8%
Applied egg-rr17.8%
pow1/2N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
pow-powN/A
metadata-evalN/A
pow-flipN/A
pow1/2N/A
unpow-1N/A
/-lowering-/.f64N/A
pow1/2N/A
pow-flipN/A
metadata-evalN/A
pow-lowering-pow.f64N/A
Applied egg-rr17.9%
if 1.27999999999999994e-55 < B Initial program 15.4%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6440.0%
Simplified40.0%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr40.1%
Taylor expanded in C around 0
*-lowering-*.f64N/A
*-lowering-*.f6440.0%
Simplified40.0%
unpow1/2N/A
*-commutativeN/A
associate-*r*N/A
sqrt-prodN/A
unpow1/2N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
unpow1/2N/A
sqrt-lowering-sqrt.f6464.1%
Applied egg-rr64.1%
Final simplification29.5%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 1.35e-55)
(/
(/ 1.0 (pow (* C (* F (* -16.0 (* A C)))) -0.5))
(- (* (* 4.0 A) C) (* B_m B_m)))
(/ (pow (* B_m (+ (* F -2.0) (/ (* 2.0 (* C F)) B_m))) 0.5) (- 0.0 B_m))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.35e-55) {
tmp = (1.0 / pow((C * (F * (-16.0 * (A * C)))), -0.5)) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = pow((B_m * ((F * -2.0) + ((2.0 * (C * F)) / B_m))), 0.5) / (0.0 - B_m);
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (b_m <= 1.35d-55) then
tmp = (1.0d0 / ((c * (f * ((-16.0d0) * (a * c)))) ** (-0.5d0))) / (((4.0d0 * a) * c) - (b_m * b_m))
else
tmp = ((b_m * ((f * (-2.0d0)) + ((2.0d0 * (c * f)) / b_m))) ** 0.5d0) / (0.0d0 - b_m)
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.35e-55) {
tmp = (1.0 / Math.pow((C * (F * (-16.0 * (A * C)))), -0.5)) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = Math.pow((B_m * ((F * -2.0) + ((2.0 * (C * F)) / B_m))), 0.5) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 1.35e-55: tmp = (1.0 / math.pow((C * (F * (-16.0 * (A * C)))), -0.5)) / (((4.0 * A) * C) - (B_m * B_m)) else: tmp = math.pow((B_m * ((F * -2.0) + ((2.0 * (C * F)) / B_m))), 0.5) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 1.35e-55) tmp = Float64(Float64(1.0 / (Float64(C * Float64(F * Float64(-16.0 * Float64(A * C)))) ^ -0.5)) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); else tmp = Float64((Float64(B_m * Float64(Float64(F * -2.0) + Float64(Float64(2.0 * Float64(C * F)) / B_m))) ^ 0.5) / Float64(0.0 - B_m)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (B_m <= 1.35e-55) tmp = (1.0 / ((C * (F * (-16.0 * (A * C)))) ^ -0.5)) / (((4.0 * A) * C) - (B_m * B_m)); else tmp = ((B_m * ((F * -2.0) + ((2.0 * (C * F)) / B_m))) ^ 0.5) / (0.0 - B_m); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 1.35e-55], N[(N[(1.0 / N[Power[N[(C * N[(F * N[(-16.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision]), $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(B$95$m * N[(N[(F * -2.0), $MachinePrecision] + N[(N[(2.0 * N[(C * F), $MachinePrecision]), $MachinePrecision] / B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 1.35 \cdot 10^{-55}:\\
\;\;\;\;\frac{\frac{1}{{\left(C \cdot \left(F \cdot \left(-16 \cdot \left(A \cdot C\right)\right)\right)\right)}^{-0.5}}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(B\_m \cdot \left(F \cdot -2 + \frac{2 \cdot \left(C \cdot F\right)}{B\_m}\right)\right)}^{0.5}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 1.35000000000000002e-55Initial program 21.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified25.7%
Taylor expanded in B around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.8%
Simplified11.8%
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6417.8%
Applied egg-rr17.8%
pow1/2N/A
associate-*l*N/A
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-commutativeN/A
metadata-evalN/A
pow-powN/A
metadata-evalN/A
pow-flipN/A
pow1/2N/A
unpow-1N/A
/-lowering-/.f64N/A
pow1/2N/A
pow-flipN/A
metadata-evalN/A
pow-lowering-pow.f64N/A
Applied egg-rr17.9%
if 1.35000000000000002e-55 < B Initial program 15.4%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6440.0%
Simplified40.0%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr40.1%
Taylor expanded in B around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6439.6%
Simplified39.6%
Final simplification23.3%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= B_m 1.28e-55) (/ (sqrt (* -16.0 (* C (* F (* A C))))) (- (* (* 4.0 A) C) (* B_m B_m))) (/ (pow (* B_m (+ (* F -2.0) (/ (* 2.0 (* C F)) B_m))) 0.5) (- 0.0 B_m))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.28e-55) {
tmp = sqrt((-16.0 * (C * (F * (A * C))))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = pow((B_m * ((F * -2.0) + ((2.0 * (C * F)) / B_m))), 0.5) / (0.0 - B_m);
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (b_m <= 1.28d-55) then
tmp = sqrt(((-16.0d0) * (c * (f * (a * c))))) / (((4.0d0 * a) * c) - (b_m * b_m))
else
tmp = ((b_m * ((f * (-2.0d0)) + ((2.0d0 * (c * f)) / b_m))) ** 0.5d0) / (0.0d0 - b_m)
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.28e-55) {
tmp = Math.sqrt((-16.0 * (C * (F * (A * C))))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = Math.pow((B_m * ((F * -2.0) + ((2.0 * (C * F)) / B_m))), 0.5) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 1.28e-55: tmp = math.sqrt((-16.0 * (C * (F * (A * C))))) / (((4.0 * A) * C) - (B_m * B_m)) else: tmp = math.pow((B_m * ((F * -2.0) + ((2.0 * (C * F)) / B_m))), 0.5) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 1.28e-55) tmp = Float64(sqrt(Float64(-16.0 * Float64(C * Float64(F * Float64(A * C))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); else tmp = Float64((Float64(B_m * Float64(Float64(F * -2.0) + Float64(Float64(2.0 * Float64(C * F)) / B_m))) ^ 0.5) / Float64(0.0 - B_m)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (B_m <= 1.28e-55) tmp = sqrt((-16.0 * (C * (F * (A * C))))) / (((4.0 * A) * C) - (B_m * B_m)); else tmp = ((B_m * ((F * -2.0) + ((2.0 * (C * F)) / B_m))) ^ 0.5) / (0.0 - B_m); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 1.28e-55], N[(N[Sqrt[N[(-16.0 * N[(C * N[(F * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(B$95$m * N[(N[(F * -2.0), $MachinePrecision] + N[(N[(2.0 * N[(C * F), $MachinePrecision]), $MachinePrecision] / B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 1.28 \cdot 10^{-55}:\\
\;\;\;\;\frac{\sqrt{-16 \cdot \left(C \cdot \left(F \cdot \left(A \cdot C\right)\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(B\_m \cdot \left(F \cdot -2 + \frac{2 \cdot \left(C \cdot F\right)}{B\_m}\right)\right)}^{0.5}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 1.27999999999999994e-55Initial program 21.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified25.7%
Taylor expanded in B around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.8%
Simplified11.8%
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6417.8%
Applied egg-rr17.8%
if 1.27999999999999994e-55 < B Initial program 15.4%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6440.0%
Simplified40.0%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr40.1%
Taylor expanded in B around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6439.6%
Simplified39.6%
Final simplification23.2%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= B_m 1.28e-55) (/ (sqrt (* -16.0 (* C (* F (* A C))))) (* 4.0 (* A C))) (/ (pow (* B_m (+ (* F -2.0) (/ (* 2.0 (* C F)) B_m))) 0.5) (- 0.0 B_m))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.28e-55) {
tmp = sqrt((-16.0 * (C * (F * (A * C))))) / (4.0 * (A * C));
} else {
tmp = pow((B_m * ((F * -2.0) + ((2.0 * (C * F)) / B_m))), 0.5) / (0.0 - B_m);
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (b_m <= 1.28d-55) then
tmp = sqrt(((-16.0d0) * (c * (f * (a * c))))) / (4.0d0 * (a * c))
else
tmp = ((b_m * ((f * (-2.0d0)) + ((2.0d0 * (c * f)) / b_m))) ** 0.5d0) / (0.0d0 - b_m)
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.28e-55) {
tmp = Math.sqrt((-16.0 * (C * (F * (A * C))))) / (4.0 * (A * C));
} else {
tmp = Math.pow((B_m * ((F * -2.0) + ((2.0 * (C * F)) / B_m))), 0.5) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 1.28e-55: tmp = math.sqrt((-16.0 * (C * (F * (A * C))))) / (4.0 * (A * C)) else: tmp = math.pow((B_m * ((F * -2.0) + ((2.0 * (C * F)) / B_m))), 0.5) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 1.28e-55) tmp = Float64(sqrt(Float64(-16.0 * Float64(C * Float64(F * Float64(A * C))))) / Float64(4.0 * Float64(A * C))); else tmp = Float64((Float64(B_m * Float64(Float64(F * -2.0) + Float64(Float64(2.0 * Float64(C * F)) / B_m))) ^ 0.5) / Float64(0.0 - B_m)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (B_m <= 1.28e-55) tmp = sqrt((-16.0 * (C * (F * (A * C))))) / (4.0 * (A * C)); else tmp = ((B_m * ((F * -2.0) + ((2.0 * (C * F)) / B_m))) ^ 0.5) / (0.0 - B_m); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 1.28e-55], N[(N[Sqrt[N[(-16.0 * N[(C * N[(F * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(B$95$m * N[(N[(F * -2.0), $MachinePrecision] + N[(N[(2.0 * N[(C * F), $MachinePrecision]), $MachinePrecision] / B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 1.28 \cdot 10^{-55}:\\
\;\;\;\;\frac{\sqrt{-16 \cdot \left(C \cdot \left(F \cdot \left(A \cdot C\right)\right)\right)}}{4 \cdot \left(A \cdot C\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(B\_m \cdot \left(F \cdot -2 + \frac{2 \cdot \left(C \cdot F\right)}{B\_m}\right)\right)}^{0.5}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 1.27999999999999994e-55Initial program 21.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified25.7%
Taylor expanded in B around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.8%
Simplified11.8%
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6417.8%
Applied egg-rr17.8%
Taylor expanded in A around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6417.8%
Simplified17.8%
if 1.27999999999999994e-55 < B Initial program 15.4%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6440.0%
Simplified40.0%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr40.1%
Taylor expanded in B around inf
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6439.6%
Simplified39.6%
Final simplification23.2%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= B_m 1.36e-55) (/ (sqrt (* -16.0 (* C (* F (* A C))))) (* 4.0 (* A C))) (/ (pow (* 2.0 (* B_m (- (/ (* C F) B_m) F))) 0.5) (- 0.0 B_m))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.36e-55) {
tmp = sqrt((-16.0 * (C * (F * (A * C))))) / (4.0 * (A * C));
} else {
tmp = pow((2.0 * (B_m * (((C * F) / B_m) - F))), 0.5) / (0.0 - B_m);
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (b_m <= 1.36d-55) then
tmp = sqrt(((-16.0d0) * (c * (f * (a * c))))) / (4.0d0 * (a * c))
else
tmp = ((2.0d0 * (b_m * (((c * f) / b_m) - f))) ** 0.5d0) / (0.0d0 - b_m)
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.36e-55) {
tmp = Math.sqrt((-16.0 * (C * (F * (A * C))))) / (4.0 * (A * C));
} else {
tmp = Math.pow((2.0 * (B_m * (((C * F) / B_m) - F))), 0.5) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 1.36e-55: tmp = math.sqrt((-16.0 * (C * (F * (A * C))))) / (4.0 * (A * C)) else: tmp = math.pow((2.0 * (B_m * (((C * F) / B_m) - F))), 0.5) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 1.36e-55) tmp = Float64(sqrt(Float64(-16.0 * Float64(C * Float64(F * Float64(A * C))))) / Float64(4.0 * Float64(A * C))); else tmp = Float64((Float64(2.0 * Float64(B_m * Float64(Float64(Float64(C * F) / B_m) - F))) ^ 0.5) / Float64(0.0 - B_m)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (B_m <= 1.36e-55) tmp = sqrt((-16.0 * (C * (F * (A * C))))) / (4.0 * (A * C)); else tmp = ((2.0 * (B_m * (((C * F) / B_m) - F))) ^ 0.5) / (0.0 - B_m); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 1.36e-55], N[(N[Sqrt[N[(-16.0 * N[(C * N[(F * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(2.0 * N[(B$95$m * N[(N[(N[(C * F), $MachinePrecision] / B$95$m), $MachinePrecision] - F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 1.36 \cdot 10^{-55}:\\
\;\;\;\;\frac{\sqrt{-16 \cdot \left(C \cdot \left(F \cdot \left(A \cdot C\right)\right)\right)}}{4 \cdot \left(A \cdot C\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(2 \cdot \left(B\_m \cdot \left(\frac{C \cdot F}{B\_m} - F\right)\right)\right)}^{0.5}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 1.35999999999999993e-55Initial program 21.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified25.7%
Taylor expanded in B around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.8%
Simplified11.8%
*-commutativeN/A
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6417.8%
Applied egg-rr17.8%
Taylor expanded in A around inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6417.8%
Simplified17.8%
if 1.35999999999999993e-55 < B Initial program 15.4%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6440.0%
Simplified40.0%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr40.1%
Taylor expanded in B around inf
*-lowering-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6439.6%
Simplified39.6%
Final simplification23.2%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= C 1.8e+94) (/ (pow (* 2.0 (* B_m (- (/ (* C F) B_m) F))) 0.5) (- 0.0 B_m)) (/ (sqrt (* (* 2.0 F) (/ (* (* B_m B_m) -0.5) C))) (- 0.0 B_m))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= 1.8e+94) {
tmp = pow((2.0 * (B_m * (((C * F) / B_m) - F))), 0.5) / (0.0 - B_m);
} else {
tmp = sqrt(((2.0 * F) * (((B_m * B_m) * -0.5) / C))) / (0.0 - B_m);
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (c <= 1.8d+94) then
tmp = ((2.0d0 * (b_m * (((c * f) / b_m) - f))) ** 0.5d0) / (0.0d0 - b_m)
else
tmp = sqrt(((2.0d0 * f) * (((b_m * b_m) * (-0.5d0)) / c))) / (0.0d0 - b_m)
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= 1.8e+94) {
tmp = Math.pow((2.0 * (B_m * (((C * F) / B_m) - F))), 0.5) / (0.0 - B_m);
} else {
tmp = Math.sqrt(((2.0 * F) * (((B_m * B_m) * -0.5) / C))) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if C <= 1.8e+94: tmp = math.pow((2.0 * (B_m * (((C * F) / B_m) - F))), 0.5) / (0.0 - B_m) else: tmp = math.sqrt(((2.0 * F) * (((B_m * B_m) * -0.5) / C))) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (C <= 1.8e+94) tmp = Float64((Float64(2.0 * Float64(B_m * Float64(Float64(Float64(C * F) / B_m) - F))) ^ 0.5) / Float64(0.0 - B_m)); else tmp = Float64(sqrt(Float64(Float64(2.0 * F) * Float64(Float64(Float64(B_m * B_m) * -0.5) / C))) / Float64(0.0 - B_m)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (C <= 1.8e+94) tmp = ((2.0 * (B_m * (((C * F) / B_m) - F))) ^ 0.5) / (0.0 - B_m); else tmp = sqrt(((2.0 * F) * (((B_m * B_m) * -0.5) / C))) / (0.0 - B_m); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[C, 1.8e+94], N[(N[Power[N[(2.0 * N[(B$95$m * N[(N[(N[(C * F), $MachinePrecision] / B$95$m), $MachinePrecision] - F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(N[(2.0 * F), $MachinePrecision] * N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] * -0.5), $MachinePrecision] / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;C \leq 1.8 \cdot 10^{+94}:\\
\;\;\;\;\frac{{\left(2 \cdot \left(B\_m \cdot \left(\frac{C \cdot F}{B\_m} - F\right)\right)\right)}^{0.5}}{0 - B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{\left(2 \cdot F\right) \cdot \frac{\left(B\_m \cdot B\_m\right) \cdot -0.5}{C}}}{0 - B\_m}\\
\end{array}
\end{array}
if C < 1.79999999999999996e94Initial program 23.4%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6413.6%
Simplified13.6%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr13.7%
Taylor expanded in B around inf
*-lowering-*.f64N/A
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f6413.3%
Simplified13.3%
if 1.79999999999999996e94 < C Initial program 1.1%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f646.4%
Simplified6.4%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr6.4%
/-lowering-/.f64N/A
unpow1/2N/A
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f646.4%
Applied egg-rr6.4%
Taylor expanded in C around inf
associate-*r/N/A
metadata-evalN/A
distribute-lft-neg-inN/A
/-lowering-/.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6417.2%
Simplified17.2%
Final simplification13.9%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= C 1.35e+93) (/ (sqrt (* (* 2.0 F) (- C B_m))) (- 0.0 B_m)) (/ (sqrt (* (* 2.0 F) (/ (* (* B_m B_m) -0.5) C))) (- 0.0 B_m))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= 1.35e+93) {
tmp = sqrt(((2.0 * F) * (C - B_m))) / (0.0 - B_m);
} else {
tmp = sqrt(((2.0 * F) * (((B_m * B_m) * -0.5) / C))) / (0.0 - B_m);
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (c <= 1.35d+93) then
tmp = sqrt(((2.0d0 * f) * (c - b_m))) / (0.0d0 - b_m)
else
tmp = sqrt(((2.0d0 * f) * (((b_m * b_m) * (-0.5d0)) / c))) / (0.0d0 - b_m)
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= 1.35e+93) {
tmp = Math.sqrt(((2.0 * F) * (C - B_m))) / (0.0 - B_m);
} else {
tmp = Math.sqrt(((2.0 * F) * (((B_m * B_m) * -0.5) / C))) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if C <= 1.35e+93: tmp = math.sqrt(((2.0 * F) * (C - B_m))) / (0.0 - B_m) else: tmp = math.sqrt(((2.0 * F) * (((B_m * B_m) * -0.5) / C))) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (C <= 1.35e+93) tmp = Float64(sqrt(Float64(Float64(2.0 * F) * Float64(C - B_m))) / Float64(0.0 - B_m)); else tmp = Float64(sqrt(Float64(Float64(2.0 * F) * Float64(Float64(Float64(B_m * B_m) * -0.5) / C))) / Float64(0.0 - B_m)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (C <= 1.35e+93) tmp = sqrt(((2.0 * F) * (C - B_m))) / (0.0 - B_m); else tmp = sqrt(((2.0 * F) * (((B_m * B_m) * -0.5) / C))) / (0.0 - B_m); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[C, 1.35e+93], N[(N[Sqrt[N[(N[(2.0 * F), $MachinePrecision] * N[(C - B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(N[(2.0 * F), $MachinePrecision] * N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] * -0.5), $MachinePrecision] / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;C \leq 1.35 \cdot 10^{+93}:\\
\;\;\;\;\frac{\sqrt{\left(2 \cdot F\right) \cdot \left(C - B\_m\right)}}{0 - B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{\left(2 \cdot F\right) \cdot \frac{\left(B\_m \cdot B\_m\right) \cdot -0.5}{C}}}{0 - B\_m}\\
\end{array}
\end{array}
if C < 1.35e93Initial program 23.4%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6413.6%
Simplified13.6%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr13.7%
/-lowering-/.f64N/A
unpow1/2N/A
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f6413.7%
Applied egg-rr13.7%
Taylor expanded in C around 0
--lowering--.f6413.0%
Simplified13.0%
if 1.35e93 < C Initial program 1.1%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f646.4%
Simplified6.4%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr6.4%
/-lowering-/.f64N/A
unpow1/2N/A
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f646.4%
Applied egg-rr6.4%
Taylor expanded in C around inf
associate-*r/N/A
metadata-evalN/A
distribute-lft-neg-inN/A
/-lowering-/.f64N/A
distribute-lft-neg-inN/A
metadata-evalN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6417.2%
Simplified17.2%
Final simplification13.7%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= C 7.2e+90) (/ (sqrt (* (* 2.0 F) (- C B_m))) (- 0.0 B_m)) (/ (sqrt (* 2.0 (* F (/ (* B_m (* B_m -0.5)) C)))) (- 0.0 B_m))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= 7.2e+90) {
tmp = sqrt(((2.0 * F) * (C - B_m))) / (0.0 - B_m);
} else {
tmp = sqrt((2.0 * (F * ((B_m * (B_m * -0.5)) / C)))) / (0.0 - B_m);
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (c <= 7.2d+90) then
tmp = sqrt(((2.0d0 * f) * (c - b_m))) / (0.0d0 - b_m)
else
tmp = sqrt((2.0d0 * (f * ((b_m * (b_m * (-0.5d0))) / c)))) / (0.0d0 - b_m)
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= 7.2e+90) {
tmp = Math.sqrt(((2.0 * F) * (C - B_m))) / (0.0 - B_m);
} else {
tmp = Math.sqrt((2.0 * (F * ((B_m * (B_m * -0.5)) / C)))) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if C <= 7.2e+90: tmp = math.sqrt(((2.0 * F) * (C - B_m))) / (0.0 - B_m) else: tmp = math.sqrt((2.0 * (F * ((B_m * (B_m * -0.5)) / C)))) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (C <= 7.2e+90) tmp = Float64(sqrt(Float64(Float64(2.0 * F) * Float64(C - B_m))) / Float64(0.0 - B_m)); else tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(Float64(B_m * Float64(B_m * -0.5)) / C)))) / Float64(0.0 - B_m)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (C <= 7.2e+90) tmp = sqrt(((2.0 * F) * (C - B_m))) / (0.0 - B_m); else tmp = sqrt((2.0 * (F * ((B_m * (B_m * -0.5)) / C)))) / (0.0 - B_m); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[C, 7.2e+90], N[(N[Sqrt[N[(N[(2.0 * F), $MachinePrecision] * N[(C - B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(2.0 * N[(F * N[(N[(B$95$m * N[(B$95$m * -0.5), $MachinePrecision]), $MachinePrecision] / C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;C \leq 7.2 \cdot 10^{+90}:\\
\;\;\;\;\frac{\sqrt{\left(2 \cdot F\right) \cdot \left(C - B\_m\right)}}{0 - B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot \frac{B\_m \cdot \left(B\_m \cdot -0.5\right)}{C}\right)}}{0 - B\_m}\\
\end{array}
\end{array}
if C < 7.2e90Initial program 23.4%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6413.6%
Simplified13.6%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr13.7%
/-lowering-/.f64N/A
unpow1/2N/A
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f6413.7%
Applied egg-rr13.7%
Taylor expanded in C around 0
--lowering--.f6413.0%
Simplified13.0%
if 7.2e90 < C Initial program 1.1%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f646.4%
Simplified6.4%
Taylor expanded in C around inf
associate-*r/N/A
metadata-evalN/A
/-lowering-/.f64N/A
metadata-evalN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6417.1%
Simplified17.1%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
sqrt-unprodN/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6417.2%
Applied egg-rr17.2%
Final simplification13.7%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= C 5.3e+91) (/ (sqrt (* (* 2.0 F) (- C B_m))) (- 0.0 B_m)) (/ (sqrt (- 0.0 (/ (* F (* B_m B_m)) C))) (- 0.0 B_m))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= 5.3e+91) {
tmp = sqrt(((2.0 * F) * (C - B_m))) / (0.0 - B_m);
} else {
tmp = sqrt((0.0 - ((F * (B_m * B_m)) / C))) / (0.0 - B_m);
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (c <= 5.3d+91) then
tmp = sqrt(((2.0d0 * f) * (c - b_m))) / (0.0d0 - b_m)
else
tmp = sqrt((0.0d0 - ((f * (b_m * b_m)) / c))) / (0.0d0 - b_m)
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= 5.3e+91) {
tmp = Math.sqrt(((2.0 * F) * (C - B_m))) / (0.0 - B_m);
} else {
tmp = Math.sqrt((0.0 - ((F * (B_m * B_m)) / C))) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if C <= 5.3e+91: tmp = math.sqrt(((2.0 * F) * (C - B_m))) / (0.0 - B_m) else: tmp = math.sqrt((0.0 - ((F * (B_m * B_m)) / C))) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (C <= 5.3e+91) tmp = Float64(sqrt(Float64(Float64(2.0 * F) * Float64(C - B_m))) / Float64(0.0 - B_m)); else tmp = Float64(sqrt(Float64(0.0 - Float64(Float64(F * Float64(B_m * B_m)) / C))) / Float64(0.0 - B_m)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (C <= 5.3e+91) tmp = sqrt(((2.0 * F) * (C - B_m))) / (0.0 - B_m); else tmp = sqrt((0.0 - ((F * (B_m * B_m)) / C))) / (0.0 - B_m); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[C, 5.3e+91], N[(N[Sqrt[N[(N[(2.0 * F), $MachinePrecision] * N[(C - B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(0.0 - N[(N[(F * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] / C), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;C \leq 5.3 \cdot 10^{+91}:\\
\;\;\;\;\frac{\sqrt{\left(2 \cdot F\right) \cdot \left(C - B\_m\right)}}{0 - B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{0 - \frac{F \cdot \left(B\_m \cdot B\_m\right)}{C}}}{0 - B\_m}\\
\end{array}
\end{array}
if C < 5.29999999999999997e91Initial program 23.4%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6413.6%
Simplified13.6%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr13.7%
/-lowering-/.f64N/A
unpow1/2N/A
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f6413.7%
Applied egg-rr13.7%
Taylor expanded in C around 0
--lowering--.f6413.0%
Simplified13.0%
if 5.29999999999999997e91 < C Initial program 1.1%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f646.4%
Simplified6.4%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr6.4%
/-lowering-/.f64N/A
unpow1/2N/A
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f646.4%
Applied egg-rr6.4%
Taylor expanded in C around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6417.2%
Simplified17.2%
Final simplification13.7%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= C -3.9e-98) (/ (sqrt (* 4.0 (* C F))) (- 0.0 B_m)) (* (sqrt (* A F)) (/ -2.0 B_m))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= -3.9e-98) {
tmp = sqrt((4.0 * (C * F))) / (0.0 - B_m);
} else {
tmp = sqrt((A * F)) * (-2.0 / B_m);
}
return tmp;
}
B_m = abs(b)
real(8) function code(a, b_m, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b_m
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: tmp
if (c <= (-3.9d-98)) then
tmp = sqrt((4.0d0 * (c * f))) / (0.0d0 - b_m)
else
tmp = sqrt((a * f)) * ((-2.0d0) / b_m)
end if
code = tmp
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= -3.9e-98) {
tmp = Math.sqrt((4.0 * (C * F))) / (0.0 - B_m);
} else {
tmp = Math.sqrt((A * F)) * (-2.0 / B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if C <= -3.9e-98: tmp = math.sqrt((4.0 * (C * F))) / (0.0 - B_m) else: tmp = math.sqrt((A * F)) * (-2.0 / B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (C <= -3.9e-98) tmp = Float64(sqrt(Float64(4.0 * Float64(C * F))) / Float64(0.0 - B_m)); else tmp = Float64(sqrt(Float64(A * F)) * Float64(-2.0 / B_m)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (C <= -3.9e-98) tmp = sqrt((4.0 * (C * F))) / (0.0 - B_m); else tmp = sqrt((A * F)) * (-2.0 / B_m); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[C, -3.9e-98], N[(N[Sqrt[N[(4.0 * N[(C * F), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(A * F), $MachinePrecision]], $MachinePrecision] * N[(-2.0 / B$95$m), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;C \leq -3.9 \cdot 10^{-98}:\\
\;\;\;\;\frac{\sqrt{4 \cdot \left(C \cdot F\right)}}{0 - B\_m}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{A \cdot F} \cdot \frac{-2}{B\_m}\\
\end{array}
\end{array}
if C < -3.89999999999999971e-98Initial program 27.3%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f649.6%
Simplified9.6%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr9.9%
/-lowering-/.f64N/A
unpow1/2N/A
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
*-lowering-*.f649.7%
Applied egg-rr9.7%
Taylor expanded in C around -inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f642.4%
Simplified2.4%
if -3.89999999999999971e-98 < C Initial program 16.7%
Taylor expanded in C around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6414.4%
Simplified14.4%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
rem-square-sqrtN/A
unpow2N/A
rem-square-sqrtN/A
metadata-evalN/A
/-lowering-/.f643.0%
Simplified3.0%
Final simplification2.8%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (/ (sqrt (* F (* B_m -2.0))) (- 0.0 B_m)))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
return sqrt((F * (B_m * -2.0))) / (0.0 - B_m);
}
B_m = abs(b)
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 * (-2.0d0)))) / (0.0d0 - b_m)
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
return Math.sqrt((F * (B_m * -2.0))) / (0.0 - B_m);
}
B_m = math.fabs(B) def code(A, B_m, C, F): return math.sqrt((F * (B_m * -2.0))) / (0.0 - B_m)
B_m = abs(B) function code(A, B_m, C, F) return Float64(sqrt(Float64(F * Float64(B_m * -2.0))) / Float64(0.0 - B_m)) end
B_m = abs(B); function tmp = code(A, B_m, C, F) tmp = sqrt((F * (B_m * -2.0))) / (0.0 - B_m); end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := N[(N[Sqrt[N[(F * N[(B$95$m * -2.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
B_m = \left|B\right|
\\
\frac{\sqrt{F \cdot \left(B\_m \cdot -2\right)}}{0 - B\_m}
\end{array}
Initial program 19.8%
Taylor expanded in A around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6412.4%
Simplified12.4%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr12.6%
Taylor expanded in C around 0
*-lowering-*.f64N/A
*-lowering-*.f6412.5%
Simplified12.5%
/-lowering-/.f64N/A
unpow1/2N/A
sqrt-lowering-sqrt.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6412.5%
Applied egg-rr12.5%
Final simplification12.5%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (* (sqrt (* A F)) (/ -2.0 B_m)))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
return sqrt((A * F)) * (-2.0 / B_m);
}
B_m = abs(b)
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((a * f)) * ((-2.0d0) / b_m)
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
return Math.sqrt((A * F)) * (-2.0 / B_m);
}
B_m = math.fabs(B) def code(A, B_m, C, F): return math.sqrt((A * F)) * (-2.0 / B_m)
B_m = abs(B) function code(A, B_m, C, F) return Float64(sqrt(Float64(A * F)) * Float64(-2.0 / B_m)) end
B_m = abs(B); function tmp = code(A, B_m, C, F) tmp = sqrt((A * F)) * (-2.0 / B_m); end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := N[(N[Sqrt[N[(A * F), $MachinePrecision]], $MachinePrecision] * N[(-2.0 / B$95$m), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
B_m = \left|B\right|
\\
\sqrt{A \cdot F} \cdot \frac{-2}{B\_m}
\end{array}
Initial program 19.8%
Taylor expanded in C around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6413.1%
Simplified13.1%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
rem-square-sqrtN/A
unpow2N/A
rem-square-sqrtN/A
metadata-evalN/A
/-lowering-/.f642.4%
Simplified2.4%
Final simplification2.4%
herbie shell --seed 2024140
(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))))