
(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 21 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 (- A (hypot A B_m)))
(t_1 (hypot B_m (- A 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)))
(t_5 (* C (* A -4.0)))
(t_6 (+ (* B_m B_m) t_5))
(t_7 (+ (* B_m B_m) (* A A)))
(t_8 (sqrt (/ 1.0 t_7)))
(t_9 (+ (* A t_8) 1.0)))
(if (<= t_3 -2e-79)
(/ (* (sqrt (* 2.0 t_6)) (sqrt (* F (+ A (- C t_1))))) t_4)
(if (<= t_3 0.0)
(/
(sqrt
(+
(* 2.0 (* (* F (* B_m B_m)) t_0))
(*
C
(*
2.0
(+
(*
(* C F)
(+
(* (* A -4.0) t_9)
(* -0.5 (* (* B_m B_m) (* t_8 (- 1.0 (/ (* A A) t_7)))))))
(* F (+ (* t_0 (* A -4.0)) (* (* B_m B_m) t_9))))))))
t_4)
(if (<= t_3 INFINITY)
(/
(sqrt
(fma
(+ A C)
(* t_6 (* 2.0 F))
(* t_1 (* (* 2.0 F) (- (- 0.0 (* B_m B_m)) t_5)))))
t_4)
(/ (pow (* 2.0 (* F (- C (hypot B_m C)))) 0.5) (- 0.0 B_m)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = A - hypot(A, B_m);
double t_1 = hypot(B_m, (A - 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 t_5 = C * (A * -4.0);
double t_6 = (B_m * B_m) + t_5;
double t_7 = (B_m * B_m) + (A * A);
double t_8 = sqrt((1.0 / t_7));
double t_9 = (A * t_8) + 1.0;
double tmp;
if (t_3 <= -2e-79) {
tmp = (sqrt((2.0 * t_6)) * sqrt((F * (A + (C - t_1))))) / t_4;
} else if (t_3 <= 0.0) {
tmp = sqrt(((2.0 * ((F * (B_m * B_m)) * t_0)) + (C * (2.0 * (((C * F) * (((A * -4.0) * t_9) + (-0.5 * ((B_m * B_m) * (t_8 * (1.0 - ((A * A) / t_7))))))) + (F * ((t_0 * (A * -4.0)) + ((B_m * B_m) * t_9)))))))) / t_4;
} else if (t_3 <= ((double) INFINITY)) {
tmp = sqrt(fma((A + C), (t_6 * (2.0 * F)), (t_1 * ((2.0 * F) * ((0.0 - (B_m * B_m)) - t_5))))) / t_4;
} else {
tmp = pow((2.0 * (F * (C - hypot(B_m, C)))), 0.5) / (0.0 - B_m);
}
return tmp;
}
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(A - hypot(A, B_m)) t_1 = hypot(B_m, Float64(A - 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)) t_5 = Float64(C * Float64(A * -4.0)) t_6 = Float64(Float64(B_m * B_m) + t_5) t_7 = Float64(Float64(B_m * B_m) + Float64(A * A)) t_8 = sqrt(Float64(1.0 / t_7)) t_9 = Float64(Float64(A * t_8) + 1.0) tmp = 0.0 if (t_3 <= -2e-79) tmp = Float64(Float64(sqrt(Float64(2.0 * t_6)) * sqrt(Float64(F * Float64(A + Float64(C - t_1))))) / t_4); elseif (t_3 <= 0.0) tmp = Float64(sqrt(Float64(Float64(2.0 * Float64(Float64(F * Float64(B_m * B_m)) * t_0)) + Float64(C * Float64(2.0 * Float64(Float64(Float64(C * F) * Float64(Float64(Float64(A * -4.0) * t_9) + Float64(-0.5 * Float64(Float64(B_m * B_m) * Float64(t_8 * Float64(1.0 - Float64(Float64(A * A) / t_7))))))) + Float64(F * Float64(Float64(t_0 * Float64(A * -4.0)) + Float64(Float64(B_m * B_m) * t_9)))))))) / t_4); elseif (t_3 <= Inf) tmp = Float64(sqrt(fma(Float64(A + C), Float64(t_6 * Float64(2.0 * F)), Float64(t_1 * Float64(Float64(2.0 * F) * Float64(Float64(0.0 - Float64(B_m * B_m)) - t_5))))) / t_4); else tmp = Float64((Float64(2.0 * Float64(F * Float64(C - hypot(B_m, C)))) ^ 0.5) / Float64(0.0 - B_m)); end return tmp end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(A - N[Sqrt[A ^ 2 + B$95$m ^ 2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $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]}, Block[{t$95$5 = N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$6 = N[(N[(B$95$m * B$95$m), $MachinePrecision] + t$95$5), $MachinePrecision]}, Block[{t$95$7 = N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(A * A), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$8 = N[Sqrt[N[(1.0 / t$95$7), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$9 = N[(N[(A * t$95$8), $MachinePrecision] + 1.0), $MachinePrecision]}, If[LessEqual[t$95$3, -2e-79], N[(N[(N[Sqrt[N[(2.0 * t$95$6), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(F * N[(A + N[(C - t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$4), $MachinePrecision], If[LessEqual[t$95$3, 0.0], N[(N[Sqrt[N[(N[(2.0 * N[(N[(F * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision]), $MachinePrecision] + N[(C * N[(2.0 * N[(N[(N[(C * F), $MachinePrecision] * N[(N[(N[(A * -4.0), $MachinePrecision] * t$95$9), $MachinePrecision] + N[(-0.5 * N[(N[(B$95$m * B$95$m), $MachinePrecision] * N[(t$95$8 * N[(1.0 - N[(N[(A * A), $MachinePrecision] / t$95$7), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(F * N[(N[(t$95$0 * N[(A * -4.0), $MachinePrecision]), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] * t$95$9), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$4), $MachinePrecision], If[LessEqual[t$95$3, Infinity], N[(N[Sqrt[N[(N[(A + C), $MachinePrecision] * N[(t$95$6 * N[(2.0 * F), $MachinePrecision]), $MachinePrecision] + N[(t$95$1 * N[(N[(2.0 * F), $MachinePrecision] * N[(N[(0.0 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] - t$95$5), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$4), $MachinePrecision], N[(N[Power[N[(2.0 * N[(F * N[(C - N[Sqrt[B$95$m ^ 2 + C ^ 2], $MachinePrecision]), $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}
t_0 := A - \mathsf{hypot}\left(A, B\_m\right)\\
t_1 := \mathsf{hypot}\left(B\_m, A - 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\\
t_5 := C \cdot \left(A \cdot -4\right)\\
t_6 := B\_m \cdot B\_m + t\_5\\
t_7 := B\_m \cdot B\_m + A \cdot A\\
t_8 := \sqrt{\frac{1}{t\_7}}\\
t_9 := A \cdot t\_8 + 1\\
\mathbf{if}\;t\_3 \leq -2 \cdot 10^{-79}:\\
\;\;\;\;\frac{\sqrt{2 \cdot t\_6} \cdot \sqrt{F \cdot \left(A + \left(C - t\_1\right)\right)}}{t\_4}\\
\mathbf{elif}\;t\_3 \leq 0:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(\left(F \cdot \left(B\_m \cdot B\_m\right)\right) \cdot t\_0\right) + C \cdot \left(2 \cdot \left(\left(C \cdot F\right) \cdot \left(\left(A \cdot -4\right) \cdot t\_9 + -0.5 \cdot \left(\left(B\_m \cdot B\_m\right) \cdot \left(t\_8 \cdot \left(1 - \frac{A \cdot A}{t\_7}\right)\right)\right)\right) + F \cdot \left(t\_0 \cdot \left(A \cdot -4\right) + \left(B\_m \cdot B\_m\right) \cdot t\_9\right)\right)\right)}}{t\_4}\\
\mathbf{elif}\;t\_3 \leq \infty:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(A + C, t\_6 \cdot \left(2 \cdot F\right), t\_1 \cdot \left(\left(2 \cdot F\right) \cdot \left(\left(0 - B\_m \cdot B\_m\right) - t\_5\right)\right)\right)}}{t\_4}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(2 \cdot \left(F \cdot \left(C - \mathsf{hypot}\left(B\_m, C\right)\right)\right)\right)}^{0.5}}{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))) < -2e-79Initial program 39.6%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified43.8%
Applied egg-rr68.1%
if -2e-79 < (/.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 22.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified22.9%
Taylor expanded in C around 0
Simplified45.7%
if 0.0 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (-.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < +inf.0Initial program 39.4%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified75.2%
sub-negN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
distribute-lft-neg-inN/A
distribute-rgt-neg-inN/A
*-commutativeN/A
sub-negN/A
pow2N/A
*-commutativeN/A
Applied egg-rr75.3%
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.f6423.4%
Simplified23.4%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr23.5%
Final simplification46.5%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (* C (* A -4.0)))
(t_1 (+ (* B_m B_m) t_0))
(t_2 (hypot B_m (- A C)))
(t_3 (* (* 4.0 A) C))
(t_4
(/
(sqrt
(*
(* 2.0 (* (- (pow B_m 2.0) t_3) F))
(- (+ A C) (sqrt (+ (pow B_m 2.0) (pow (- A C) 2.0))))))
(- t_3 (pow B_m 2.0))))
(t_5 (- t_3 (* B_m B_m))))
(if (<= t_4 -4e-214)
(/ (* (sqrt (* 2.0 t_1)) (sqrt (* F (+ A (- C t_2))))) t_5)
(if (<= t_4 0.0)
(/ (sqrt (* t_1 (+ (/ (* F (* B_m B_m)) (- C A)) (* 4.0 (* C F))))) t_5)
(if (<= t_4 INFINITY)
(/
(sqrt
(fma
(+ A C)
(* t_1 (* 2.0 F))
(* t_2 (* (* 2.0 F) (- (- 0.0 (* B_m B_m)) t_0)))))
t_5)
(/ (pow (* 2.0 (* F (- C (hypot B_m C)))) 0.5) (- 0.0 B_m)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = C * (A * -4.0);
double t_1 = (B_m * B_m) + t_0;
double t_2 = hypot(B_m, (A - C));
double t_3 = (4.0 * A) * C;
double t_4 = sqrt(((2.0 * ((pow(B_m, 2.0) - t_3) * F)) * ((A + C) - sqrt((pow(B_m, 2.0) + pow((A - C), 2.0)))))) / (t_3 - pow(B_m, 2.0));
double t_5 = t_3 - (B_m * B_m);
double tmp;
if (t_4 <= -4e-214) {
tmp = (sqrt((2.0 * t_1)) * sqrt((F * (A + (C - t_2))))) / t_5;
} else if (t_4 <= 0.0) {
tmp = sqrt((t_1 * (((F * (B_m * B_m)) / (C - A)) + (4.0 * (C * F))))) / t_5;
} else if (t_4 <= ((double) INFINITY)) {
tmp = sqrt(fma((A + C), (t_1 * (2.0 * F)), (t_2 * ((2.0 * F) * ((0.0 - (B_m * B_m)) - t_0))))) / t_5;
} else {
tmp = pow((2.0 * (F * (C - hypot(B_m, C)))), 0.5) / (0.0 - B_m);
}
return tmp;
}
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(C * Float64(A * -4.0)) t_1 = Float64(Float64(B_m * B_m) + t_0) t_2 = hypot(B_m, Float64(A - C)) t_3 = Float64(Float64(4.0 * A) * C) t_4 = Float64(sqrt(Float64(Float64(2.0 * Float64(Float64((B_m ^ 2.0) - t_3) * F)) * Float64(Float64(A + C) - sqrt(Float64((B_m ^ 2.0) + (Float64(A - C) ^ 2.0)))))) / Float64(t_3 - (B_m ^ 2.0))) t_5 = Float64(t_3 - Float64(B_m * B_m)) tmp = 0.0 if (t_4 <= -4e-214) tmp = Float64(Float64(sqrt(Float64(2.0 * t_1)) * sqrt(Float64(F * Float64(A + Float64(C - t_2))))) / t_5); elseif (t_4 <= 0.0) tmp = Float64(sqrt(Float64(t_1 * Float64(Float64(Float64(F * Float64(B_m * B_m)) / Float64(C - A)) + Float64(4.0 * Float64(C * F))))) / t_5); elseif (t_4 <= Inf) tmp = Float64(sqrt(fma(Float64(A + C), Float64(t_1 * Float64(2.0 * F)), Float64(t_2 * Float64(Float64(2.0 * F) * Float64(Float64(0.0 - Float64(B_m * B_m)) - t_0))))) / t_5); else tmp = Float64((Float64(2.0 * Float64(F * Float64(C - hypot(B_m, C)))) ^ 0.5) / Float64(0.0 - B_m)); end return tmp end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(B$95$m * B$95$m), $MachinePrecision] + t$95$0), $MachinePrecision]}, Block[{t$95$2 = N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, Block[{t$95$3 = N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]}, Block[{t$95$4 = N[(N[Sqrt[N[(N[(2.0 * N[(N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$3), $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$3 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(t$95$3 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$4, -4e-214], N[(N[(N[Sqrt[N[(2.0 * t$95$1), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(F * N[(A + N[(C - t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / t$95$5), $MachinePrecision], If[LessEqual[t$95$4, 0.0], N[(N[Sqrt[N[(t$95$1 * N[(N[(N[(F * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] / N[(C - A), $MachinePrecision]), $MachinePrecision] + N[(4.0 * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$5), $MachinePrecision], If[LessEqual[t$95$4, Infinity], N[(N[Sqrt[N[(N[(A + C), $MachinePrecision] * N[(t$95$1 * N[(2.0 * F), $MachinePrecision]), $MachinePrecision] + N[(t$95$2 * N[(N[(2.0 * F), $MachinePrecision] * N[(N[(0.0 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$5), $MachinePrecision], N[(N[Power[N[(2.0 * N[(F * N[(C - N[Sqrt[B$95$m ^ 2 + C ^ 2], $MachinePrecision]), $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}
t_0 := C \cdot \left(A \cdot -4\right)\\
t_1 := B\_m \cdot B\_m + t\_0\\
t_2 := \mathsf{hypot}\left(B\_m, A - C\right)\\
t_3 := \left(4 \cdot A\right) \cdot C\\
t_4 := \frac{\sqrt{\left(2 \cdot \left(\left({B\_m}^{2} - t\_3\right) \cdot F\right)\right) \cdot \left(\left(A + C\right) - \sqrt{{B\_m}^{2} + {\left(A - C\right)}^{2}}\right)}}{t\_3 - {B\_m}^{2}}\\
t_5 := t\_3 - B\_m \cdot B\_m\\
\mathbf{if}\;t\_4 \leq -4 \cdot 10^{-214}:\\
\;\;\;\;\frac{\sqrt{2 \cdot t\_1} \cdot \sqrt{F \cdot \left(A + \left(C - t\_2\right)\right)}}{t\_5}\\
\mathbf{elif}\;t\_4 \leq 0:\\
\;\;\;\;\frac{\sqrt{t\_1 \cdot \left(\frac{F \cdot \left(B\_m \cdot B\_m\right)}{C - A} + 4 \cdot \left(C \cdot F\right)\right)}}{t\_5}\\
\mathbf{elif}\;t\_4 \leq \infty:\\
\;\;\;\;\frac{\sqrt{\mathsf{fma}\left(A + C, t\_1 \cdot \left(2 \cdot F\right), t\_2 \cdot \left(\left(2 \cdot F\right) \cdot \left(\left(0 - B\_m \cdot B\_m\right) - t\_0\right)\right)\right)}}{t\_5}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(2 \cdot \left(F \cdot \left(C - \mathsf{hypot}\left(B\_m, C\right)\right)\right)\right)}^{0.5}}{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))) < -3.99999999999999965e-214Initial program 45.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified49.6%
Applied egg-rr71.1%
if -3.99999999999999965e-214 < (/.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.4%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified3.4%
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-rr12.3%
Taylor expanded in B around 0
+-lowering-+.f64N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6431.5%
Simplified31.5%
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 39.4%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified75.2%
sub-negN/A
*-commutativeN/A
associate-*r*N/A
*-commutativeN/A
metadata-evalN/A
distribute-lft-neg-inN/A
distribute-rgt-neg-inN/A
*-commutativeN/A
sub-negN/A
pow2N/A
*-commutativeN/A
Applied egg-rr75.3%
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.f6423.4%
Simplified23.4%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr23.5%
Final simplification46.3%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= (pow B_m 2.0) 1e+118)
(/
(sqrt
(*
(+ (* B_m B_m) (* C (* A -4.0)))
(* 2.0 (* F (+ A (- C (hypot B_m (- A C))))))))
(- (* (* 4.0 A) C) (* B_m B_m)))
(/ (pow (* 2.0 (* F (- C (hypot B_m C)))) 0.5) (- 0.0 B_m))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (pow(B_m, 2.0) <= 1e+118) {
tmp = sqrt((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * (F * (A + (C - hypot(B_m, (A - C)))))))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = pow((2.0 * (F * (C - hypot(B_m, C)))), 0.5) / (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 (Math.pow(B_m, 2.0) <= 1e+118) {
tmp = Math.sqrt((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * (F * (A + (C - Math.hypot(B_m, (A - C)))))))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = Math.pow((2.0 * (F * (C - Math.hypot(B_m, C)))), 0.5) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if math.pow(B_m, 2.0) <= 1e+118: tmp = math.sqrt((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * (F * (A + (C - math.hypot(B_m, (A - C)))))))) / (((4.0 * A) * C) - (B_m * B_m)) else: tmp = math.pow((2.0 * (F * (C - math.hypot(B_m, C)))), 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 ^ 2.0) <= 1e+118) tmp = Float64(sqrt(Float64(Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0))) * Float64(2.0 * Float64(F * Float64(A + Float64(C - hypot(B_m, Float64(A - C)))))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); else tmp = Float64((Float64(2.0 * Float64(F * Float64(C - hypot(B_m, C)))) ^ 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 ^ 2.0) <= 1e+118) tmp = sqrt((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * (F * (A + (C - hypot(B_m, (A - C)))))))) / (((4.0 * A) * C) - (B_m * B_m)); else tmp = ((2.0 * (F * (C - hypot(B_m, C)))) ^ 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[N[Power[B$95$m, 2.0], $MachinePrecision], 1e+118], 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[(C - N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $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[Power[N[(2.0 * N[(F * N[(C - N[Sqrt[B$95$m ^ 2 + C ^ 2], $MachinePrecision]), $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}^{2} \leq 10^{+118}:\\
\;\;\;\;\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(C - \mathsf{hypot}\left(B\_m, A - C\right)\right)\right)\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(2 \cdot \left(F \cdot \left(C - \mathsf{hypot}\left(B\_m, C\right)\right)\right)\right)}^{0.5}}{0 - B\_m}\\
\end{array}
\end{array}
if (pow.f64 B #s(literal 2 binary64)) < 9.99999999999999967e117Initial program 26.7%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified34.9%
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-rr37.9%
if 9.99999999999999967e117 < (pow.f64 B #s(literal 2 binary64)) Initial program 9.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.f6432.7%
Simplified32.7%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr32.8%
Final simplification36.0%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 5.3e+59)
(/
(sqrt
(*
(* (+ (* B_m B_m) (* C (* A -4.0))) (* 2.0 F))
(- (+ A C) (hypot B_m (- A C)))))
(- (* (* 4.0 A) C) (* B_m B_m)))
(/ (pow (* 2.0 (* F (- C (hypot B_m C)))) 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 <= 5.3e+59) {
tmp = sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * F)) * ((A + C) - hypot(B_m, (A - C))))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = pow((2.0 * (F * (C - hypot(B_m, C)))), 0.5) / (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 <= 5.3e+59) {
tmp = Math.sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * F)) * ((A + C) - Math.hypot(B_m, (A - C))))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = Math.pow((2.0 * (F * (C - Math.hypot(B_m, C)))), 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 <= 5.3e+59: tmp = math.sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * F)) * ((A + C) - math.hypot(B_m, (A - C))))) / (((4.0 * A) * C) - (B_m * B_m)) else: tmp = math.pow((2.0 * (F * (C - math.hypot(B_m, C)))), 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 <= 5.3e+59) 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))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); else tmp = Float64((Float64(2.0 * Float64(F * Float64(C - hypot(B_m, C)))) ^ 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 <= 5.3e+59) tmp = sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (2.0 * F)) * ((A + C) - hypot(B_m, (A - C))))) / (((4.0 * A) * C) - (B_m * B_m)); else tmp = ((2.0 * (F * (C - hypot(B_m, C)))) ^ 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, 5.3e+59], 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] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[N[(2.0 * N[(F * N[(C - N[Sqrt[B$95$m ^ 2 + C ^ 2], $MachinePrecision]), $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 5.3 \cdot 10^{+59}:\\
\;\;\;\;\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)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(2 \cdot \left(F \cdot \left(C - \mathsf{hypot}\left(B\_m, C\right)\right)\right)\right)}^{0.5}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 5.2999999999999997e59Initial program 23.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified30.0%
if 5.2999999999999997e59 < B Initial program 6.6%
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.f6460.3%
Simplified60.3%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr60.7%
Final simplification35.9%
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 6.2e-117)
(/ (sqrt (* F (* (* 4.0 A) (+ (* B_m B_m) (* -4.0 (* A C)))))) t_0)
(if (<= B_m 7.5e-45)
(/ (sqrt (* (+ (* B_m B_m) (* C (* A -4.0))) (* 4.0 (* C F)))) t_0)
(/ (sqrt (* 2.0 (* F (- A (hypot B_m A))))) (- 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 <= 6.2e-117) {
tmp = sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / t_0;
} else if (B_m <= 7.5e-45) {
tmp = sqrt((((B_m * B_m) + (C * (A * -4.0))) * (4.0 * (C * F)))) / t_0;
} else {
tmp = sqrt((2.0 * (F * (A - hypot(B_m, A))))) / (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 <= 6.2e-117) {
tmp = Math.sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / t_0;
} else if (B_m <= 7.5e-45) {
tmp = Math.sqrt((((B_m * B_m) + (C * (A * -4.0))) * (4.0 * (C * F)))) / t_0;
} else {
tmp = Math.sqrt((2.0 * (F * (A - Math.hypot(B_m, A))))) / (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 <= 6.2e-117: tmp = math.sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / t_0 elif B_m <= 7.5e-45: tmp = math.sqrt((((B_m * B_m) + (C * (A * -4.0))) * (4.0 * (C * F)))) / t_0 else: tmp = math.sqrt((2.0 * (F * (A - math.hypot(B_m, A))))) / (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 <= 6.2e-117) tmp = Float64(sqrt(Float64(F * Float64(Float64(4.0 * A) * Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C)))))) / t_0); elseif (B_m <= 7.5e-45) tmp = Float64(sqrt(Float64(Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0))) * Float64(4.0 * Float64(C * F)))) / t_0); else tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(A - hypot(B_m, A))))) / 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 <= 6.2e-117) tmp = sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / t_0; elseif (B_m <= 7.5e-45) tmp = sqrt((((B_m * B_m) + (C * (A * -4.0))) * (4.0 * (C * F)))) / t_0; else tmp = sqrt((2.0 * (F * (A - hypot(B_m, A))))) / (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, 6.2e-117], N[(N[Sqrt[N[(F * N[(N[(4.0 * A), $MachinePrecision] * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[B$95$m, 7.5e-45], N[(N[Sqrt[N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(4.0 * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[Sqrt[N[(2.0 * N[(F * N[(A - N[Sqrt[B$95$m ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $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 6.2 \cdot 10^{-117}:\\
\;\;\;\;\frac{\sqrt{F \cdot \left(\left(4 \cdot A\right) \cdot \left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right)\right)}}{t\_0}\\
\mathbf{elif}\;B\_m \leq 7.5 \cdot 10^{-45}:\\
\;\;\;\;\frac{\sqrt{\left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right) \cdot \left(4 \cdot \left(C \cdot F\right)\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot \left(A - \mathsf{hypot}\left(B\_m, A\right)\right)\right)}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 6.20000000000000022e-117Initial program 21.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified27.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-rr29.6%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f6420.7%
Simplified20.7%
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6420.8%
Applied egg-rr20.8%
if 6.20000000000000022e-117 < B < 7.5000000000000006e-45Initial program 38.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified38.3%
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-rr46.9%
Taylor expanded in C around -inf
*-lowering-*.f64N/A
*-lowering-*.f6420.5%
Simplified20.5%
if 7.5000000000000006e-45 < B Initial program 14.3%
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.f6448.6%
Simplified48.6%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr48.8%
Final simplification28.4%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 9.2e-117)
(/
(sqrt (* F (* (* 4.0 A) (+ (* B_m B_m) (* -4.0 (* A C))))))
(- (* (* 4.0 A) C) (* B_m B_m)))
(/ (pow (* 2.0 (* F (- C (hypot B_m C)))) 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 <= 9.2e-117) {
tmp = sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = pow((2.0 * (F * (C - hypot(B_m, C)))), 0.5) / (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 <= 9.2e-117) {
tmp = Math.sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = Math.pow((2.0 * (F * (C - Math.hypot(B_m, C)))), 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 <= 9.2e-117: tmp = math.sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / (((4.0 * A) * C) - (B_m * B_m)) else: tmp = math.pow((2.0 * (F * (C - math.hypot(B_m, C)))), 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 <= 9.2e-117) tmp = Float64(sqrt(Float64(F * Float64(Float64(4.0 * A) * Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C)))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); else tmp = Float64((Float64(2.0 * Float64(F * Float64(C - hypot(B_m, C)))) ^ 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 <= 9.2e-117) tmp = sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / (((4.0 * A) * C) - (B_m * B_m)); else tmp = ((2.0 * (F * (C - hypot(B_m, C)))) ^ 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, 9.2e-117], N[(N[Sqrt[N[(F * N[(N[(4.0 * A), $MachinePrecision] * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * 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[Power[N[(2.0 * N[(F * N[(C - N[Sqrt[B$95$m ^ 2 + C ^ 2], $MachinePrecision]), $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 9.2 \cdot 10^{-117}:\\
\;\;\;\;\frac{\sqrt{F \cdot \left(\left(4 \cdot A\right) \cdot \left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{{\left(2 \cdot \left(F \cdot \left(C - \mathsf{hypot}\left(B\_m, C\right)\right)\right)\right)}^{0.5}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 9.19999999999999978e-117Initial program 21.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified27.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-rr29.6%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f6420.7%
Simplified20.7%
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6420.8%
Applied egg-rr20.8%
if 9.19999999999999978e-117 < B Initial program 17.5%
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.f6446.3%
Simplified46.3%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr46.4%
Final simplification28.9%
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 6e-118)
(/ (sqrt (* F (* (* 4.0 A) (+ (* B_m B_m) (* -4.0 (* A C)))))) t_0)
(if (<= B_m 1.75e-44)
(/ (sqrt (* (+ (* B_m B_m) (* C (* A -4.0))) (* 4.0 (* C F)))) t_0)
(/ (sqrt (* -2.0 (* B_m F))) (- 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 <= 6e-118) {
tmp = sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / t_0;
} else if (B_m <= 1.75e-44) {
tmp = sqrt((((B_m * B_m) + (C * (A * -4.0))) * (4.0 * (C * F)))) / t_0;
} else {
tmp = sqrt((-2.0 * (B_m * F))) / (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) :: t_0
real(8) :: tmp
t_0 = ((4.0d0 * a) * c) - (b_m * b_m)
if (b_m <= 6d-118) then
tmp = sqrt((f * ((4.0d0 * a) * ((b_m * b_m) + ((-4.0d0) * (a * c)))))) / t_0
else if (b_m <= 1.75d-44) then
tmp = sqrt((((b_m * b_m) + (c * (a * (-4.0d0)))) * (4.0d0 * (c * f)))) / t_0
else
tmp = sqrt(((-2.0d0) * (b_m * f))) / (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 t_0 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 6e-118) {
tmp = Math.sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / t_0;
} else if (B_m <= 1.75e-44) {
tmp = Math.sqrt((((B_m * B_m) + (C * (A * -4.0))) * (4.0 * (C * F)))) / t_0;
} else {
tmp = Math.sqrt((-2.0 * (B_m * F))) / (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 <= 6e-118: tmp = math.sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / t_0 elif B_m <= 1.75e-44: tmp = math.sqrt((((B_m * B_m) + (C * (A * -4.0))) * (4.0 * (C * F)))) / t_0 else: tmp = math.sqrt((-2.0 * (B_m * F))) / (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 <= 6e-118) tmp = Float64(sqrt(Float64(F * Float64(Float64(4.0 * A) * Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C)))))) / t_0); elseif (B_m <= 1.75e-44) tmp = Float64(sqrt(Float64(Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0))) * Float64(4.0 * Float64(C * F)))) / t_0); else tmp = Float64(sqrt(Float64(-2.0 * Float64(B_m * F))) / 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 <= 6e-118) tmp = sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / t_0; elseif (B_m <= 1.75e-44) tmp = sqrt((((B_m * B_m) + (C * (A * -4.0))) * (4.0 * (C * F)))) / t_0; else tmp = sqrt((-2.0 * (B_m * F))) / (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, 6e-118], N[(N[Sqrt[N[(F * N[(N[(4.0 * A), $MachinePrecision] * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[B$95$m, 1.75e-44], N[(N[Sqrt[N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(4.0 * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[Sqrt[N[(-2.0 * N[(B$95$m * F), $MachinePrecision]), $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 6 \cdot 10^{-118}:\\
\;\;\;\;\frac{\sqrt{F \cdot \left(\left(4 \cdot A\right) \cdot \left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right)\right)}}{t\_0}\\
\mathbf{elif}\;B\_m \leq 1.75 \cdot 10^{-44}:\\
\;\;\;\;\frac{\sqrt{\left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right) \cdot \left(4 \cdot \left(C \cdot F\right)\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{-2 \cdot \left(B\_m \cdot F\right)}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 6.00000000000000035e-118Initial program 21.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified27.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-rr29.6%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f6420.7%
Simplified20.7%
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6420.8%
Applied egg-rr20.8%
if 6.00000000000000035e-118 < B < 1.7499999999999999e-44Initial program 38.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified38.3%
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-rr46.9%
Taylor expanded in C around -inf
*-lowering-*.f64N/A
*-lowering-*.f6420.5%
Simplified20.5%
if 1.7499999999999999e-44 < B Initial program 14.3%
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.f6448.6%
Simplified48.6%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr48.8%
Taylor expanded in A around 0
*-lowering-*.f64N/A
*-lowering-*.f6447.7%
Simplified47.7%
Final simplification28.1%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 5e-57)
(/
(sqrt (* (+ (* B_m B_m) (* C (* A -4.0))) (* 4.0 (* A F))))
(- (* (* 4.0 A) C) (* B_m B_m)))
(/ (sqrt (* -2.0 (* B_m F))) (- 0.0 B_m))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 5e-57) {
tmp = sqrt((((B_m * B_m) + (C * (A * -4.0))) * (4.0 * (A * F)))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = sqrt((-2.0 * (B_m * F))) / (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 <= 5d-57) then
tmp = sqrt((((b_m * b_m) + (c * (a * (-4.0d0)))) * (4.0d0 * (a * f)))) / (((4.0d0 * a) * c) - (b_m * b_m))
else
tmp = sqrt(((-2.0d0) * (b_m * f))) / (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 <= 5e-57) {
tmp = Math.sqrt((((B_m * B_m) + (C * (A * -4.0))) * (4.0 * (A * F)))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = Math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 5e-57: tmp = math.sqrt((((B_m * B_m) + (C * (A * -4.0))) * (4.0 * (A * F)))) / (((4.0 * A) * C) - (B_m * B_m)) else: tmp = math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 5e-57) tmp = Float64(sqrt(Float64(Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0))) * Float64(4.0 * Float64(A * F)))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); else tmp = Float64(sqrt(Float64(-2.0 * Float64(B_m * F))) / 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 <= 5e-57) tmp = sqrt((((B_m * B_m) + (C * (A * -4.0))) * (4.0 * (A * F)))) / (((4.0 * A) * C) - (B_m * B_m)); else tmp = sqrt((-2.0 * (B_m * F))) / (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, 5e-57], N[(N[Sqrt[N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(4.0 * N[(A * F), $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[Sqrt[N[(-2.0 * N[(B$95$m * F), $MachinePrecision]), $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 5 \cdot 10^{-57}:\\
\;\;\;\;\frac{\sqrt{\left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right) \cdot \left(4 \cdot \left(A \cdot F\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{-2 \cdot \left(B\_m \cdot F\right)}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 5.0000000000000002e-57Initial program 22.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified28.2%
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-rr30.6%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f6420.7%
Simplified20.7%
if 5.0000000000000002e-57 < B Initial program 14.3%
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.f6448.6%
Simplified48.6%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr48.8%
Taylor expanded in A around 0
*-lowering-*.f64N/A
*-lowering-*.f6447.7%
Simplified47.7%
Final simplification28.1%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 5.5e-57)
(/
(sqrt (* F (* (* 4.0 A) (+ (* B_m B_m) (* -4.0 (* A C))))))
(- (* (* 4.0 A) C) (* B_m B_m)))
(/ (sqrt (* -2.0 (* B_m F))) (- 0.0 B_m))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 5.5e-57) {
tmp = sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = sqrt((-2.0 * (B_m * F))) / (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 <= 5.5d-57) then
tmp = sqrt((f * ((4.0d0 * a) * ((b_m * b_m) + ((-4.0d0) * (a * c)))))) / (((4.0d0 * a) * c) - (b_m * b_m))
else
tmp = sqrt(((-2.0d0) * (b_m * f))) / (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 <= 5.5e-57) {
tmp = Math.sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = Math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 5.5e-57: tmp = math.sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / (((4.0 * A) * C) - (B_m * B_m)) else: tmp = math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 5.5e-57) tmp = Float64(sqrt(Float64(F * Float64(Float64(4.0 * A) * Float64(Float64(B_m * B_m) + Float64(-4.0 * Float64(A * C)))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); else tmp = Float64(sqrt(Float64(-2.0 * Float64(B_m * F))) / 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 <= 5.5e-57) tmp = sqrt((F * ((4.0 * A) * ((B_m * B_m) + (-4.0 * (A * C)))))) / (((4.0 * A) * C) - (B_m * B_m)); else tmp = sqrt((-2.0 * (B_m * F))) / (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, 5.5e-57], N[(N[Sqrt[N[(F * N[(N[(4.0 * A), $MachinePrecision] * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(-4.0 * N[(A * 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[Sqrt[N[(-2.0 * N[(B$95$m * F), $MachinePrecision]), $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 5.5 \cdot 10^{-57}:\\
\;\;\;\;\frac{\sqrt{F \cdot \left(\left(4 \cdot A\right) \cdot \left(B\_m \cdot B\_m + -4 \cdot \left(A \cdot C\right)\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{-2 \cdot \left(B\_m \cdot F\right)}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 5.50000000000000011e-57Initial program 22.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified28.2%
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-rr30.6%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f6420.7%
Simplified20.7%
associate-*r*N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6420.7%
Applied egg-rr20.7%
if 5.50000000000000011e-57 < B Initial program 14.3%
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.f6448.6%
Simplified48.6%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr48.8%
Taylor expanded in A around 0
*-lowering-*.f64N/A
*-lowering-*.f6447.7%
Simplified47.7%
Final simplification28.1%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 1e-83)
(/
(sqrt (* (* -4.0 (* A C)) (* 4.0 (* A F))))
(- (* (* 4.0 A) C) (* B_m B_m)))
(/ (sqrt (* -2.0 (* B_m F))) (- 0.0 B_m))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1e-83) {
tmp = sqrt(((-4.0 * (A * C)) * (4.0 * (A * F)))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = sqrt((-2.0 * (B_m * F))) / (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 <= 1d-83) then
tmp = sqrt((((-4.0d0) * (a * c)) * (4.0d0 * (a * f)))) / (((4.0d0 * a) * c) - (b_m * b_m))
else
tmp = sqrt(((-2.0d0) * (b_m * f))) / (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 <= 1e-83) {
tmp = Math.sqrt(((-4.0 * (A * C)) * (4.0 * (A * F)))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = Math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 1e-83: tmp = math.sqrt(((-4.0 * (A * C)) * (4.0 * (A * F)))) / (((4.0 * A) * C) - (B_m * B_m)) else: tmp = math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 1e-83) tmp = Float64(sqrt(Float64(Float64(-4.0 * Float64(A * C)) * Float64(4.0 * Float64(A * F)))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); else tmp = Float64(sqrt(Float64(-2.0 * Float64(B_m * F))) / 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 <= 1e-83) tmp = sqrt(((-4.0 * (A * C)) * (4.0 * (A * F)))) / (((4.0 * A) * C) - (B_m * B_m)); else tmp = sqrt((-2.0 * (B_m * F))) / (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, 1e-83], N[(N[Sqrt[N[(N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision] * N[(4.0 * N[(A * F), $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[Sqrt[N[(-2.0 * N[(B$95$m * F), $MachinePrecision]), $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 10^{-83}:\\
\;\;\;\;\frac{\sqrt{\left(-4 \cdot \left(A \cdot C\right)\right) \cdot \left(4 \cdot \left(A \cdot F\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{-2 \cdot \left(B\_m \cdot F\right)}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 1e-83Initial program 21.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified27.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-rr29.0%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f6420.3%
Simplified20.3%
Taylor expanded in B around 0
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6418.0%
Simplified18.0%
if 1e-83 < B Initial program 18.3%
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.f6447.2%
Simplified47.2%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr47.4%
Taylor expanded in A around 0
*-lowering-*.f64N/A
*-lowering-*.f6445.2%
Simplified45.2%
Final simplification26.2%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= F -1.35e-307)
(/ (sqrt (* -2.0 (* B_m F))) (- 0.0 B_m))
(*
0.25
(sqrt (/ (+ (* F -16.0) (* -4.0 (/ (* F (* B_m B_m)) (* A A)))) C)))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (F <= -1.35e-307) {
tmp = sqrt((-2.0 * (B_m * F))) / (0.0 - B_m);
} else {
tmp = 0.25 * sqrt((((F * -16.0) + (-4.0 * ((F * (B_m * B_m)) / (A * A)))) / C));
}
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 (f <= (-1.35d-307)) then
tmp = sqrt(((-2.0d0) * (b_m * f))) / (0.0d0 - b_m)
else
tmp = 0.25d0 * sqrt((((f * (-16.0d0)) + ((-4.0d0) * ((f * (b_m * b_m)) / (a * a)))) / c))
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 (F <= -1.35e-307) {
tmp = Math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m);
} else {
tmp = 0.25 * Math.sqrt((((F * -16.0) + (-4.0 * ((F * (B_m * B_m)) / (A * A)))) / C));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if F <= -1.35e-307: tmp = math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m) else: tmp = 0.25 * math.sqrt((((F * -16.0) + (-4.0 * ((F * (B_m * B_m)) / (A * A)))) / C)) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (F <= -1.35e-307) tmp = Float64(sqrt(Float64(-2.0 * Float64(B_m * F))) / Float64(0.0 - B_m)); else tmp = Float64(0.25 * sqrt(Float64(Float64(Float64(F * -16.0) + Float64(-4.0 * Float64(Float64(F * Float64(B_m * B_m)) / Float64(A * A)))) / C))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (F <= -1.35e-307) tmp = sqrt((-2.0 * (B_m * F))) / (0.0 - B_m); else tmp = 0.25 * sqrt((((F * -16.0) + (-4.0 * ((F * (B_m * B_m)) / (A * A)))) / C)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[F, -1.35e-307], N[(N[Sqrt[N[(-2.0 * N[(B$95$m * F), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision], N[(0.25 * N[Sqrt[N[(N[(N[(F * -16.0), $MachinePrecision] + N[(-4.0 * N[(N[(F * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] / N[(A * A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;F \leq -1.35 \cdot 10^{-307}:\\
\;\;\;\;\frac{\sqrt{-2 \cdot \left(B\_m \cdot F\right)}}{0 - B\_m}\\
\mathbf{else}:\\
\;\;\;\;0.25 \cdot \sqrt{\frac{F \cdot -16 + -4 \cdot \frac{F \cdot \left(B\_m \cdot B\_m\right)}{A \cdot A}}{C}}\\
\end{array}
\end{array}
if F < -1.34999999999999993e-307Initial program 19.3%
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.f6418.7%
Simplified18.7%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr18.7%
Taylor expanded in A around 0
*-lowering-*.f64N/A
*-lowering-*.f6416.9%
Simplified16.9%
if -1.34999999999999993e-307 < F Initial program 25.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified52.3%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
fma-defineN/A
mul-1-negN/A
fmm-undefN/A
--lowering--.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
Simplified23.4%
Taylor expanded in C around inf
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
cancel-sign-sub-invN/A
metadata-evalN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6461.3%
Simplified61.3%
Final simplification23.3%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= B_m 1.55e-83) (* (pow (- 0.0 (/ (* F (* B_m B_m)) C)) 0.5) (/ -1.0 B_m)) (/ (sqrt (* -2.0 (* B_m F))) (- 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.55e-83) {
tmp = pow((0.0 - ((F * (B_m * B_m)) / C)), 0.5) * (-1.0 / B_m);
} else {
tmp = sqrt((-2.0 * (B_m * F))) / (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.55d-83) then
tmp = ((0.0d0 - ((f * (b_m * b_m)) / c)) ** 0.5d0) * ((-1.0d0) / b_m)
else
tmp = sqrt(((-2.0d0) * (b_m * f))) / (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.55e-83) {
tmp = Math.pow((0.0 - ((F * (B_m * B_m)) / C)), 0.5) * (-1.0 / B_m);
} else {
tmp = Math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 1.55e-83: tmp = math.pow((0.0 - ((F * (B_m * B_m)) / C)), 0.5) * (-1.0 / B_m) else: tmp = math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 1.55e-83) tmp = Float64((Float64(0.0 - Float64(Float64(F * Float64(B_m * B_m)) / C)) ^ 0.5) * Float64(-1.0 / B_m)); else tmp = Float64(sqrt(Float64(-2.0 * Float64(B_m * F))) / 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.55e-83) tmp = ((0.0 - ((F * (B_m * B_m)) / C)) ^ 0.5) * (-1.0 / B_m); else tmp = sqrt((-2.0 * (B_m * F))) / (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.55e-83], N[(N[Power[N[(0.0 - N[(N[(F * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] / C), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] * N[(-1.0 / B$95$m), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(-2.0 * N[(B$95$m * F), $MachinePrecision]), $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.55 \cdot 10^{-83}:\\
\;\;\;\;{\left(0 - \frac{F \cdot \left(B\_m \cdot B\_m\right)}{C}\right)}^{0.5} \cdot \frac{-1}{B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{-2 \cdot \left(B\_m \cdot F\right)}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 1.54999999999999996e-83Initial program 21.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.f642.7%
Simplified2.7%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr2.7%
distribute-neg-frac2N/A
div-invN/A
*-lowering-*.f64N/A
pow-lowering-pow.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
metadata-evalN/A
frac-2negN/A
/-lowering-/.f642.7%
Applied egg-rr2.7%
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-*.f645.8%
Simplified5.8%
if 1.54999999999999996e-83 < B Initial program 18.5%
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.f6447.8%
Simplified47.8%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr47.9%
Taylor expanded in A around 0
*-lowering-*.f64N/A
*-lowering-*.f6445.7%
Simplified45.7%
Final simplification17.7%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= B_m 1.8e-83) (* (/ -1.0 B_m) (pow (- 0.0 (* F (/ (* B_m B_m) C))) 0.5)) (/ (sqrt (* -2.0 (* B_m F))) (- 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.8e-83) {
tmp = (-1.0 / B_m) * pow((0.0 - (F * ((B_m * B_m) / C))), 0.5);
} else {
tmp = sqrt((-2.0 * (B_m * F))) / (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.8d-83) then
tmp = ((-1.0d0) / b_m) * ((0.0d0 - (f * ((b_m * b_m) / c))) ** 0.5d0)
else
tmp = sqrt(((-2.0d0) * (b_m * f))) / (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.8e-83) {
tmp = (-1.0 / B_m) * Math.pow((0.0 - (F * ((B_m * B_m) / C))), 0.5);
} else {
tmp = Math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 1.8e-83: tmp = (-1.0 / B_m) * math.pow((0.0 - (F * ((B_m * B_m) / C))), 0.5) else: tmp = math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 1.8e-83) tmp = Float64(Float64(-1.0 / B_m) * (Float64(0.0 - Float64(F * Float64(Float64(B_m * B_m) / C))) ^ 0.5)); else tmp = Float64(sqrt(Float64(-2.0 * Float64(B_m * F))) / 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.8e-83) tmp = (-1.0 / B_m) * ((0.0 - (F * ((B_m * B_m) / C))) ^ 0.5); else tmp = sqrt((-2.0 * (B_m * F))) / (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.8e-83], N[(N[(-1.0 / B$95$m), $MachinePrecision] * N[Power[N[(0.0 - N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] / C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(-2.0 * N[(B$95$m * F), $MachinePrecision]), $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.8 \cdot 10^{-83}:\\
\;\;\;\;\frac{-1}{B\_m} \cdot {\left(0 - F \cdot \frac{B\_m \cdot B\_m}{C}\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{-2 \cdot \left(B\_m \cdot F\right)}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 1.80000000000000006e-83Initial program 21.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.f642.7%
Simplified2.7%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr2.7%
distribute-neg-frac2N/A
div-invN/A
*-lowering-*.f64N/A
pow-lowering-pow.f64N/A
*-commutativeN/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
+-commutativeN/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
metadata-evalN/A
frac-2negN/A
/-lowering-/.f642.7%
Applied egg-rr2.7%
Taylor expanded in C around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
/-lowering-/.f64N/A
unpow2N/A
*-lowering-*.f646.2%
Simplified6.2%
if 1.80000000000000006e-83 < B Initial program 18.5%
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.f6447.8%
Simplified47.8%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr47.9%
Taylor expanded in A around 0
*-lowering-*.f64N/A
*-lowering-*.f6445.7%
Simplified45.7%
Final simplification17.9%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= B_m 3.25e-83) (/ (pow (* (* B_m B_m) (- 0.0 (/ F C))) 0.5) (- 0.0 B_m)) (/ (sqrt (* -2.0 (* B_m F))) (- 0.0 B_m))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 3.25e-83) {
tmp = pow(((B_m * B_m) * (0.0 - (F / C))), 0.5) / (0.0 - B_m);
} else {
tmp = sqrt((-2.0 * (B_m * F))) / (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 <= 3.25d-83) then
tmp = (((b_m * b_m) * (0.0d0 - (f / c))) ** 0.5d0) / (0.0d0 - b_m)
else
tmp = sqrt(((-2.0d0) * (b_m * f))) / (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 <= 3.25e-83) {
tmp = Math.pow(((B_m * B_m) * (0.0 - (F / C))), 0.5) / (0.0 - B_m);
} else {
tmp = Math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 3.25e-83: tmp = math.pow(((B_m * B_m) * (0.0 - (F / C))), 0.5) / (0.0 - B_m) else: tmp = math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 3.25e-83) tmp = Float64((Float64(Float64(B_m * B_m) * Float64(0.0 - Float64(F / C))) ^ 0.5) / Float64(0.0 - B_m)); else tmp = Float64(sqrt(Float64(-2.0 * Float64(B_m * F))) / 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 <= 3.25e-83) tmp = (((B_m * B_m) * (0.0 - (F / C))) ^ 0.5) / (0.0 - B_m); else tmp = sqrt((-2.0 * (B_m * F))) / (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, 3.25e-83], N[(N[Power[N[(N[(B$95$m * B$95$m), $MachinePrecision] * N[(0.0 - N[(F / C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(-2.0 * N[(B$95$m * F), $MachinePrecision]), $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 3.25 \cdot 10^{-83}:\\
\;\;\;\;\frac{{\left(\left(B\_m \cdot B\_m\right) \cdot \left(0 - \frac{F}{C}\right)\right)}^{0.5}}{0 - B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{-2 \cdot \left(B\_m \cdot F\right)}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 3.25e-83Initial program 21.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.f642.7%
Simplified2.7%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr2.7%
Taylor expanded in C around inf
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-/l*N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
/-lowering-/.f646.2%
Simplified6.2%
if 3.25e-83 < B Initial program 18.5%
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.f6447.8%
Simplified47.8%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr47.9%
Taylor expanded in A around 0
*-lowering-*.f64N/A
*-lowering-*.f6445.7%
Simplified45.7%
Final simplification17.9%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= C -3.3e+133) (/ (pow (* 4.0 (* C F)) 0.5) (- 0.0 B_m)) (/ (sqrt (* -2.0 (* B_m F))) (- 0.0 B_m))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= -3.3e+133) {
tmp = pow((4.0 * (C * F)), 0.5) / (0.0 - B_m);
} else {
tmp = sqrt((-2.0 * (B_m * F))) / (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 <= (-3.3d+133)) then
tmp = ((4.0d0 * (c * f)) ** 0.5d0) / (0.0d0 - b_m)
else
tmp = sqrt(((-2.0d0) * (b_m * f))) / (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 <= -3.3e+133) {
tmp = Math.pow((4.0 * (C * F)), 0.5) / (0.0 - B_m);
} else {
tmp = Math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if C <= -3.3e+133: tmp = math.pow((4.0 * (C * F)), 0.5) / (0.0 - B_m) else: tmp = math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (C <= -3.3e+133) tmp = Float64((Float64(4.0 * Float64(C * F)) ^ 0.5) / Float64(0.0 - B_m)); else tmp = Float64(sqrt(Float64(-2.0 * Float64(B_m * F))) / 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 <= -3.3e+133) tmp = ((4.0 * (C * F)) ^ 0.5) / (0.0 - B_m); else tmp = sqrt((-2.0 * (B_m * F))) / (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, -3.3e+133], N[(N[Power[N[(4.0 * N[(C * F), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(-2.0 * N[(B$95$m * F), $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 -3.3 \cdot 10^{+133}:\\
\;\;\;\;\frac{{\left(4 \cdot \left(C \cdot F\right)\right)}^{0.5}}{0 - B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{-2 \cdot \left(B\_m \cdot F\right)}}{0 - B\_m}\\
\end{array}
\end{array}
if C < -3.3e133Initial program 8.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.f647.3%
Simplified7.3%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr7.6%
Taylor expanded in C around -inf
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f647.5%
Simplified7.5%
if -3.3e133 < C Initial program 22.0%
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.f6417.9%
Simplified17.9%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr18.0%
Taylor expanded in A around 0
*-lowering-*.f64N/A
*-lowering-*.f6416.6%
Simplified16.6%
Final simplification15.5%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= C -8e+134) (/ (* 2.0 (sqrt (* C F))) (- 0.0 B_m)) (/ (sqrt (* -2.0 (* B_m F))) (- 0.0 B_m))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (C <= -8e+134) {
tmp = (2.0 * sqrt((C * F))) / (0.0 - B_m);
} else {
tmp = sqrt((-2.0 * (B_m * F))) / (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 <= (-8d+134)) then
tmp = (2.0d0 * sqrt((c * f))) / (0.0d0 - b_m)
else
tmp = sqrt(((-2.0d0) * (b_m * f))) / (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 <= -8e+134) {
tmp = (2.0 * Math.sqrt((C * F))) / (0.0 - B_m);
} else {
tmp = Math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if C <= -8e+134: tmp = (2.0 * math.sqrt((C * F))) / (0.0 - B_m) else: tmp = math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (C <= -8e+134) tmp = Float64(Float64(2.0 * sqrt(Float64(C * F))) / Float64(0.0 - B_m)); else tmp = Float64(sqrt(Float64(-2.0 * Float64(B_m * F))) / 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 <= -8e+134) tmp = (2.0 * sqrt((C * F))) / (0.0 - B_m); else tmp = sqrt((-2.0 * (B_m * F))) / (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, -8e+134], N[(N[(2.0 * N[Sqrt[N[(C * F), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(-2.0 * N[(B$95$m * F), $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 -8 \cdot 10^{+134}:\\
\;\;\;\;\frac{2 \cdot \sqrt{C \cdot F}}{0 - B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{-2 \cdot \left(B\_m \cdot F\right)}}{0 - B\_m}\\
\end{array}
\end{array}
if C < -7.99999999999999937e134Initial program 8.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.f647.3%
Simplified7.3%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr7.6%
Taylor expanded in C around -inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
fma-defineN/A
mul-1-negN/A
fmm-undefN/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f641.5%
Simplified1.5%
Taylor expanded in C around inf
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
*-commutativeN/A
*-lowering-*.f647.2%
Simplified7.2%
if -7.99999999999999937e134 < C Initial program 22.0%
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.f6417.9%
Simplified17.9%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr18.0%
Taylor expanded in A around 0
*-lowering-*.f64N/A
*-lowering-*.f6416.6%
Simplified16.6%
Final simplification15.4%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (/ (sqrt (* -2.0 (* B_m F))) (- 0.0 B_m)))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
return sqrt((-2.0 * (B_m * F))) / (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(((-2.0d0) * (b_m * f))) / (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((-2.0 * (B_m * F))) / (0.0 - B_m);
}
B_m = math.fabs(B) def code(A, B_m, C, F): return math.sqrt((-2.0 * (B_m * F))) / (0.0 - B_m)
B_m = abs(B) function code(A, B_m, C, F) return Float64(sqrt(Float64(-2.0 * Float64(B_m * F))) / Float64(0.0 - B_m)) end
B_m = abs(B); function tmp = code(A, B_m, C, F) tmp = sqrt((-2.0 * (B_m * F))) / (0.0 - B_m); end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := N[(N[Sqrt[N[(-2.0 * N[(B$95$m * F), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
B_m = \left|B\right|
\\
\frac{\sqrt{-2 \cdot \left(B\_m \cdot F\right)}}{0 - B\_m}
\end{array}
Initial program 20.3%
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.f6416.0%
Simplified16.0%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr16.1%
Taylor expanded in A around 0
*-lowering-*.f64N/A
*-lowering-*.f6415.0%
Simplified15.0%
Final simplification15.0%
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 20.3%
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.f6416.0%
Simplified16.0%
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.3%
Simplified2.3%
Final simplification2.3%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (- 0.0 (sqrt (/ F C))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
return 0.0 - sqrt((F / C));
}
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 = 0.0d0 - sqrt((f / c))
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
return 0.0 - Math.sqrt((F / C));
}
B_m = math.fabs(B) def code(A, B_m, C, F): return 0.0 - math.sqrt((F / C))
B_m = abs(B) function code(A, B_m, C, F) return Float64(0.0 - sqrt(Float64(F / C))) end
B_m = abs(B); function tmp = code(A, B_m, C, F) tmp = 0.0 - sqrt((F / C)); end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := N[(0.0 - N[Sqrt[N[(F / C), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
B_m = \left|B\right|
\\
0 - \sqrt{\frac{F}{C}}
\end{array}
Initial program 20.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.f6416.4%
Simplified16.4%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
associate-*l/N/A
/-lowering-/.f64N/A
Applied egg-rr16.5%
Taylor expanded in C around -inf
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
fma-defineN/A
mul-1-negN/A
fmm-undefN/A
--lowering--.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f641.6%
Simplified1.6%
Taylor expanded in B around -inf
*-commutativeN/A
unpow2N/A
rem-square-sqrtN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f642.4%
Simplified2.4%
Final simplification2.4%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (sqrt (/ 2.0 (/ B_m F))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
return sqrt((2.0 / (B_m / F)));
}
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((2.0d0 / (b_m / f)))
end function
B_m = Math.abs(B);
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) def code(A, B_m, C, F): return math.sqrt((2.0 / (B_m / F)))
B_m = abs(B) function code(A, B_m, C, F) return sqrt(Float64(2.0 / Float64(B_m / F))) end
B_m = abs(B); function tmp = code(A, B_m, C, F) tmp = sqrt((2.0 / (B_m / F))); end
B_m = N[Abs[B], $MachinePrecision] 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|
\\
\sqrt{\frac{2}{\frac{B\_m}{F}}}
\end{array}
Initial program 20.3%
Taylor expanded in B around -inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
unpow2N/A
rem-square-sqrtN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f642.1%
Simplified2.1%
distribute-rgt-neg-inN/A
mul-1-negN/A
remove-double-negN/A
sqrt-unprodN/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f642.1%
Applied egg-rr2.1%
sqrt-lowering-sqrt.f64N/A
*-commutativeN/A
clear-numN/A
un-div-invN/A
/-lowering-/.f64N/A
/-lowering-/.f642.1%
Applied egg-rr2.1%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (sqrt (* F (/ 2.0 B_m))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
return sqrt((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((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((F * (2.0 / B_m)));
}
B_m = math.fabs(B) def code(A, B_m, C, F): return math.sqrt((F * (2.0 / B_m)))
B_m = abs(B) function code(A, B_m, C, F) return sqrt(Float64(F * Float64(2.0 / B_m))) end
B_m = abs(B); function tmp = code(A, B_m, C, F) tmp = sqrt((F * (2.0 / B_m))); end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := N[Sqrt[N[(F * N[(2.0 / B$95$m), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
B_m = \left|B\right|
\\
\sqrt{F \cdot \frac{2}{B\_m}}
\end{array}
Initial program 20.3%
Taylor expanded in B around -inf
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
unpow2N/A
rem-square-sqrtN/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f642.1%
Simplified2.1%
distribute-rgt-neg-inN/A
mul-1-negN/A
remove-double-negN/A
sqrt-unprodN/A
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f642.1%
Applied egg-rr2.1%
associate-*l/N/A
associate-/l*N/A
*-lowering-*.f64N/A
/-lowering-/.f642.1%
Applied egg-rr2.1%
herbie shell --seed 2024150
(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))))