
(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 36 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (A B C F)
:precision binary64
(let* ((t_0 (- (pow B 2.0) (* (* 4.0 A) C))))
(/
(-
(sqrt
(*
(* 2.0 (* t_0 F))
(+ (+ A C) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0)))))))
t_0)))
double code(double A, double B, double C, double F) {
double t_0 = pow(B, 2.0) - ((4.0 * A) * C);
return -sqrt(((2.0 * (t_0 * F)) * ((A + C) + sqrt((pow((A - C), 2.0) + pow(B, 2.0)))))) / t_0;
}
real(8) function code(a, b, c, f)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8), intent (in) :: f
real(8) :: t_0
t_0 = (b ** 2.0d0) - ((4.0d0 * a) * c)
code = -sqrt(((2.0d0 * (t_0 * f)) * ((a + c) + sqrt((((a - c) ** 2.0d0) + (b ** 2.0d0)))))) / t_0
end function
public static double code(double A, double B, double C, double F) {
double t_0 = Math.pow(B, 2.0) - ((4.0 * A) * C);
return -Math.sqrt(((2.0 * (t_0 * F)) * ((A + C) + Math.sqrt((Math.pow((A - C), 2.0) + Math.pow(B, 2.0)))))) / t_0;
}
def code(A, B, C, F): t_0 = math.pow(B, 2.0) - ((4.0 * A) * C) return -math.sqrt(((2.0 * (t_0 * F)) * ((A + C) + math.sqrt((math.pow((A - C), 2.0) + math.pow(B, 2.0)))))) / t_0
function code(A, B, C, F) t_0 = Float64((B ^ 2.0) - Float64(Float64(4.0 * A) * C)) return Float64(Float64(-sqrt(Float64(Float64(2.0 * Float64(t_0 * F)) * Float64(Float64(A + C) + sqrt(Float64((Float64(A - C) ^ 2.0) + (B ^ 2.0))))))) / t_0) end
function tmp = code(A, B, C, F) t_0 = (B ^ 2.0) - ((4.0 * A) * C); tmp = -sqrt(((2.0 * (t_0 * F)) * ((A + C) + sqrt((((A - C) ^ 2.0) + (B ^ 2.0)))))) / t_0; end
code[A_, B_, C_, F_] := Block[{t$95$0 = N[(N[Power[B, 2.0], $MachinePrecision] - N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]), $MachinePrecision]}, N[((-N[Sqrt[N[(N[(2.0 * N[(t$95$0 * F), $MachinePrecision]), $MachinePrecision] * N[(N[(A + C), $MachinePrecision] + N[Sqrt[N[(N[Power[N[(A - C), $MachinePrecision], 2.0], $MachinePrecision] + N[Power[B, 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]) / t$95$0), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := {B}^{2} - \left(4 \cdot A\right) \cdot C\\
\frac{-\sqrt{\left(2 \cdot \left(t\_0 \cdot F\right)\right) \cdot \left(\left(A + C\right) + \sqrt{{\left(A - C\right)}^{2} + {B}^{2}}\right)}}{t\_0}
\end{array}
\end{array}
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (+ (* B_m B_m) (* C C)))
(t_1 (sqrt (/ 1.0 t_0)))
(t_2 (- 1.0 (* C t_1)))
(t_3 (hypot B_m (- A C)))
(t_4 (+ C (hypot B_m C)))
(t_5 (* (* 4.0 A) C))
(t_6
(/
(sqrt
(*
(* 2.0 (* (- (pow B_m 2.0) t_5) F))
(+ (+ A C) (sqrt (+ (pow B_m 2.0) (pow (- A C) 2.0))))))
(- t_5 (pow B_m 2.0))))
(t_7 (- t_5 (* B_m B_m))))
(if (<= t_6 -5e-118)
(-
0.0
(*
(sqrt F)
(pow (* 2.0 (/ (+ (+ A C) t_3) (+ (* B_m B_m) (* A (* C -4.0))))) 0.5)))
(if (<= t_6 20000.0)
(/
(sqrt
(+
(* (* 2.0 (* B_m B_m)) (* F t_4))
(*
A
(*
2.0
(+
(*
(* A F)
(+
(* (* C -4.0) t_2)
(* 0.5 (* (* B_m B_m) (* t_1 (- 1.0 (/ (* C C) t_0)))))))
(* F (+ (* -4.0 (* C t_4)) (* (* B_m B_m) t_2))))))))
t_7)
(if (<= t_6 INFINITY)
(*
(sqrt (* 2.0 (* F (+ (* B_m B_m) (* C (* A -4.0))))))
(/ (pow (+ A (+ C t_3)) 0.5) t_7))
(/ -1.0 (* (/ B_m (sqrt 2.0)) (* (pow t_4 -0.5) (pow F -0.5)))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = (B_m * B_m) + (C * C);
double t_1 = sqrt((1.0 / t_0));
double t_2 = 1.0 - (C * t_1);
double t_3 = hypot(B_m, (A - C));
double t_4 = C + hypot(B_m, C);
double t_5 = (4.0 * A) * C;
double t_6 = sqrt(((2.0 * ((pow(B_m, 2.0) - t_5) * F)) * ((A + C) + sqrt((pow(B_m, 2.0) + pow((A - C), 2.0)))))) / (t_5 - pow(B_m, 2.0));
double t_7 = t_5 - (B_m * B_m);
double tmp;
if (t_6 <= -5e-118) {
tmp = 0.0 - (sqrt(F) * pow((2.0 * (((A + C) + t_3) / ((B_m * B_m) + (A * (C * -4.0))))), 0.5));
} else if (t_6 <= 20000.0) {
tmp = sqrt((((2.0 * (B_m * B_m)) * (F * t_4)) + (A * (2.0 * (((A * F) * (((C * -4.0) * t_2) + (0.5 * ((B_m * B_m) * (t_1 * (1.0 - ((C * C) / t_0))))))) + (F * ((-4.0 * (C * t_4)) + ((B_m * B_m) * t_2)))))))) / t_7;
} else if (t_6 <= ((double) INFINITY)) {
tmp = sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (pow((A + (C + t_3)), 0.5) / t_7);
} else {
tmp = -1.0 / ((B_m / sqrt(2.0)) * (pow(t_4, -0.5) * pow(F, -0.5)));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = (B_m * B_m) + (C * C);
double t_1 = Math.sqrt((1.0 / t_0));
double t_2 = 1.0 - (C * t_1);
double t_3 = Math.hypot(B_m, (A - C));
double t_4 = C + Math.hypot(B_m, C);
double t_5 = (4.0 * A) * C;
double t_6 = Math.sqrt(((2.0 * ((Math.pow(B_m, 2.0) - t_5) * F)) * ((A + C) + Math.sqrt((Math.pow(B_m, 2.0) + Math.pow((A - C), 2.0)))))) / (t_5 - Math.pow(B_m, 2.0));
double t_7 = t_5 - (B_m * B_m);
double tmp;
if (t_6 <= -5e-118) {
tmp = 0.0 - (Math.sqrt(F) * Math.pow((2.0 * (((A + C) + t_3) / ((B_m * B_m) + (A * (C * -4.0))))), 0.5));
} else if (t_6 <= 20000.0) {
tmp = Math.sqrt((((2.0 * (B_m * B_m)) * (F * t_4)) + (A * (2.0 * (((A * F) * (((C * -4.0) * t_2) + (0.5 * ((B_m * B_m) * (t_1 * (1.0 - ((C * C) / t_0))))))) + (F * ((-4.0 * (C * t_4)) + ((B_m * B_m) * t_2)))))))) / t_7;
} else if (t_6 <= Double.POSITIVE_INFINITY) {
tmp = Math.sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (Math.pow((A + (C + t_3)), 0.5) / t_7);
} else {
tmp = -1.0 / ((B_m / Math.sqrt(2.0)) * (Math.pow(t_4, -0.5) * Math.pow(F, -0.5)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = (B_m * B_m) + (C * C) t_1 = math.sqrt((1.0 / t_0)) t_2 = 1.0 - (C * t_1) t_3 = math.hypot(B_m, (A - C)) t_4 = C + math.hypot(B_m, C) t_5 = (4.0 * A) * C t_6 = math.sqrt(((2.0 * ((math.pow(B_m, 2.0) - t_5) * F)) * ((A + C) + math.sqrt((math.pow(B_m, 2.0) + math.pow((A - C), 2.0)))))) / (t_5 - math.pow(B_m, 2.0)) t_7 = t_5 - (B_m * B_m) tmp = 0 if t_6 <= -5e-118: tmp = 0.0 - (math.sqrt(F) * math.pow((2.0 * (((A + C) + t_3) / ((B_m * B_m) + (A * (C * -4.0))))), 0.5)) elif t_6 <= 20000.0: tmp = math.sqrt((((2.0 * (B_m * B_m)) * (F * t_4)) + (A * (2.0 * (((A * F) * (((C * -4.0) * t_2) + (0.5 * ((B_m * B_m) * (t_1 * (1.0 - ((C * C) / t_0))))))) + (F * ((-4.0 * (C * t_4)) + ((B_m * B_m) * t_2)))))))) / t_7 elif t_6 <= math.inf: tmp = math.sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (math.pow((A + (C + t_3)), 0.5) / t_7) else: tmp = -1.0 / ((B_m / math.sqrt(2.0)) * (math.pow(t_4, -0.5) * math.pow(F, -0.5))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(B_m * B_m) + Float64(C * C)) t_1 = sqrt(Float64(1.0 / t_0)) t_2 = Float64(1.0 - Float64(C * t_1)) t_3 = hypot(B_m, Float64(A - C)) t_4 = Float64(C + hypot(B_m, C)) t_5 = Float64(Float64(4.0 * A) * C) t_6 = Float64(sqrt(Float64(Float64(2.0 * Float64(Float64((B_m ^ 2.0) - t_5) * F)) * Float64(Float64(A + C) + sqrt(Float64((B_m ^ 2.0) + (Float64(A - C) ^ 2.0)))))) / Float64(t_5 - (B_m ^ 2.0))) t_7 = Float64(t_5 - Float64(B_m * B_m)) tmp = 0.0 if (t_6 <= -5e-118) tmp = Float64(0.0 - Float64(sqrt(F) * (Float64(2.0 * Float64(Float64(Float64(A + C) + t_3) / Float64(Float64(B_m * B_m) + Float64(A * Float64(C * -4.0))))) ^ 0.5))); elseif (t_6 <= 20000.0) tmp = Float64(sqrt(Float64(Float64(Float64(2.0 * Float64(B_m * B_m)) * Float64(F * t_4)) + Float64(A * Float64(2.0 * Float64(Float64(Float64(A * F) * Float64(Float64(Float64(C * -4.0) * t_2) + Float64(0.5 * Float64(Float64(B_m * B_m) * Float64(t_1 * Float64(1.0 - Float64(Float64(C * C) / t_0))))))) + Float64(F * Float64(Float64(-4.0 * Float64(C * t_4)) + Float64(Float64(B_m * B_m) * t_2)))))))) / t_7); elseif (t_6 <= Inf) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0)))))) * Float64((Float64(A + Float64(C + t_3)) ^ 0.5) / t_7)); else tmp = Float64(-1.0 / Float64(Float64(B_m / sqrt(2.0)) * Float64((t_4 ^ -0.5) * (F ^ -0.5)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = (B_m * B_m) + (C * C); t_1 = sqrt((1.0 / t_0)); t_2 = 1.0 - (C * t_1); t_3 = hypot(B_m, (A - C)); t_4 = C + hypot(B_m, C); t_5 = (4.0 * A) * C; t_6 = sqrt(((2.0 * (((B_m ^ 2.0) - t_5) * F)) * ((A + C) + sqrt(((B_m ^ 2.0) + ((A - C) ^ 2.0)))))) / (t_5 - (B_m ^ 2.0)); t_7 = t_5 - (B_m * B_m); tmp = 0.0; if (t_6 <= -5e-118) tmp = 0.0 - (sqrt(F) * ((2.0 * (((A + C) + t_3) / ((B_m * B_m) + (A * (C * -4.0))))) ^ 0.5)); elseif (t_6 <= 20000.0) tmp = sqrt((((2.0 * (B_m * B_m)) * (F * t_4)) + (A * (2.0 * (((A * F) * (((C * -4.0) * t_2) + (0.5 * ((B_m * B_m) * (t_1 * (1.0 - ((C * C) / t_0))))))) + (F * ((-4.0 * (C * t_4)) + ((B_m * B_m) * t_2)))))))) / t_7; elseif (t_6 <= Inf) tmp = sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (((A + (C + t_3)) ^ 0.5) / t_7); else tmp = -1.0 / ((B_m / sqrt(2.0)) * ((t_4 ^ -0.5) * (F ^ -0.5))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * C), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[Sqrt[N[(1.0 / t$95$0), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$2 = N[(1.0 - N[(C * t$95$1), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$3 = N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, Block[{t$95$4 = N[(C + N[Sqrt[B$95$m ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$5 = N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]}, Block[{t$95$6 = N[(N[Sqrt[N[(N[(2.0 * N[(N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$5), $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$5 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$7 = N[(t$95$5 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$6, -5e-118], N[(0.0 - N[(N[Sqrt[F], $MachinePrecision] * N[Power[N[(2.0 * N[(N[(N[(A + C), $MachinePrecision] + t$95$3), $MachinePrecision] / N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$6, 20000.0], N[(N[Sqrt[N[(N[(N[(2.0 * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] * N[(F * t$95$4), $MachinePrecision]), $MachinePrecision] + N[(A * N[(2.0 * N[(N[(N[(A * F), $MachinePrecision] * N[(N[(N[(C * -4.0), $MachinePrecision] * t$95$2), $MachinePrecision] + N[(0.5 * N[(N[(B$95$m * B$95$m), $MachinePrecision] * N[(t$95$1 * N[(1.0 - N[(N[(C * C), $MachinePrecision] / t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(F * N[(N[(-4.0 * N[(C * t$95$4), $MachinePrecision]), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] * t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$7), $MachinePrecision], If[LessEqual[t$95$6, Infinity], N[(N[Sqrt[N[(2.0 * N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Power[N[(A + N[(C + t$95$3), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / t$95$7), $MachinePrecision]), $MachinePrecision], N[(-1.0 / N[(N[(B$95$m / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[t$95$4, -0.5], $MachinePrecision] * N[Power[F, -0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]]]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := B\_m \cdot B\_m + C \cdot C\\
t_1 := \sqrt{\frac{1}{t\_0}}\\
t_2 := 1 - C \cdot t\_1\\
t_3 := \mathsf{hypot}\left(B\_m, A - C\right)\\
t_4 := C + \mathsf{hypot}\left(B\_m, C\right)\\
t_5 := \left(4 \cdot A\right) \cdot C\\
t_6 := \frac{\sqrt{\left(2 \cdot \left(\left({B\_m}^{2} - t\_5\right) \cdot F\right)\right) \cdot \left(\left(A + C\right) + \sqrt{{B\_m}^{2} + {\left(A - C\right)}^{2}}\right)}}{t\_5 - {B\_m}^{2}}\\
t_7 := t\_5 - B\_m \cdot B\_m\\
\mathbf{if}\;t\_6 \leq -5 \cdot 10^{-118}:\\
\;\;\;\;0 - \sqrt{F} \cdot {\left(2 \cdot \frac{\left(A + C\right) + t\_3}{B\_m \cdot B\_m + A \cdot \left(C \cdot -4\right)}\right)}^{0.5}\\
\mathbf{elif}\;t\_6 \leq 20000:\\
\;\;\;\;\frac{\sqrt{\left(2 \cdot \left(B\_m \cdot B\_m\right)\right) \cdot \left(F \cdot t\_4\right) + A \cdot \left(2 \cdot \left(\left(A \cdot F\right) \cdot \left(\left(C \cdot -4\right) \cdot t\_2 + 0.5 \cdot \left(\left(B\_m \cdot B\_m\right) \cdot \left(t\_1 \cdot \left(1 - \frac{C \cdot C}{t\_0}\right)\right)\right)\right) + F \cdot \left(-4 \cdot \left(C \cdot t\_4\right) + \left(B\_m \cdot B\_m\right) \cdot t\_2\right)\right)\right)}}{t\_7}\\
\mathbf{elif}\;t\_6 \leq \infty:\\
\;\;\;\;\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right)\right)} \cdot \frac{{\left(A + \left(C + t\_3\right)\right)}^{0.5}}{t\_7}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\frac{B\_m}{\sqrt{2}} \cdot \left({t\_4}^{-0.5} \cdot {F}^{-0.5}\right)}\\
\end{array}
\end{array}
if (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < -5.00000000000000015e-118Initial program 45.6%
Taylor expanded in F around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
Simplified54.0%
sqrt-unprodN/A
pow1/2N/A
associate-/l*N/A
associate-*l*N/A
unpow-prod-downN/A
pow1/2N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
Applied egg-rr72.6%
if -5.00000000000000015e-118 < (/.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))) < 2e4Initial program 30.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified30.5%
Taylor expanded in A around 0
Simplified53.1%
if 2e4 < (/.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 35.6%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified67.6%
pow1/2N/A
unpow-prod-downN/A
associate-/l*N/A
*-lowering-*.f64N/A
Applied egg-rr80.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%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified0.4%
Applied egg-rr0.7%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f642.0%
Simplified2.0%
pow1/2N/A
inv-powN/A
pow-powN/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
metadata-evalN/A
pow-lowering-pow.f64N/A
metadata-eval30.9%
Applied egg-rr30.9%
Final simplification51.0%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (hypot B_m (- A C)))
(t_1 (* (* 4.0 A) C))
(t_2
(/
(sqrt
(*
(* 2.0 (* (- (pow B_m 2.0) t_1) F))
(+ (+ A C) (sqrt (+ (pow B_m 2.0) (pow (- A C) 2.0))))))
(- t_1 (pow B_m 2.0)))))
(if (<= t_2 5e-162)
(-
0.0
(*
(sqrt F)
(pow (* 2.0 (/ (+ (+ A C) t_0) (+ (* B_m B_m) (* A (* C -4.0))))) 0.5)))
(if (<= t_2 INFINITY)
(*
(sqrt (* 2.0 (* F (+ (* B_m B_m) (* C (* A -4.0))))))
(/ (pow (+ A (+ C t_0)) 0.5) (- t_1 (* B_m B_m))))
(/
-1.0
(*
(/ B_m (sqrt 2.0))
(* (pow (+ C (hypot B_m C)) -0.5) (pow F -0.5))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = hypot(B_m, (A - C));
double t_1 = (4.0 * A) * C;
double t_2 = sqrt(((2.0 * ((pow(B_m, 2.0) - t_1) * F)) * ((A + C) + sqrt((pow(B_m, 2.0) + pow((A - C), 2.0)))))) / (t_1 - pow(B_m, 2.0));
double tmp;
if (t_2 <= 5e-162) {
tmp = 0.0 - (sqrt(F) * pow((2.0 * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0))))), 0.5));
} else if (t_2 <= ((double) INFINITY)) {
tmp = sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (pow((A + (C + t_0)), 0.5) / (t_1 - (B_m * B_m)));
} else {
tmp = -1.0 / ((B_m / sqrt(2.0)) * (pow((C + hypot(B_m, C)), -0.5) * pow(F, -0.5)));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double t_0 = Math.hypot(B_m, (A - C));
double t_1 = (4.0 * A) * C;
double t_2 = Math.sqrt(((2.0 * ((Math.pow(B_m, 2.0) - t_1) * F)) * ((A + C) + Math.sqrt((Math.pow(B_m, 2.0) + Math.pow((A - C), 2.0)))))) / (t_1 - Math.pow(B_m, 2.0));
double tmp;
if (t_2 <= 5e-162) {
tmp = 0.0 - (Math.sqrt(F) * Math.pow((2.0 * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0))))), 0.5));
} else if (t_2 <= Double.POSITIVE_INFINITY) {
tmp = Math.sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (Math.pow((A + (C + t_0)), 0.5) / (t_1 - (B_m * B_m)));
} else {
tmp = -1.0 / ((B_m / Math.sqrt(2.0)) * (Math.pow((C + Math.hypot(B_m, C)), -0.5) * Math.pow(F, -0.5)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = math.hypot(B_m, (A - C)) t_1 = (4.0 * A) * C t_2 = math.sqrt(((2.0 * ((math.pow(B_m, 2.0) - t_1) * F)) * ((A + C) + math.sqrt((math.pow(B_m, 2.0) + math.pow((A - C), 2.0)))))) / (t_1 - math.pow(B_m, 2.0)) tmp = 0 if t_2 <= 5e-162: tmp = 0.0 - (math.sqrt(F) * math.pow((2.0 * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0))))), 0.5)) elif t_2 <= math.inf: tmp = math.sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (math.pow((A + (C + t_0)), 0.5) / (t_1 - (B_m * B_m))) else: tmp = -1.0 / ((B_m / math.sqrt(2.0)) * (math.pow((C + math.hypot(B_m, C)), -0.5) * math.pow(F, -0.5))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = hypot(B_m, Float64(A - C)) t_1 = Float64(Float64(4.0 * A) * C) t_2 = Float64(sqrt(Float64(Float64(2.0 * Float64(Float64((B_m ^ 2.0) - t_1) * F)) * Float64(Float64(A + C) + sqrt(Float64((B_m ^ 2.0) + (Float64(A - C) ^ 2.0)))))) / Float64(t_1 - (B_m ^ 2.0))) tmp = 0.0 if (t_2 <= 5e-162) tmp = Float64(0.0 - Float64(sqrt(F) * (Float64(2.0 * Float64(Float64(Float64(A + C) + t_0) / Float64(Float64(B_m * B_m) + Float64(A * Float64(C * -4.0))))) ^ 0.5))); elseif (t_2 <= Inf) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0)))))) * Float64((Float64(A + Float64(C + t_0)) ^ 0.5) / Float64(t_1 - Float64(B_m * B_m)))); else tmp = Float64(-1.0 / Float64(Float64(B_m / sqrt(2.0)) * Float64((Float64(C + hypot(B_m, C)) ^ -0.5) * (F ^ -0.5)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = hypot(B_m, (A - C)); t_1 = (4.0 * A) * C; t_2 = sqrt(((2.0 * (((B_m ^ 2.0) - t_1) * F)) * ((A + C) + sqrt(((B_m ^ 2.0) + ((A - C) ^ 2.0)))))) / (t_1 - (B_m ^ 2.0)); tmp = 0.0; if (t_2 <= 5e-162) tmp = 0.0 - (sqrt(F) * ((2.0 * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0))))) ^ 0.5)); elseif (t_2 <= Inf) tmp = sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (((A + (C + t_0)) ^ 0.5) / (t_1 - (B_m * B_m))); else tmp = -1.0 / ((B_m / sqrt(2.0)) * (((C + hypot(B_m, C)) ^ -0.5) * (F ^ -0.5))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, Block[{t$95$1 = N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]}, Block[{t$95$2 = N[(N[Sqrt[N[(N[(2.0 * N[(N[(N[Power[B$95$m, 2.0], $MachinePrecision] - t$95$1), $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$1 - N[Power[B$95$m, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$2, 5e-162], N[(0.0 - N[(N[Sqrt[F], $MachinePrecision] * N[Power[N[(2.0 * N[(N[(N[(A + C), $MachinePrecision] + t$95$0), $MachinePrecision] / N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$2, Infinity], N[(N[Sqrt[N[(2.0 * N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Power[N[(A + N[(C + t$95$0), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(t$95$1 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(-1.0 / N[(N[(B$95$m / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(C + N[Sqrt[B$95$m ^ 2 + C ^ 2], $MachinePrecision]), $MachinePrecision], -0.5], $MachinePrecision] * N[Power[F, -0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \mathsf{hypot}\left(B\_m, A - C\right)\\
t_1 := \left(4 \cdot A\right) \cdot C\\
t_2 := \frac{\sqrt{\left(2 \cdot \left(\left({B\_m}^{2} - t\_1\right) \cdot F\right)\right) \cdot \left(\left(A + C\right) + \sqrt{{B\_m}^{2} + {\left(A - C\right)}^{2}}\right)}}{t\_1 - {B\_m}^{2}}\\
\mathbf{if}\;t\_2 \leq 5 \cdot 10^{-162}:\\
\;\;\;\;0 - \sqrt{F} \cdot {\left(2 \cdot \frac{\left(A + C\right) + t\_0}{B\_m \cdot B\_m + A \cdot \left(C \cdot -4\right)}\right)}^{0.5}\\
\mathbf{elif}\;t\_2 \leq \infty:\\
\;\;\;\;\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right)\right)} \cdot \frac{{\left(A + \left(C + t\_0\right)\right)}^{0.5}}{t\_1 - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{\frac{B\_m}{\sqrt{2}} \cdot \left({\left(C + \mathsf{hypot}\left(B\_m, C\right)\right)}^{-0.5} \cdot {F}^{-0.5}\right)}\\
\end{array}
\end{array}
if (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) < 5.00000000000000014e-162Initial program 38.0%
Taylor expanded in F around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
Simplified44.4%
sqrt-unprodN/A
pow1/2N/A
associate-/l*N/A
associate-*l*N/A
unpow-prod-downN/A
pow1/2N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
Applied egg-rr60.9%
if 5.00000000000000014e-162 < (/.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 52.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified75.0%
pow1/2N/A
unpow-prod-downN/A
associate-/l*N/A
*-lowering-*.f64N/A
Applied egg-rr81.0%
if +inf.0 < (/.f64 (neg.f64 (sqrt.f64 (*.f64 (*.f64 #s(literal 2 binary64) (*.f64 (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C)) F)) (+.f64 (+.f64 A C) (sqrt.f64 (+.f64 (pow.f64 (-.f64 A C) #s(literal 2 binary64)) (pow.f64 B #s(literal 2 binary64)))))))) (-.f64 (pow.f64 B #s(literal 2 binary64)) (*.f64 (*.f64 #s(literal 4 binary64) A) C))) Initial program 0.0%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified0.4%
Applied egg-rr0.7%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f642.0%
Simplified2.0%
pow1/2N/A
inv-powN/A
pow-powN/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow-lowering-pow.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
metadata-evalN/A
pow-lowering-pow.f64N/A
metadata-eval30.9%
Applied egg-rr30.9%
Final simplification48.9%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 2.75e+80)
(*
(sqrt (* 2.0 (* F (+ (* B_m B_m) (* C (* A -4.0))))))
(/
(pow (+ A (+ C (hypot B_m (- A C)))) 0.5)
(- (* (* 4.0 A) C) (* B_m B_m))))
(*
(/ (/ -1.0 B_m) (pow 2.0 -0.5))
(* (sqrt F) (sqrt (+ A (hypot B_m A)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 2.75e+80) {
tmp = sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (pow((A + (C + hypot(B_m, (A - C)))), 0.5) / (((4.0 * A) * C) - (B_m * B_m)));
} else {
tmp = ((-1.0 / B_m) / pow(2.0, -0.5)) * (sqrt(F) * sqrt((A + hypot(B_m, A))));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 2.75e+80) {
tmp = Math.sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (Math.pow((A + (C + Math.hypot(B_m, (A - C)))), 0.5) / (((4.0 * A) * C) - (B_m * B_m)));
} else {
tmp = ((-1.0 / B_m) / Math.pow(2.0, -0.5)) * (Math.sqrt(F) * Math.sqrt((A + Math.hypot(B_m, A))));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 2.75e+80: tmp = math.sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (math.pow((A + (C + math.hypot(B_m, (A - C)))), 0.5) / (((4.0 * A) * C) - (B_m * B_m))) else: tmp = ((-1.0 / B_m) / math.pow(2.0, -0.5)) * (math.sqrt(F) * math.sqrt((A + math.hypot(B_m, A)))) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 2.75e+80) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0)))))) * Float64((Float64(A + Float64(C + hypot(B_m, Float64(A - C)))) ^ 0.5) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)))); else tmp = Float64(Float64(Float64(-1.0 / B_m) / (2.0 ^ -0.5)) * Float64(sqrt(F) * sqrt(Float64(A + hypot(B_m, A))))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (B_m <= 2.75e+80) tmp = sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (((A + (C + hypot(B_m, (A - C)))) ^ 0.5) / (((4.0 * A) * C) - (B_m * B_m))); else tmp = ((-1.0 / B_m) / (2.0 ^ -0.5)) * (sqrt(F) * sqrt((A + hypot(B_m, A)))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 2.75e+80], N[(N[Sqrt[N[(2.0 * N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Power[N[(A + N[(C + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(-1.0 / B$95$m), $MachinePrecision] / N[Power[2.0, -0.5], $MachinePrecision]), $MachinePrecision] * N[(N[Sqrt[F], $MachinePrecision] * N[Sqrt[N[(A + N[Sqrt[B$95$m ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 2.75 \cdot 10^{+80}:\\
\;\;\;\;\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right)\right)} \cdot \frac{{\left(A + \left(C + \mathsf{hypot}\left(B\_m, A - C\right)\right)\right)}^{0.5}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{-1}{B\_m}}{{2}^{-0.5}} \cdot \left(\sqrt{F} \cdot \sqrt{A + \mathsf{hypot}\left(B\_m, A\right)}\right)\\
\end{array}
\end{array}
if B < 2.74999999999999984e80Initial program 26.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified30.5%
pow1/2N/A
unpow-prod-downN/A
associate-/l*N/A
*-lowering-*.f64N/A
Applied egg-rr34.0%
if 2.74999999999999984e80 < B Initial program 5.9%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6447.3%
Simplified47.3%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6470.5%
Applied egg-rr70.5%
clear-numN/A
div-invN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
pow1/2N/A
pow-flipN/A
metadata-evalN/A
metadata-evalN/A
pow-lowering-pow.f64N/A
metadata-eval70.5%
Applied egg-rr70.5%
Final simplification41.9%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 5.3e+79)
(*
(sqrt (* 2.0 (* F (+ (* B_m B_m) (* C (* A -4.0))))))
(/
(pow (+ A (+ C (hypot B_m (- A C)))) 0.5)
(- (* (* 4.0 A) C) (* B_m B_m))))
(* (* (sqrt F) (sqrt (+ A (hypot B_m A)))) (/ -1.0 (* B_m (sqrt 0.5))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 5.3e+79) {
tmp = sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (pow((A + (C + hypot(B_m, (A - C)))), 0.5) / (((4.0 * A) * C) - (B_m * B_m)));
} else {
tmp = (sqrt(F) * sqrt((A + hypot(B_m, A)))) * (-1.0 / (B_m * sqrt(0.5)));
}
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+79) {
tmp = Math.sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (Math.pow((A + (C + Math.hypot(B_m, (A - C)))), 0.5) / (((4.0 * A) * C) - (B_m * B_m)));
} else {
tmp = (Math.sqrt(F) * Math.sqrt((A + Math.hypot(B_m, A)))) * (-1.0 / (B_m * Math.sqrt(0.5)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 5.3e+79: tmp = math.sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (math.pow((A + (C + math.hypot(B_m, (A - C)))), 0.5) / (((4.0 * A) * C) - (B_m * B_m))) else: tmp = (math.sqrt(F) * math.sqrt((A + math.hypot(B_m, A)))) * (-1.0 / (B_m * math.sqrt(0.5))) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 5.3e+79) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0)))))) * Float64((Float64(A + Float64(C + hypot(B_m, Float64(A - C)))) ^ 0.5) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)))); else tmp = Float64(Float64(sqrt(F) * sqrt(Float64(A + hypot(B_m, A)))) * Float64(-1.0 / Float64(B_m * sqrt(0.5)))); 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+79) tmp = sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (((A + (C + hypot(B_m, (A - C)))) ^ 0.5) / (((4.0 * A) * C) - (B_m * B_m))); else tmp = (sqrt(F) * sqrt((A + hypot(B_m, A)))) * (-1.0 / (B_m * sqrt(0.5))); 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+79], N[(N[Sqrt[N[(2.0 * N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Power[N[(A + N[(C + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[F], $MachinePrecision] * N[Sqrt[N[(A + N[Sqrt[B$95$m ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(-1.0 / N[(B$95$m * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 5.3 \cdot 10^{+79}:\\
\;\;\;\;\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right)\right)} \cdot \frac{{\left(A + \left(C + \mathsf{hypot}\left(B\_m, A - C\right)\right)\right)}^{0.5}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\left(\sqrt{F} \cdot \sqrt{A + \mathsf{hypot}\left(B\_m, A\right)}\right) \cdot \frac{-1}{B\_m \cdot \sqrt{0.5}}\\
\end{array}
\end{array}
if B < 5.29999999999999978e79Initial program 26.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified30.5%
pow1/2N/A
unpow-prod-downN/A
associate-/l*N/A
*-lowering-*.f64N/A
Applied egg-rr34.0%
if 5.29999999999999978e79 < B Initial program 5.9%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6447.3%
Simplified47.3%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6470.5%
Applied egg-rr70.5%
clear-numN/A
div-invN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
pow1/2N/A
pow-flipN/A
metadata-evalN/A
metadata-evalN/A
pow-lowering-pow.f64N/A
metadata-eval70.5%
Applied egg-rr70.5%
Taylor expanded in B around 0
/-lowering-/.f64N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f6470.6%
Simplified70.6%
Final simplification41.9%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 6.5e+79)
(*
(sqrt (* 2.0 (* F (+ (* B_m B_m) (* C (* A -4.0))))))
(/
(pow (+ A (+ C (hypot B_m (- A C)))) 0.5)
(- (* (* 4.0 A) C) (* B_m B_m))))
(* (* (sqrt F) (sqrt (+ A (hypot B_m A)))) (/ (sqrt 2.0) (- 0.0 B_m)))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 6.5e+79) {
tmp = sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (pow((A + (C + hypot(B_m, (A - C)))), 0.5) / (((4.0 * A) * C) - (B_m * B_m)));
} else {
tmp = (sqrt(F) * sqrt((A + hypot(B_m, A)))) * (sqrt(2.0) / (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 <= 6.5e+79) {
tmp = Math.sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (Math.pow((A + (C + Math.hypot(B_m, (A - C)))), 0.5) / (((4.0 * A) * C) - (B_m * B_m)));
} else {
tmp = (Math.sqrt(F) * Math.sqrt((A + Math.hypot(B_m, A)))) * (Math.sqrt(2.0) / (0.0 - B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 6.5e+79: tmp = math.sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (math.pow((A + (C + math.hypot(B_m, (A - C)))), 0.5) / (((4.0 * A) * C) - (B_m * B_m))) else: tmp = (math.sqrt(F) * math.sqrt((A + math.hypot(B_m, A)))) * (math.sqrt(2.0) / (0.0 - B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 6.5e+79) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0)))))) * Float64((Float64(A + Float64(C + hypot(B_m, Float64(A - C)))) ^ 0.5) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)))); else tmp = Float64(Float64(sqrt(F) * sqrt(Float64(A + hypot(B_m, A)))) * Float64(sqrt(2.0) / 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 <= 6.5e+79) tmp = sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (((A + (C + hypot(B_m, (A - C)))) ^ 0.5) / (((4.0 * A) * C) - (B_m * B_m))); else tmp = (sqrt(F) * sqrt((A + hypot(B_m, A)))) * (sqrt(2.0) / (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, 6.5e+79], N[(N[Sqrt[N[(2.0 * N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Power[N[(A + N[(C + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[F], $MachinePrecision] * N[Sqrt[N[(A + N[Sqrt[B$95$m ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * N[(N[Sqrt[2.0], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 6.5 \cdot 10^{+79}:\\
\;\;\;\;\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right)\right)} \cdot \frac{{\left(A + \left(C + \mathsf{hypot}\left(B\_m, A - C\right)\right)\right)}^{0.5}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\left(\sqrt{F} \cdot \sqrt{A + \mathsf{hypot}\left(B\_m, A\right)}\right) \cdot \frac{\sqrt{2}}{0 - B\_m}\\
\end{array}
\end{array}
if B < 6.49999999999999954e79Initial program 26.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified30.5%
pow1/2N/A
unpow-prod-downN/A
associate-/l*N/A
*-lowering-*.f64N/A
Applied egg-rr34.0%
if 6.49999999999999954e79 < B Initial program 5.9%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6447.3%
Simplified47.3%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6470.5%
Applied egg-rr70.5%
mul-1-negN/A
neg-lowering-neg.f64N/A
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6470.5%
Applied egg-rr70.5%
Final simplification41.9%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (hypot B_m (- A C))))
(if (<= B_m 7e+40)
(*
(sqrt (* 2.0 (* F (+ (* B_m B_m) (* C (* A -4.0))))))
(/ (pow (+ A (+ C t_0)) 0.5) (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= B_m 7.6e+124)
(-
0.0
(*
(sqrt F)
(pow
(* 2.0 (/ (+ (+ A C) t_0) (+ (* B_m B_m) (* A (* C -4.0)))))
0.5)))
(* (/ (sqrt 2.0) B_m) (* (sqrt F) (- 0.0 (sqrt B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = hypot(B_m, (A - C));
double tmp;
if (B_m <= 7e+40) {
tmp = sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (pow((A + (C + t_0)), 0.5) / (((4.0 * A) * C) - (B_m * B_m)));
} else if (B_m <= 7.6e+124) {
tmp = 0.0 - (sqrt(F) * pow((2.0 * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0))))), 0.5));
} else {
tmp = (sqrt(2.0) / B_m) * (sqrt(F) * (0.0 - sqrt(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 = Math.hypot(B_m, (A - C));
double tmp;
if (B_m <= 7e+40) {
tmp = Math.sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (Math.pow((A + (C + t_0)), 0.5) / (((4.0 * A) * C) - (B_m * B_m)));
} else if (B_m <= 7.6e+124) {
tmp = 0.0 - (Math.sqrt(F) * Math.pow((2.0 * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0))))), 0.5));
} else {
tmp = (Math.sqrt(2.0) / B_m) * (Math.sqrt(F) * (0.0 - Math.sqrt(B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = math.hypot(B_m, (A - C)) tmp = 0 if B_m <= 7e+40: tmp = math.sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (math.pow((A + (C + t_0)), 0.5) / (((4.0 * A) * C) - (B_m * B_m))) elif B_m <= 7.6e+124: tmp = 0.0 - (math.sqrt(F) * math.pow((2.0 * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0))))), 0.5)) else: tmp = (math.sqrt(2.0) / B_m) * (math.sqrt(F) * (0.0 - math.sqrt(B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = hypot(B_m, Float64(A - C)) tmp = 0.0 if (B_m <= 7e+40) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0)))))) * Float64((Float64(A + Float64(C + t_0)) ^ 0.5) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)))); elseif (B_m <= 7.6e+124) tmp = Float64(0.0 - Float64(sqrt(F) * (Float64(2.0 * Float64(Float64(Float64(A + C) + t_0) / Float64(Float64(B_m * B_m) + Float64(A * Float64(C * -4.0))))) ^ 0.5))); else tmp = Float64(Float64(sqrt(2.0) / B_m) * Float64(sqrt(F) * Float64(0.0 - sqrt(B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = hypot(B_m, (A - C)); tmp = 0.0; if (B_m <= 7e+40) tmp = sqrt((2.0 * (F * ((B_m * B_m) + (C * (A * -4.0)))))) * (((A + (C + t_0)) ^ 0.5) / (((4.0 * A) * C) - (B_m * B_m))); elseif (B_m <= 7.6e+124) tmp = 0.0 - (sqrt(F) * ((2.0 * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0))))) ^ 0.5)); else tmp = (sqrt(2.0) / B_m) * (sqrt(F) * (0.0 - sqrt(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[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, If[LessEqual[B$95$m, 7e+40], N[(N[Sqrt[N[(2.0 * N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[Power[N[(A + N[(C + t$95$0), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 7.6e+124], N[(0.0 - N[(N[Sqrt[F], $MachinePrecision] * N[Power[N[(2.0 * N[(N[(N[(A + C), $MachinePrecision] + t$95$0), $MachinePrecision] / N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[2.0], $MachinePrecision] / B$95$m), $MachinePrecision] * N[(N[Sqrt[F], $MachinePrecision] * N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \mathsf{hypot}\left(B\_m, A - C\right)\\
\mathbf{if}\;B\_m \leq 7 \cdot 10^{+40}:\\
\;\;\;\;\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right)\right)} \cdot \frac{{\left(A + \left(C + t\_0\right)\right)}^{0.5}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;B\_m \leq 7.6 \cdot 10^{+124}:\\
\;\;\;\;0 - \sqrt{F} \cdot {\left(2 \cdot \frac{\left(A + C\right) + t\_0}{B\_m \cdot B\_m + A \cdot \left(C \cdot -4\right)}\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{2}}{B\_m} \cdot \left(\sqrt{F} \cdot \left(0 - \sqrt{B\_m}\right)\right)\\
\end{array}
\end{array}
if B < 6.9999999999999998e40Initial program 26.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified30.6%
pow1/2N/A
unpow-prod-downN/A
associate-/l*N/A
*-lowering-*.f64N/A
Applied egg-rr34.3%
if 6.9999999999999998e40 < B < 7.5999999999999997e124Initial program 22.7%
Taylor expanded in F around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
Simplified39.2%
sqrt-unprodN/A
pow1/2N/A
associate-/l*N/A
associate-*l*N/A
unpow-prod-downN/A
pow1/2N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
Applied egg-rr48.9%
if 7.5999999999999997e124 < B Initial program 2.4%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6449.1%
Simplified49.1%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6478.2%
Applied egg-rr78.2%
Taylor expanded in A around 0
sqrt-lowering-sqrt.f6470.4%
Simplified70.4%
Final simplification41.6%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (hypot B_m (- A C))))
(if (<= B_m 0.00155)
(/
(*
(sqrt (* F (+ (* B_m B_m) (* C (* A -4.0)))))
(sqrt (* 2.0 (+ A (+ C t_0)))))
(- (* (* 4.0 A) C) (* B_m B_m)))
(if (<= B_m 7.6e+124)
(-
0.0
(*
(sqrt F)
(pow
(* 2.0 (/ (+ (+ A C) t_0) (+ (* B_m B_m) (* A (* C -4.0)))))
0.5)))
(* (/ (sqrt 2.0) B_m) (* (sqrt F) (- 0.0 (sqrt B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = hypot(B_m, (A - C));
double tmp;
if (B_m <= 0.00155) {
tmp = (sqrt((F * ((B_m * B_m) + (C * (A * -4.0))))) * sqrt((2.0 * (A + (C + t_0))))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (B_m <= 7.6e+124) {
tmp = 0.0 - (sqrt(F) * pow((2.0 * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0))))), 0.5));
} else {
tmp = (sqrt(2.0) / B_m) * (sqrt(F) * (0.0 - sqrt(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 = Math.hypot(B_m, (A - C));
double tmp;
if (B_m <= 0.00155) {
tmp = (Math.sqrt((F * ((B_m * B_m) + (C * (A * -4.0))))) * Math.sqrt((2.0 * (A + (C + t_0))))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (B_m <= 7.6e+124) {
tmp = 0.0 - (Math.sqrt(F) * Math.pow((2.0 * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0))))), 0.5));
} else {
tmp = (Math.sqrt(2.0) / B_m) * (Math.sqrt(F) * (0.0 - Math.sqrt(B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = math.hypot(B_m, (A - C)) tmp = 0 if B_m <= 0.00155: tmp = (math.sqrt((F * ((B_m * B_m) + (C * (A * -4.0))))) * math.sqrt((2.0 * (A + (C + t_0))))) / (((4.0 * A) * C) - (B_m * B_m)) elif B_m <= 7.6e+124: tmp = 0.0 - (math.sqrt(F) * math.pow((2.0 * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0))))), 0.5)) else: tmp = (math.sqrt(2.0) / B_m) * (math.sqrt(F) * (0.0 - math.sqrt(B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = hypot(B_m, Float64(A - C)) tmp = 0.0 if (B_m <= 0.00155) tmp = Float64(Float64(sqrt(Float64(F * Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0))))) * sqrt(Float64(2.0 * Float64(A + Float64(C + t_0))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); elseif (B_m <= 7.6e+124) tmp = Float64(0.0 - Float64(sqrt(F) * (Float64(2.0 * Float64(Float64(Float64(A + C) + t_0) / Float64(Float64(B_m * B_m) + Float64(A * Float64(C * -4.0))))) ^ 0.5))); else tmp = Float64(Float64(sqrt(2.0) / B_m) * Float64(sqrt(F) * Float64(0.0 - sqrt(B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = hypot(B_m, (A - C)); tmp = 0.0; if (B_m <= 0.00155) tmp = (sqrt((F * ((B_m * B_m) + (C * (A * -4.0))))) * sqrt((2.0 * (A + (C + t_0))))) / (((4.0 * A) * C) - (B_m * B_m)); elseif (B_m <= 7.6e+124) tmp = 0.0 - (sqrt(F) * ((2.0 * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0))))) ^ 0.5)); else tmp = (sqrt(2.0) / B_m) * (sqrt(F) * (0.0 - sqrt(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[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, If[LessEqual[B$95$m, 0.00155], N[(N[(N[Sqrt[N[(F * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[Sqrt[N[(2.0 * N[(A + N[(C + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 7.6e+124], N[(0.0 - N[(N[Sqrt[F], $MachinePrecision] * N[Power[N[(2.0 * N[(N[(N[(A + C), $MachinePrecision] + t$95$0), $MachinePrecision] / N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[2.0], $MachinePrecision] / B$95$m), $MachinePrecision] * N[(N[Sqrt[F], $MachinePrecision] * N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \mathsf{hypot}\left(B\_m, A - C\right)\\
\mathbf{if}\;B\_m \leq 0.00155:\\
\;\;\;\;\frac{\sqrt{F \cdot \left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right)} \cdot \sqrt{2 \cdot \left(A + \left(C + t\_0\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;B\_m \leq 7.6 \cdot 10^{+124}:\\
\;\;\;\;0 - \sqrt{F} \cdot {\left(2 \cdot \frac{\left(A + C\right) + t\_0}{B\_m \cdot B\_m + A \cdot \left(C \cdot -4\right)}\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{2}}{B\_m} \cdot \left(\sqrt{F} \cdot \left(0 - \sqrt{B\_m}\right)\right)\\
\end{array}
\end{array}
if B < 0.00154999999999999995Initial program 25.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified30.0%
pow2N/A
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
sqrt-prodN/A
pow1/2N/A
*-lowering-*.f64N/A
Applied egg-rr33.7%
if 0.00154999999999999995 < B < 7.5999999999999997e124Initial program 29.4%
Taylor expanded in F around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
Simplified42.1%
sqrt-unprodN/A
pow1/2N/A
associate-/l*N/A
associate-*l*N/A
unpow-prod-downN/A
pow1/2N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
Applied egg-rr49.4%
if 7.5999999999999997e124 < B Initial program 2.4%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6449.1%
Simplified49.1%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6478.2%
Applied egg-rr78.2%
Taylor expanded in A around 0
sqrt-lowering-sqrt.f6470.4%
Simplified70.4%
Final simplification41.6%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (+ (+ A C) (hypot B_m (- A C)))))
(if (<= B_m 8.8e-161)
(/
(* (sqrt t_0) (sqrt (* A (* -8.0 (* C F)))))
(- (* (* 4.0 A) C) (* B_m B_m)))
(if (<= B_m 7.6e+124)
(-
0.0
(*
(sqrt F)
(pow (* 2.0 (/ t_0 (+ (* B_m B_m) (* A (* C -4.0))))) 0.5)))
(* (/ (sqrt 2.0) B_m) (* (sqrt F) (- 0.0 (sqrt B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = (A + C) + hypot(B_m, (A - C));
double tmp;
if (B_m <= 8.8e-161) {
tmp = (sqrt(t_0) * sqrt((A * (-8.0 * (C * F))))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (B_m <= 7.6e+124) {
tmp = 0.0 - (sqrt(F) * pow((2.0 * (t_0 / ((B_m * B_m) + (A * (C * -4.0))))), 0.5));
} else {
tmp = (sqrt(2.0) / B_m) * (sqrt(F) * (0.0 - sqrt(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 = (A + C) + Math.hypot(B_m, (A - C));
double tmp;
if (B_m <= 8.8e-161) {
tmp = (Math.sqrt(t_0) * Math.sqrt((A * (-8.0 * (C * F))))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (B_m <= 7.6e+124) {
tmp = 0.0 - (Math.sqrt(F) * Math.pow((2.0 * (t_0 / ((B_m * B_m) + (A * (C * -4.0))))), 0.5));
} else {
tmp = (Math.sqrt(2.0) / B_m) * (Math.sqrt(F) * (0.0 - Math.sqrt(B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = (A + C) + math.hypot(B_m, (A - C)) tmp = 0 if B_m <= 8.8e-161: tmp = (math.sqrt(t_0) * math.sqrt((A * (-8.0 * (C * F))))) / (((4.0 * A) * C) - (B_m * B_m)) elif B_m <= 7.6e+124: tmp = 0.0 - (math.sqrt(F) * math.pow((2.0 * (t_0 / ((B_m * B_m) + (A * (C * -4.0))))), 0.5)) else: tmp = (math.sqrt(2.0) / B_m) * (math.sqrt(F) * (0.0 - math.sqrt(B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(A + C) + hypot(B_m, Float64(A - C))) tmp = 0.0 if (B_m <= 8.8e-161) tmp = Float64(Float64(sqrt(t_0) * sqrt(Float64(A * Float64(-8.0 * Float64(C * F))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); elseif (B_m <= 7.6e+124) tmp = Float64(0.0 - Float64(sqrt(F) * (Float64(2.0 * Float64(t_0 / Float64(Float64(B_m * B_m) + Float64(A * Float64(C * -4.0))))) ^ 0.5))); else tmp = Float64(Float64(sqrt(2.0) / B_m) * Float64(sqrt(F) * Float64(0.0 - sqrt(B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = (A + C) + hypot(B_m, (A - C)); tmp = 0.0; if (B_m <= 8.8e-161) tmp = (sqrt(t_0) * sqrt((A * (-8.0 * (C * F))))) / (((4.0 * A) * C) - (B_m * B_m)); elseif (B_m <= 7.6e+124) tmp = 0.0 - (sqrt(F) * ((2.0 * (t_0 / ((B_m * B_m) + (A * (C * -4.0))))) ^ 0.5)); else tmp = (sqrt(2.0) / B_m) * (sqrt(F) * (0.0 - sqrt(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[(A + C), $MachinePrecision] + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 8.8e-161], N[(N[(N[Sqrt[t$95$0], $MachinePrecision] * N[Sqrt[N[(A * N[(-8.0 * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 7.6e+124], N[(0.0 - N[(N[Sqrt[F], $MachinePrecision] * N[Power[N[(2.0 * N[(t$95$0 / N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[2.0], $MachinePrecision] / B$95$m), $MachinePrecision] * N[(N[Sqrt[F], $MachinePrecision] * N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \left(A + C\right) + \mathsf{hypot}\left(B\_m, A - C\right)\\
\mathbf{if}\;B\_m \leq 8.8 \cdot 10^{-161}:\\
\;\;\;\;\frac{\sqrt{t\_0} \cdot \sqrt{A \cdot \left(-8 \cdot \left(C \cdot F\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;B\_m \leq 7.6 \cdot 10^{+124}:\\
\;\;\;\;0 - \sqrt{F} \cdot {\left(2 \cdot \frac{t\_0}{B\_m \cdot B\_m + A \cdot \left(C \cdot -4\right)}\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{2}}{B\_m} \cdot \left(\sqrt{F} \cdot \left(0 - \sqrt{B\_m}\right)\right)\\
\end{array}
\end{array}
if B < 8.80000000000000009e-161Initial program 23.8%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified28.5%
Taylor expanded in B around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6419.5%
Simplified19.5%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
--lowering--.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
*-commutativeN/A
Applied egg-rr19.6%
if 8.80000000000000009e-161 < B < 7.5999999999999997e124Initial program 31.5%
Taylor expanded in F around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
Simplified38.2%
sqrt-unprodN/A
pow1/2N/A
associate-/l*N/A
associate-*l*N/A
unpow-prod-downN/A
pow1/2N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
Applied egg-rr48.1%
if 7.5999999999999997e124 < B Initial program 2.4%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6449.1%
Simplified49.1%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6478.2%
Applied egg-rr78.2%
Taylor expanded in A around 0
sqrt-lowering-sqrt.f6470.4%
Simplified70.4%
Final simplification35.1%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (+ (+ A C) (hypot B_m (- A C)))))
(if (<= B_m 2.8e-221)
(/ (sqrt (* t_0 (* -8.0 (* F (* A C))))) (- (* (* 4.0 A) C) (* B_m B_m)))
(if (<= B_m 7.6e+124)
(-
0.0
(*
(sqrt F)
(pow (* 2.0 (/ t_0 (+ (* B_m B_m) (* A (* C -4.0))))) 0.5)))
(* (/ (sqrt 2.0) B_m) (* (sqrt F) (- 0.0 (sqrt B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = (A + C) + hypot(B_m, (A - C));
double tmp;
if (B_m <= 2.8e-221) {
tmp = sqrt((t_0 * (-8.0 * (F * (A * C))))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (B_m <= 7.6e+124) {
tmp = 0.0 - (sqrt(F) * pow((2.0 * (t_0 / ((B_m * B_m) + (A * (C * -4.0))))), 0.5));
} else {
tmp = (sqrt(2.0) / B_m) * (sqrt(F) * (0.0 - sqrt(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 = (A + C) + Math.hypot(B_m, (A - C));
double tmp;
if (B_m <= 2.8e-221) {
tmp = Math.sqrt((t_0 * (-8.0 * (F * (A * C))))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (B_m <= 7.6e+124) {
tmp = 0.0 - (Math.sqrt(F) * Math.pow((2.0 * (t_0 / ((B_m * B_m) + (A * (C * -4.0))))), 0.5));
} else {
tmp = (Math.sqrt(2.0) / B_m) * (Math.sqrt(F) * (0.0 - Math.sqrt(B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = (A + C) + math.hypot(B_m, (A - C)) tmp = 0 if B_m <= 2.8e-221: tmp = math.sqrt((t_0 * (-8.0 * (F * (A * C))))) / (((4.0 * A) * C) - (B_m * B_m)) elif B_m <= 7.6e+124: tmp = 0.0 - (math.sqrt(F) * math.pow((2.0 * (t_0 / ((B_m * B_m) + (A * (C * -4.0))))), 0.5)) else: tmp = (math.sqrt(2.0) / B_m) * (math.sqrt(F) * (0.0 - math.sqrt(B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(A + C) + hypot(B_m, Float64(A - C))) tmp = 0.0 if (B_m <= 2.8e-221) tmp = Float64(sqrt(Float64(t_0 * Float64(-8.0 * Float64(F * Float64(A * C))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); elseif (B_m <= 7.6e+124) tmp = Float64(0.0 - Float64(sqrt(F) * (Float64(2.0 * Float64(t_0 / Float64(Float64(B_m * B_m) + Float64(A * Float64(C * -4.0))))) ^ 0.5))); else tmp = Float64(Float64(sqrt(2.0) / B_m) * Float64(sqrt(F) * Float64(0.0 - sqrt(B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = (A + C) + hypot(B_m, (A - C)); tmp = 0.0; if (B_m <= 2.8e-221) tmp = sqrt((t_0 * (-8.0 * (F * (A * C))))) / (((4.0 * A) * C) - (B_m * B_m)); elseif (B_m <= 7.6e+124) tmp = 0.0 - (sqrt(F) * ((2.0 * (t_0 / ((B_m * B_m) + (A * (C * -4.0))))) ^ 0.5)); else tmp = (sqrt(2.0) / B_m) * (sqrt(F) * (0.0 - sqrt(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[(A + C), $MachinePrecision] + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 2.8e-221], N[(N[Sqrt[N[(t$95$0 * N[(-8.0 * N[(F * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 7.6e+124], N[(0.0 - N[(N[Sqrt[F], $MachinePrecision] * N[Power[N[(2.0 * N[(t$95$0 / N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[2.0], $MachinePrecision] / B$95$m), $MachinePrecision] * N[(N[Sqrt[F], $MachinePrecision] * N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \left(A + C\right) + \mathsf{hypot}\left(B\_m, A - C\right)\\
\mathbf{if}\;B\_m \leq 2.8 \cdot 10^{-221}:\\
\;\;\;\;\frac{\sqrt{t\_0 \cdot \left(-8 \cdot \left(F \cdot \left(A \cdot C\right)\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;B\_m \leq 7.6 \cdot 10^{+124}:\\
\;\;\;\;0 - \sqrt{F} \cdot {\left(2 \cdot \frac{t\_0}{B\_m \cdot B\_m + A \cdot \left(C \cdot -4\right)}\right)}^{0.5}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{2}}{B\_m} \cdot \left(\sqrt{F} \cdot \left(0 - \sqrt{B\_m}\right)\right)\\
\end{array}
\end{array}
if B < 2.80000000000000019e-221Initial program 24.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified29.5%
Taylor expanded in B around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6419.5%
Simplified19.5%
if 2.80000000000000019e-221 < B < 7.5999999999999997e124Initial program 29.1%
Taylor expanded in F around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
Simplified31.0%
sqrt-unprodN/A
pow1/2N/A
associate-/l*N/A
associate-*l*N/A
unpow-prod-downN/A
pow1/2N/A
*-lowering-*.f64N/A
sqrt-lowering-sqrt.f64N/A
Applied egg-rr42.5%
if 7.5999999999999997e124 < B Initial program 2.4%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6449.1%
Simplified49.1%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6478.2%
Applied egg-rr78.2%
Taylor expanded in A around 0
sqrt-lowering-sqrt.f6470.4%
Simplified70.4%
Final simplification35.1%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (hypot B_m (- A C))))
(if (<= B_m 3.3e+36)
(/
(sqrt (* (* (+ (* B_m B_m) (* C (* A -4.0))) (+ A (+ C t_0))) (* 2.0 F)))
(- (* (* 4.0 A) C) (* B_m B_m)))
(if (<= B_m 4e+100)
(-
0.0
(*
(sqrt 2.0)
(sqrt (* F (/ (+ (+ A C) t_0) (+ (* B_m B_m) (* A (* C -4.0))))))))
(* (/ (sqrt 2.0) B_m) (* (sqrt F) (- 0.0 (sqrt B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = hypot(B_m, (A - C));
double tmp;
if (B_m <= 3.3e+36) {
tmp = sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (A + (C + t_0))) * (2.0 * F))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (B_m <= 4e+100) {
tmp = 0.0 - (sqrt(2.0) * sqrt((F * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0)))))));
} else {
tmp = (sqrt(2.0) / B_m) * (sqrt(F) * (0.0 - sqrt(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 = Math.hypot(B_m, (A - C));
double tmp;
if (B_m <= 3.3e+36) {
tmp = Math.sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (A + (C + t_0))) * (2.0 * F))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (B_m <= 4e+100) {
tmp = 0.0 - (Math.sqrt(2.0) * Math.sqrt((F * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0)))))));
} else {
tmp = (Math.sqrt(2.0) / B_m) * (Math.sqrt(F) * (0.0 - Math.sqrt(B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = math.hypot(B_m, (A - C)) tmp = 0 if B_m <= 3.3e+36: tmp = math.sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (A + (C + t_0))) * (2.0 * F))) / (((4.0 * A) * C) - (B_m * B_m)) elif B_m <= 4e+100: tmp = 0.0 - (math.sqrt(2.0) * math.sqrt((F * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0))))))) else: tmp = (math.sqrt(2.0) / B_m) * (math.sqrt(F) * (0.0 - math.sqrt(B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = hypot(B_m, Float64(A - C)) tmp = 0.0 if (B_m <= 3.3e+36) tmp = Float64(sqrt(Float64(Float64(Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0))) * Float64(A + Float64(C + t_0))) * Float64(2.0 * F))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); elseif (B_m <= 4e+100) tmp = Float64(0.0 - Float64(sqrt(2.0) * sqrt(Float64(F * Float64(Float64(Float64(A + C) + t_0) / Float64(Float64(B_m * B_m) + Float64(A * Float64(C * -4.0)))))))); else tmp = Float64(Float64(sqrt(2.0) / B_m) * Float64(sqrt(F) * Float64(0.0 - sqrt(B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = hypot(B_m, (A - C)); tmp = 0.0; if (B_m <= 3.3e+36) tmp = sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (A + (C + t_0))) * (2.0 * F))) / (((4.0 * A) * C) - (B_m * B_m)); elseif (B_m <= 4e+100) tmp = 0.0 - (sqrt(2.0) * sqrt((F * (((A + C) + t_0) / ((B_m * B_m) + (A * (C * -4.0))))))); else tmp = (sqrt(2.0) / B_m) * (sqrt(F) * (0.0 - sqrt(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[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]}, If[LessEqual[B$95$m, 3.3e+36], N[(N[Sqrt[N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(A + N[(C + t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(2.0 * F), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 4e+100], N[(0.0 - N[(N[Sqrt[2.0], $MachinePrecision] * N[Sqrt[N[(F * N[(N[(N[(A + C), $MachinePrecision] + t$95$0), $MachinePrecision] / N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(A * N[(C * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[2.0], $MachinePrecision] / B$95$m), $MachinePrecision] * N[(N[Sqrt[F], $MachinePrecision] * N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \mathsf{hypot}\left(B\_m, A - C\right)\\
\mathbf{if}\;B\_m \leq 3.3 \cdot 10^{+36}:\\
\;\;\;\;\frac{\sqrt{\left(\left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right) \cdot \left(A + \left(C + t\_0\right)\right)\right) \cdot \left(2 \cdot F\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;B\_m \leq 4 \cdot 10^{+100}:\\
\;\;\;\;0 - \sqrt{2} \cdot \sqrt{F \cdot \frac{\left(A + C\right) + t\_0}{B\_m \cdot B\_m + A \cdot \left(C \cdot -4\right)}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{2}}{B\_m} \cdot \left(\sqrt{F} \cdot \left(0 - \sqrt{B\_m}\right)\right)\\
\end{array}
\end{array}
if B < 3.2999999999999999e36Initial program 25.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified30.3%
*-commutativeN/A
pow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr30.1%
if 3.2999999999999999e36 < B < 4.00000000000000006e100Initial program 29.6%
Taylor expanded in F around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
Simplified45.1%
associate-/l*N/A
*-commutativeN/A
*-lowering-*.f64N/A
Applied egg-rr52.1%
if 4.00000000000000006e100 < B Initial program 4.4%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6449.3%
Simplified49.3%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6474.9%
Applied egg-rr74.9%
Taylor expanded in A around 0
sqrt-lowering-sqrt.f6466.5%
Simplified66.5%
Final simplification38.4%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 3.8e+76)
(/
(sqrt
(*
(* (+ (* B_m B_m) (* C (* A -4.0))) (+ A (+ C (hypot B_m (- A C)))))
(* 2.0 F)))
(- (* (* 4.0 A) C) (* B_m B_m)))
(* (/ (sqrt 2.0) B_m) (* (sqrt F) (- 0.0 (sqrt B_m))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 3.8e+76) {
tmp = sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (A + (C + hypot(B_m, (A - C))))) * (2.0 * F))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = (sqrt(2.0) / B_m) * (sqrt(F) * (0.0 - sqrt(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 <= 3.8e+76) {
tmp = Math.sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (A + (C + Math.hypot(B_m, (A - C))))) * (2.0 * F))) / (((4.0 * A) * C) - (B_m * B_m));
} else {
tmp = (Math.sqrt(2.0) / B_m) * (Math.sqrt(F) * (0.0 - Math.sqrt(B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 3.8e+76: tmp = math.sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (A + (C + math.hypot(B_m, (A - C))))) * (2.0 * F))) / (((4.0 * A) * C) - (B_m * B_m)) else: tmp = (math.sqrt(2.0) / B_m) * (math.sqrt(F) * (0.0 - math.sqrt(B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 3.8e+76) tmp = Float64(sqrt(Float64(Float64(Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0))) * Float64(A + Float64(C + hypot(B_m, Float64(A - C))))) * Float64(2.0 * F))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); else tmp = Float64(Float64(sqrt(2.0) / B_m) * Float64(sqrt(F) * Float64(0.0 - sqrt(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.8e+76) tmp = sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (A + (C + hypot(B_m, (A - C))))) * (2.0 * F))) / (((4.0 * A) * C) - (B_m * B_m)); else tmp = (sqrt(2.0) / B_m) * (sqrt(F) * (0.0 - sqrt(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.8e+76], N[(N[Sqrt[N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(A + N[(C + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(2.0 * F), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Sqrt[2.0], $MachinePrecision] / B$95$m), $MachinePrecision] * N[(N[Sqrt[F], $MachinePrecision] * N[(0.0 - N[Sqrt[B$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 3.8 \cdot 10^{+76}:\\
\;\;\;\;\frac{\sqrt{\left(\left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right) \cdot \left(A + \left(C + \mathsf{hypot}\left(B\_m, A - C\right)\right)\right)\right) \cdot \left(2 \cdot F\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{2}}{B\_m} \cdot \left(\sqrt{F} \cdot \left(0 - \sqrt{B\_m}\right)\right)\\
\end{array}
\end{array}
if B < 3.80000000000000024e76Initial program 26.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified30.5%
*-commutativeN/A
pow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr30.4%
if 3.80000000000000024e76 < B Initial program 5.9%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6447.3%
Simplified47.3%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6470.5%
Applied egg-rr70.5%
Taylor expanded in A around 0
sqrt-lowering-sqrt.f6462.8%
Simplified62.8%
Final simplification37.3%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (* (* 4.0 A) C)))
(if (<= F 7e-294)
(/
(sqrt
(* (+ (+ A C) (hypot B_m (- A C))) (* (* 2.0 F) (- (* B_m B_m) t_0))))
(- t_0 (* B_m B_m)))
(if (<= F 1.4e+46)
(* (pow (* 2.0 (* F (+ A (hypot B_m A)))) 0.5) (/ -1.0 B_m))
(/ 1.0 (* (sqrt (/ B_m F)) (/ -1.0 (sqrt 2.0))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = (4.0 * A) * C;
double tmp;
if (F <= 7e-294) {
tmp = sqrt((((A + C) + hypot(B_m, (A - C))) * ((2.0 * F) * ((B_m * B_m) - t_0)))) / (t_0 - (B_m * B_m));
} else if (F <= 1.4e+46) {
tmp = pow((2.0 * (F * (A + hypot(B_m, A)))), 0.5) * (-1.0 / B_m);
} else {
tmp = 1.0 / (sqrt((B_m / F)) * (-1.0 / sqrt(2.0)));
}
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;
double tmp;
if (F <= 7e-294) {
tmp = Math.sqrt((((A + C) + Math.hypot(B_m, (A - C))) * ((2.0 * F) * ((B_m * B_m) - t_0)))) / (t_0 - (B_m * B_m));
} else if (F <= 1.4e+46) {
tmp = Math.pow((2.0 * (F * (A + Math.hypot(B_m, A)))), 0.5) * (-1.0 / B_m);
} else {
tmp = 1.0 / (Math.sqrt((B_m / F)) * (-1.0 / Math.sqrt(2.0)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = (4.0 * A) * C tmp = 0 if F <= 7e-294: tmp = math.sqrt((((A + C) + math.hypot(B_m, (A - C))) * ((2.0 * F) * ((B_m * B_m) - t_0)))) / (t_0 - (B_m * B_m)) elif F <= 1.4e+46: tmp = math.pow((2.0 * (F * (A + math.hypot(B_m, A)))), 0.5) * (-1.0 / B_m) else: tmp = 1.0 / (math.sqrt((B_m / F)) * (-1.0 / math.sqrt(2.0))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(4.0 * A) * C) tmp = 0.0 if (F <= 7e-294) tmp = Float64(sqrt(Float64(Float64(Float64(A + C) + hypot(B_m, Float64(A - C))) * Float64(Float64(2.0 * F) * Float64(Float64(B_m * B_m) - t_0)))) / Float64(t_0 - Float64(B_m * B_m))); elseif (F <= 1.4e+46) tmp = Float64((Float64(2.0 * Float64(F * Float64(A + hypot(B_m, A)))) ^ 0.5) * Float64(-1.0 / B_m)); else tmp = Float64(1.0 / Float64(sqrt(Float64(B_m / F)) * Float64(-1.0 / sqrt(2.0)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = (4.0 * A) * C; tmp = 0.0; if (F <= 7e-294) tmp = sqrt((((A + C) + hypot(B_m, (A - C))) * ((2.0 * F) * ((B_m * B_m) - t_0)))) / (t_0 - (B_m * B_m)); elseif (F <= 1.4e+46) tmp = ((2.0 * (F * (A + hypot(B_m, A)))) ^ 0.5) * (-1.0 / B_m); else tmp = 1.0 / (sqrt((B_m / F)) * (-1.0 / sqrt(2.0))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision]}, If[LessEqual[F, 7e-294], N[(N[Sqrt[N[(N[(N[(A + C), $MachinePrecision] + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 * F), $MachinePrecision] * N[(N[(B$95$m * B$95$m), $MachinePrecision] - t$95$0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(t$95$0 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 1.4e+46], N[(N[Power[N[(2.0 * N[(F * N[(A + N[Sqrt[B$95$m ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] * N[(-1.0 / B$95$m), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[Sqrt[N[(B$95$m / F), $MachinePrecision]], $MachinePrecision] * N[(-1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \left(4 \cdot A\right) \cdot C\\
\mathbf{if}\;F \leq 7 \cdot 10^{-294}:\\
\;\;\;\;\frac{\sqrt{\left(\left(A + C\right) + \mathsf{hypot}\left(B\_m, A - C\right)\right) \cdot \left(\left(2 \cdot F\right) \cdot \left(B\_m \cdot B\_m - t\_0\right)\right)}}{t\_0 - B\_m \cdot B\_m}\\
\mathbf{elif}\;F \leq 1.4 \cdot 10^{+46}:\\
\;\;\;\;{\left(2 \cdot \left(F \cdot \left(A + \mathsf{hypot}\left(B\_m, A\right)\right)\right)\right)}^{0.5} \cdot \frac{-1}{B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sqrt{\frac{B\_m}{F}} \cdot \frac{-1}{\sqrt{2}}}\\
\end{array}
\end{array}
if F < 7.00000000000000064e-294Initial program 36.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified53.9%
if 7.00000000000000064e-294 < F < 1.40000000000000009e46Initial program 20.4%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6425.4%
Simplified25.4%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6426.8%
Applied egg-rr26.8%
clear-numN/A
div-invN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
pow1/2N/A
pow-flipN/A
metadata-evalN/A
metadata-evalN/A
pow-lowering-pow.f64N/A
metadata-eval26.9%
Applied egg-rr26.9%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
div-invN/A
pow-flipN/A
metadata-evalN/A
pow1/2N/A
associate-*l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
pow1/2N/A
sqrt-unprodN/A
pow1/2N/A
pow-prod-downN/A
Applied egg-rr25.4%
if 1.40000000000000009e46 < F Initial program 19.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified19.2%
Applied egg-rr20.1%
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
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6421.2%
Simplified21.2%
Final simplification27.1%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= F 5.8e-296)
(/
(sqrt
(*
(* (+ (* B_m B_m) (* C (* A -4.0))) (+ A (+ C (hypot B_m (- A C)))))
(* 2.0 F)))
(- (* (* 4.0 A) C) (* B_m B_m)))
(if (<= F 2e+46)
(* (pow (* 2.0 (* F (+ A (hypot B_m A)))) 0.5) (/ -1.0 B_m))
(/ 1.0 (* (sqrt (/ B_m F)) (/ -1.0 (sqrt 2.0)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (F <= 5.8e-296) {
tmp = sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (A + (C + hypot(B_m, (A - C))))) * (2.0 * F))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (F <= 2e+46) {
tmp = pow((2.0 * (F * (A + hypot(B_m, A)))), 0.5) * (-1.0 / B_m);
} else {
tmp = 1.0 / (sqrt((B_m / F)) * (-1.0 / sqrt(2.0)));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (F <= 5.8e-296) {
tmp = Math.sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (A + (C + Math.hypot(B_m, (A - C))))) * (2.0 * F))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (F <= 2e+46) {
tmp = Math.pow((2.0 * (F * (A + Math.hypot(B_m, A)))), 0.5) * (-1.0 / B_m);
} else {
tmp = 1.0 / (Math.sqrt((B_m / F)) * (-1.0 / Math.sqrt(2.0)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if F <= 5.8e-296: tmp = math.sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (A + (C + math.hypot(B_m, (A - C))))) * (2.0 * F))) / (((4.0 * A) * C) - (B_m * B_m)) elif F <= 2e+46: tmp = math.pow((2.0 * (F * (A + math.hypot(B_m, A)))), 0.5) * (-1.0 / B_m) else: tmp = 1.0 / (math.sqrt((B_m / F)) * (-1.0 / math.sqrt(2.0))) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (F <= 5.8e-296) tmp = Float64(sqrt(Float64(Float64(Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0))) * Float64(A + Float64(C + hypot(B_m, Float64(A - C))))) * Float64(2.0 * F))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); elseif (F <= 2e+46) tmp = Float64((Float64(2.0 * Float64(F * Float64(A + hypot(B_m, A)))) ^ 0.5) * Float64(-1.0 / B_m)); else tmp = Float64(1.0 / Float64(sqrt(Float64(B_m / F)) * Float64(-1.0 / sqrt(2.0)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (F <= 5.8e-296) tmp = sqrt(((((B_m * B_m) + (C * (A * -4.0))) * (A + (C + hypot(B_m, (A - C))))) * (2.0 * F))) / (((4.0 * A) * C) - (B_m * B_m)); elseif (F <= 2e+46) tmp = ((2.0 * (F * (A + hypot(B_m, A)))) ^ 0.5) * (-1.0 / B_m); else tmp = 1.0 / (sqrt((B_m / F)) * (-1.0 / sqrt(2.0))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[F, 5.8e-296], N[(N[Sqrt[N[(N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(A + N[(C + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(2.0 * F), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 2e+46], N[(N[Power[N[(2.0 * N[(F * N[(A + N[Sqrt[B$95$m ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] * N[(-1.0 / B$95$m), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[Sqrt[N[(B$95$m / F), $MachinePrecision]], $MachinePrecision] * N[(-1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;F \leq 5.8 \cdot 10^{-296}:\\
\;\;\;\;\frac{\sqrt{\left(\left(B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)\right) \cdot \left(A + \left(C + \mathsf{hypot}\left(B\_m, A - C\right)\right)\right)\right) \cdot \left(2 \cdot F\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;F \leq 2 \cdot 10^{+46}:\\
\;\;\;\;{\left(2 \cdot \left(F \cdot \left(A + \mathsf{hypot}\left(B\_m, A\right)\right)\right)\right)}^{0.5} \cdot \frac{-1}{B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sqrt{\frac{B\_m}{F}} \cdot \frac{-1}{\sqrt{2}}}\\
\end{array}
\end{array}
if F < 5.79999999999999965e-296Initial program 38.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified55.5%
*-commutativeN/A
pow2N/A
associate-*r*N/A
*-lowering-*.f64N/A
Applied egg-rr55.0%
if 5.79999999999999965e-296 < F < 2e46Initial 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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6425.3%
Simplified25.3%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6426.6%
Applied egg-rr26.6%
clear-numN/A
div-invN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
pow1/2N/A
pow-flipN/A
metadata-evalN/A
metadata-evalN/A
pow-lowering-pow.f64N/A
metadata-eval26.7%
Applied egg-rr26.7%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
div-invN/A
pow-flipN/A
metadata-evalN/A
pow1/2N/A
associate-*l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
pow1/2N/A
sqrt-unprodN/A
pow1/2N/A
pow-prod-downN/A
Applied egg-rr25.3%
if 2e46 < F Initial program 19.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified19.2%
Applied egg-rr20.1%
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
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6421.2%
Simplified21.2%
Final simplification27.0%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= F 7e-294)
(/
(sqrt (* (+ (+ A C) (hypot B_m (- A C))) (* -8.0 (* F (* A C)))))
(- (* (* 4.0 A) C) (* B_m B_m)))
(if (<= F 3e+46)
(* (pow (* 2.0 (* F (+ A (hypot B_m A)))) 0.5) (/ -1.0 B_m))
(/ 1.0 (* (sqrt (/ B_m F)) (/ -1.0 (sqrt 2.0)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (F <= 7e-294) {
tmp = sqrt((((A + C) + hypot(B_m, (A - C))) * (-8.0 * (F * (A * C))))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (F <= 3e+46) {
tmp = pow((2.0 * (F * (A + hypot(B_m, A)))), 0.5) * (-1.0 / B_m);
} else {
tmp = 1.0 / (sqrt((B_m / F)) * (-1.0 / sqrt(2.0)));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (F <= 7e-294) {
tmp = Math.sqrt((((A + C) + Math.hypot(B_m, (A - C))) * (-8.0 * (F * (A * C))))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (F <= 3e+46) {
tmp = Math.pow((2.0 * (F * (A + Math.hypot(B_m, A)))), 0.5) * (-1.0 / B_m);
} else {
tmp = 1.0 / (Math.sqrt((B_m / F)) * (-1.0 / Math.sqrt(2.0)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if F <= 7e-294: tmp = math.sqrt((((A + C) + math.hypot(B_m, (A - C))) * (-8.0 * (F * (A * C))))) / (((4.0 * A) * C) - (B_m * B_m)) elif F <= 3e+46: tmp = math.pow((2.0 * (F * (A + math.hypot(B_m, A)))), 0.5) * (-1.0 / B_m) else: tmp = 1.0 / (math.sqrt((B_m / F)) * (-1.0 / math.sqrt(2.0))) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (F <= 7e-294) tmp = Float64(sqrt(Float64(Float64(Float64(A + C) + hypot(B_m, Float64(A - C))) * Float64(-8.0 * Float64(F * Float64(A * C))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); elseif (F <= 3e+46) tmp = Float64((Float64(2.0 * Float64(F * Float64(A + hypot(B_m, A)))) ^ 0.5) * Float64(-1.0 / B_m)); else tmp = Float64(1.0 / Float64(sqrt(Float64(B_m / F)) * Float64(-1.0 / sqrt(2.0)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (F <= 7e-294) tmp = sqrt((((A + C) + hypot(B_m, (A - C))) * (-8.0 * (F * (A * C))))) / (((4.0 * A) * C) - (B_m * B_m)); elseif (F <= 3e+46) tmp = ((2.0 * (F * (A + hypot(B_m, A)))) ^ 0.5) * (-1.0 / B_m); else tmp = 1.0 / (sqrt((B_m / F)) * (-1.0 / sqrt(2.0))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[F, 7e-294], N[(N[Sqrt[N[(N[(N[(A + C), $MachinePrecision] + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision] * N[(-8.0 * N[(F * N[(A * C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 3e+46], N[(N[Power[N[(2.0 * N[(F * N[(A + N[Sqrt[B$95$m ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] * N[(-1.0 / B$95$m), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[Sqrt[N[(B$95$m / F), $MachinePrecision]], $MachinePrecision] * N[(-1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;F \leq 7 \cdot 10^{-294}:\\
\;\;\;\;\frac{\sqrt{\left(\left(A + C\right) + \mathsf{hypot}\left(B\_m, A - C\right)\right) \cdot \left(-8 \cdot \left(F \cdot \left(A \cdot C\right)\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;F \leq 3 \cdot 10^{+46}:\\
\;\;\;\;{\left(2 \cdot \left(F \cdot \left(A + \mathsf{hypot}\left(B\_m, A\right)\right)\right)\right)}^{0.5} \cdot \frac{-1}{B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sqrt{\frac{B\_m}{F}} \cdot \frac{-1}{\sqrt{2}}}\\
\end{array}
\end{array}
if F < 7.00000000000000064e-294Initial program 36.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified53.9%
Taylor expanded in B around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6451.8%
Simplified51.8%
if 7.00000000000000064e-294 < F < 3.00000000000000023e46Initial program 20.4%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6425.4%
Simplified25.4%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6426.8%
Applied egg-rr26.8%
clear-numN/A
div-invN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
pow1/2N/A
pow-flipN/A
metadata-evalN/A
metadata-evalN/A
pow-lowering-pow.f64N/A
metadata-eval26.9%
Applied egg-rr26.9%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
div-invN/A
pow-flipN/A
metadata-evalN/A
pow1/2N/A
associate-*l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
pow1/2N/A
sqrt-unprodN/A
pow1/2N/A
pow-prod-downN/A
Applied egg-rr25.4%
if 3.00000000000000023e46 < F Initial program 19.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified19.2%
Applied egg-rr20.1%
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
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6421.2%
Simplified21.2%
Final simplification26.8%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= F 7e-294)
(/
(sqrt (* (* -8.0 (* A C)) (* F (+ (+ A C) (hypot B_m (- A C))))))
(- (* (* 4.0 A) C) (* B_m B_m)))
(if (<= F 4.2e+46)
(* (pow (* 2.0 (* F (+ A (hypot B_m A)))) 0.5) (/ -1.0 B_m))
(/ 1.0 (* (sqrt (/ B_m F)) (/ -1.0 (sqrt 2.0)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (F <= 7e-294) {
tmp = sqrt(((-8.0 * (A * C)) * (F * ((A + C) + hypot(B_m, (A - C)))))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (F <= 4.2e+46) {
tmp = pow((2.0 * (F * (A + hypot(B_m, A)))), 0.5) * (-1.0 / B_m);
} else {
tmp = 1.0 / (sqrt((B_m / F)) * (-1.0 / sqrt(2.0)));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (F <= 7e-294) {
tmp = Math.sqrt(((-8.0 * (A * C)) * (F * ((A + C) + Math.hypot(B_m, (A - C)))))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (F <= 4.2e+46) {
tmp = Math.pow((2.0 * (F * (A + Math.hypot(B_m, A)))), 0.5) * (-1.0 / B_m);
} else {
tmp = 1.0 / (Math.sqrt((B_m / F)) * (-1.0 / Math.sqrt(2.0)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if F <= 7e-294: tmp = math.sqrt(((-8.0 * (A * C)) * (F * ((A + C) + math.hypot(B_m, (A - C)))))) / (((4.0 * A) * C) - (B_m * B_m)) elif F <= 4.2e+46: tmp = math.pow((2.0 * (F * (A + math.hypot(B_m, A)))), 0.5) * (-1.0 / B_m) else: tmp = 1.0 / (math.sqrt((B_m / F)) * (-1.0 / math.sqrt(2.0))) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (F <= 7e-294) tmp = Float64(sqrt(Float64(Float64(-8.0 * Float64(A * C)) * Float64(F * Float64(Float64(A + C) + hypot(B_m, Float64(A - C)))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); elseif (F <= 4.2e+46) tmp = Float64((Float64(2.0 * Float64(F * Float64(A + hypot(B_m, A)))) ^ 0.5) * Float64(-1.0 / B_m)); else tmp = Float64(1.0 / Float64(sqrt(Float64(B_m / F)) * Float64(-1.0 / sqrt(2.0)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (F <= 7e-294) tmp = sqrt(((-8.0 * (A * C)) * (F * ((A + C) + hypot(B_m, (A - C)))))) / (((4.0 * A) * C) - (B_m * B_m)); elseif (F <= 4.2e+46) tmp = ((2.0 * (F * (A + hypot(B_m, A)))) ^ 0.5) * (-1.0 / B_m); else tmp = 1.0 / (sqrt((B_m / F)) * (-1.0 / sqrt(2.0))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[F, 7e-294], N[(N[Sqrt[N[(N[(-8.0 * N[(A * C), $MachinePrecision]), $MachinePrecision] * N[(F * N[(N[(A + C), $MachinePrecision] + N[Sqrt[B$95$m ^ 2 + N[(A - C), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 4.2e+46], N[(N[Power[N[(2.0 * N[(F * N[(A + N[Sqrt[B$95$m ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] * N[(-1.0 / B$95$m), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[Sqrt[N[(B$95$m / F), $MachinePrecision]], $MachinePrecision] * N[(-1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;F \leq 7 \cdot 10^{-294}:\\
\;\;\;\;\frac{\sqrt{\left(-8 \cdot \left(A \cdot C\right)\right) \cdot \left(F \cdot \left(\left(A + C\right) + \mathsf{hypot}\left(B\_m, A - C\right)\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;F \leq 4.2 \cdot 10^{+46}:\\
\;\;\;\;{\left(2 \cdot \left(F \cdot \left(A + \mathsf{hypot}\left(B\_m, A\right)\right)\right)\right)}^{0.5} \cdot \frac{-1}{B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sqrt{\frac{B\_m}{F}} \cdot \frac{-1}{\sqrt{2}}}\\
\end{array}
\end{array}
if F < 7.00000000000000064e-294Initial program 36.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified53.9%
Taylor expanded in B around 0
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f6451.8%
Simplified51.8%
associate-*r*N/A
associate-*l*N/A
distribute-rgt-inN/A
+-commutativeN/A
distribute-rgt-inN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-lft-inN/A
+-commutativeN/A
distribute-lft-inN/A
*-lowering-*.f64N/A
Applied egg-rr48.3%
if 7.00000000000000064e-294 < F < 4.2e46Initial program 20.4%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6425.4%
Simplified25.4%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6426.8%
Applied egg-rr26.8%
clear-numN/A
div-invN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
pow1/2N/A
pow-flipN/A
metadata-evalN/A
metadata-evalN/A
pow-lowering-pow.f64N/A
metadata-eval26.9%
Applied egg-rr26.9%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
div-invN/A
pow-flipN/A
metadata-evalN/A
pow1/2N/A
associate-*l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
pow1/2N/A
sqrt-unprodN/A
pow1/2N/A
pow-prod-downN/A
Applied egg-rr25.4%
if 4.2e46 < F Initial program 19.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified19.2%
Applied egg-rr20.1%
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
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6421.2%
Simplified21.2%
Final simplification26.4%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= F 2.5e-291)
(/ (sqrt (* (* C (* A C)) (* F -16.0))) (- (* (* 4.0 A) C) (* B_m B_m)))
(if (<= F 1.12e+46)
(* (pow (* 2.0 (* F (+ A (hypot B_m A)))) 0.5) (/ -1.0 B_m))
(/ 1.0 (* (sqrt (/ B_m F)) (/ -1.0 (sqrt 2.0)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (F <= 2.5e-291) {
tmp = sqrt(((C * (A * C)) * (F * -16.0))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (F <= 1.12e+46) {
tmp = pow((2.0 * (F * (A + hypot(B_m, A)))), 0.5) * (-1.0 / B_m);
} else {
tmp = 1.0 / (sqrt((B_m / F)) * (-1.0 / sqrt(2.0)));
}
return tmp;
}
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
double tmp;
if (F <= 2.5e-291) {
tmp = Math.sqrt(((C * (A * C)) * (F * -16.0))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (F <= 1.12e+46) {
tmp = Math.pow((2.0 * (F * (A + Math.hypot(B_m, A)))), 0.5) * (-1.0 / B_m);
} else {
tmp = 1.0 / (Math.sqrt((B_m / F)) * (-1.0 / Math.sqrt(2.0)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if F <= 2.5e-291: tmp = math.sqrt(((C * (A * C)) * (F * -16.0))) / (((4.0 * A) * C) - (B_m * B_m)) elif F <= 1.12e+46: tmp = math.pow((2.0 * (F * (A + math.hypot(B_m, A)))), 0.5) * (-1.0 / B_m) else: tmp = 1.0 / (math.sqrt((B_m / F)) * (-1.0 / math.sqrt(2.0))) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (F <= 2.5e-291) tmp = Float64(sqrt(Float64(Float64(C * Float64(A * C)) * Float64(F * -16.0))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); elseif (F <= 1.12e+46) tmp = Float64((Float64(2.0 * Float64(F * Float64(A + hypot(B_m, A)))) ^ 0.5) * Float64(-1.0 / B_m)); else tmp = Float64(1.0 / Float64(sqrt(Float64(B_m / F)) * Float64(-1.0 / sqrt(2.0)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (F <= 2.5e-291) tmp = sqrt(((C * (A * C)) * (F * -16.0))) / (((4.0 * A) * C) - (B_m * B_m)); elseif (F <= 1.12e+46) tmp = ((2.0 * (F * (A + hypot(B_m, A)))) ^ 0.5) * (-1.0 / B_m); else tmp = 1.0 / (sqrt((B_m / F)) * (-1.0 / sqrt(2.0))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[F, 2.5e-291], N[(N[Sqrt[N[(N[(C * N[(A * C), $MachinePrecision]), $MachinePrecision] * N[(F * -16.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 1.12e+46], N[(N[Power[N[(2.0 * N[(F * N[(A + N[Sqrt[B$95$m ^ 2 + A ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision] * N[(-1.0 / B$95$m), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[Sqrt[N[(B$95$m / F), $MachinePrecision]], $MachinePrecision] * N[(-1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;F \leq 2.5 \cdot 10^{-291}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot \left(A \cdot C\right)\right) \cdot \left(F \cdot -16\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;F \leq 1.12 \cdot 10^{+46}:\\
\;\;\;\;{\left(2 \cdot \left(F \cdot \left(A + \mathsf{hypot}\left(B\_m, A\right)\right)\right)\right)}^{0.5} \cdot \frac{-1}{B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sqrt{\frac{B\_m}{F}} \cdot \frac{-1}{\sqrt{2}}}\\
\end{array}
\end{array}
if F < 2.5000000000000002e-291Initial program 35.6%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified52.4%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6421.6%
Simplified21.6%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6431.2%
Applied egg-rr31.2%
if 2.5000000000000002e-291 < F < 1.12e46Initial program 20.6%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6425.6%
Simplified25.6%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6426.9%
Applied egg-rr26.9%
clear-numN/A
div-invN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
pow1/2N/A
pow-flipN/A
metadata-evalN/A
metadata-evalN/A
pow-lowering-pow.f64N/A
metadata-eval27.0%
Applied egg-rr27.0%
associate-*l*N/A
mul-1-negN/A
neg-lowering-neg.f64N/A
div-invN/A
pow-flipN/A
metadata-evalN/A
pow1/2N/A
associate-*l*N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
pow1/2N/A
sqrt-unprodN/A
pow1/2N/A
pow-prod-downN/A
Applied egg-rr25.6%
if 1.12e46 < F Initial program 19.5%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified19.2%
Applied egg-rr20.1%
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
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6421.2%
Simplified21.2%
Final simplification24.6%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= F 2.5e-291)
(/ (sqrt (* (* C (* A C)) (* F -16.0))) (- (* (* 4.0 A) C) (* B_m B_m)))
(if (<= F 5e-32)
(* (/ (sqrt 2.0) (- 0.0 B_m)) (sqrt (* B_m F)))
(/ 1.0 (* (sqrt (/ B_m F)) (/ -1.0 (sqrt 2.0)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (F <= 2.5e-291) {
tmp = sqrt(((C * (A * C)) * (F * -16.0))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (F <= 5e-32) {
tmp = (sqrt(2.0) / (0.0 - B_m)) * sqrt((B_m * F));
} else {
tmp = 1.0 / (sqrt((B_m / F)) * (-1.0 / sqrt(2.0)));
}
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 <= 2.5d-291) then
tmp = sqrt(((c * (a * c)) * (f * (-16.0d0)))) / (((4.0d0 * a) * c) - (b_m * b_m))
else if (f <= 5d-32) then
tmp = (sqrt(2.0d0) / (0.0d0 - b_m)) * sqrt((b_m * f))
else
tmp = 1.0d0 / (sqrt((b_m / f)) * ((-1.0d0) / sqrt(2.0d0)))
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 <= 2.5e-291) {
tmp = Math.sqrt(((C * (A * C)) * (F * -16.0))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (F <= 5e-32) {
tmp = (Math.sqrt(2.0) / (0.0 - B_m)) * Math.sqrt((B_m * F));
} else {
tmp = 1.0 / (Math.sqrt((B_m / F)) * (-1.0 / Math.sqrt(2.0)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if F <= 2.5e-291: tmp = math.sqrt(((C * (A * C)) * (F * -16.0))) / (((4.0 * A) * C) - (B_m * B_m)) elif F <= 5e-32: tmp = (math.sqrt(2.0) / (0.0 - B_m)) * math.sqrt((B_m * F)) else: tmp = 1.0 / (math.sqrt((B_m / F)) * (-1.0 / math.sqrt(2.0))) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (F <= 2.5e-291) tmp = Float64(sqrt(Float64(Float64(C * Float64(A * C)) * Float64(F * -16.0))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); elseif (F <= 5e-32) tmp = Float64(Float64(sqrt(2.0) / Float64(0.0 - B_m)) * sqrt(Float64(B_m * F))); else tmp = Float64(1.0 / Float64(sqrt(Float64(B_m / F)) * Float64(-1.0 / sqrt(2.0)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (F <= 2.5e-291) tmp = sqrt(((C * (A * C)) * (F * -16.0))) / (((4.0 * A) * C) - (B_m * B_m)); elseif (F <= 5e-32) tmp = (sqrt(2.0) / (0.0 - B_m)) * sqrt((B_m * F)); else tmp = 1.0 / (sqrt((B_m / F)) * (-1.0 / sqrt(2.0))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[F, 2.5e-291], N[(N[Sqrt[N[(N[(C * N[(A * C), $MachinePrecision]), $MachinePrecision] * N[(F * -16.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 5e-32], N[(N[(N[Sqrt[2.0], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(B$95$m * F), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[Sqrt[N[(B$95$m / F), $MachinePrecision]], $MachinePrecision] * N[(-1.0 / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;F \leq 2.5 \cdot 10^{-291}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot \left(A \cdot C\right)\right) \cdot \left(F \cdot -16\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;F \leq 5 \cdot 10^{-32}:\\
\;\;\;\;\frac{\sqrt{2}}{0 - B\_m} \cdot \sqrt{B\_m \cdot F}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\sqrt{\frac{B\_m}{F}} \cdot \frac{-1}{\sqrt{2}}}\\
\end{array}
\end{array}
if F < 2.5000000000000002e-291Initial program 35.6%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified52.4%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6421.6%
Simplified21.6%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6431.2%
Applied egg-rr31.2%
if 2.5000000000000002e-291 < F < 5e-32Initial program 17.6%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6427.3%
Simplified27.3%
Taylor expanded in A around 0
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f6425.0%
Simplified25.0%
if 5e-32 < F Initial program 21.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified21.8%
Applied egg-rr23.0%
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
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6419.6%
Simplified19.6%
Final simplification22.9%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= F 2.5e-291)
(/ (sqrt (* (* C (* A C)) (* F -16.0))) (- (* (* 4.0 A) C) (* B_m B_m)))
(if (<= F 6.2e+67)
(* (/ (sqrt 2.0) (- 0.0 B_m)) (sqrt (* B_m F)))
(- 0.0 (* (sqrt 2.0) (sqrt (/ F B_m)))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (F <= 2.5e-291) {
tmp = sqrt(((C * (A * C)) * (F * -16.0))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (F <= 6.2e+67) {
tmp = (sqrt(2.0) / (0.0 - B_m)) * sqrt((B_m * F));
} else {
tmp = 0.0 - (sqrt(2.0) * sqrt((F / 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 (f <= 2.5d-291) then
tmp = sqrt(((c * (a * c)) * (f * (-16.0d0)))) / (((4.0d0 * a) * c) - (b_m * b_m))
else if (f <= 6.2d+67) then
tmp = (sqrt(2.0d0) / (0.0d0 - b_m)) * sqrt((b_m * f))
else
tmp = 0.0d0 - (sqrt(2.0d0) * sqrt((f / 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 (F <= 2.5e-291) {
tmp = Math.sqrt(((C * (A * C)) * (F * -16.0))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (F <= 6.2e+67) {
tmp = (Math.sqrt(2.0) / (0.0 - B_m)) * Math.sqrt((B_m * F));
} else {
tmp = 0.0 - (Math.sqrt(2.0) * Math.sqrt((F / B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if F <= 2.5e-291: tmp = math.sqrt(((C * (A * C)) * (F * -16.0))) / (((4.0 * A) * C) - (B_m * B_m)) elif F <= 6.2e+67: tmp = (math.sqrt(2.0) / (0.0 - B_m)) * math.sqrt((B_m * F)) else: tmp = 0.0 - (math.sqrt(2.0) * math.sqrt((F / B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (F <= 2.5e-291) tmp = Float64(sqrt(Float64(Float64(C * Float64(A * C)) * Float64(F * -16.0))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); elseif (F <= 6.2e+67) tmp = Float64(Float64(sqrt(2.0) / Float64(0.0 - B_m)) * sqrt(Float64(B_m * F))); else tmp = Float64(0.0 - Float64(sqrt(2.0) * sqrt(Float64(F / B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (F <= 2.5e-291) tmp = sqrt(((C * (A * C)) * (F * -16.0))) / (((4.0 * A) * C) - (B_m * B_m)); elseif (F <= 6.2e+67) tmp = (sqrt(2.0) / (0.0 - B_m)) * sqrt((B_m * F)); else tmp = 0.0 - (sqrt(2.0) * sqrt((F / B_m))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[F, 2.5e-291], N[(N[Sqrt[N[(N[(C * N[(A * C), $MachinePrecision]), $MachinePrecision] * N[(F * -16.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[F, 6.2e+67], N[(N[(N[Sqrt[2.0], $MachinePrecision] / N[(0.0 - B$95$m), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(B$95$m * F), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], N[(0.0 - N[(N[Sqrt[2.0], $MachinePrecision] * N[Sqrt[N[(F / B$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;F \leq 2.5 \cdot 10^{-291}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot \left(A \cdot C\right)\right) \cdot \left(F \cdot -16\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;F \leq 6.2 \cdot 10^{+67}:\\
\;\;\;\;\frac{\sqrt{2}}{0 - B\_m} \cdot \sqrt{B\_m \cdot F}\\
\mathbf{else}:\\
\;\;\;\;0 - \sqrt{2} \cdot \sqrt{\frac{F}{B\_m}}\\
\end{array}
\end{array}
if F < 2.5000000000000002e-291Initial program 35.6%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified52.4%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6421.6%
Simplified21.6%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6431.2%
Applied egg-rr31.2%
if 2.5000000000000002e-291 < F < 6.19999999999999992e67Initial program 22.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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6425.2%
Simplified25.2%
Taylor expanded in A around 0
sqrt-lowering-sqrt.f64N/A
*-lowering-*.f6422.1%
Simplified22.1%
if 6.19999999999999992e67 < F Initial program 16.7%
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
sqrt-lowering-sqrt.f6421.3%
Simplified21.3%
Final simplification22.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 1.05e-141)
(/ (sqrt (* -16.0 (* C (* A (* C F))))) t_0)
(if (<= B_m 6.2e-27)
(/
(sqrt
(*
F
(+
(* -16.0 (* C (* A A)))
(*
2.0
(*
(* B_m B_m)
(+
(* -2.0 (/ (* A C) (- A C)))
(+
(* 2.0 A)
(*
(* B_m B_m)
(+
(* 0.5 (/ (* A C) (* (- A C) (* (- A C) (- A C)))))
(* 0.5 (/ 1.0 (- A C))))))))))))
t_0)
(- 0.0 (* (sqrt 2.0) (sqrt (/ F B_m))))))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double t_0 = ((4.0 * A) * C) - (B_m * B_m);
double tmp;
if (B_m <= 1.05e-141) {
tmp = sqrt((-16.0 * (C * (A * (C * F))))) / t_0;
} else if (B_m <= 6.2e-27) {
tmp = sqrt((F * ((-16.0 * (C * (A * A))) + (2.0 * ((B_m * B_m) * ((-2.0 * ((A * C) / (A - C))) + ((2.0 * A) + ((B_m * B_m) * ((0.5 * ((A * C) / ((A - C) * ((A - C) * (A - C))))) + (0.5 * (1.0 / (A - C)))))))))))) / t_0;
} else {
tmp = 0.0 - (sqrt(2.0) * sqrt((F / 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 <= 1.05d-141) then
tmp = sqrt(((-16.0d0) * (c * (a * (c * f))))) / t_0
else if (b_m <= 6.2d-27) then
tmp = sqrt((f * (((-16.0d0) * (c * (a * a))) + (2.0d0 * ((b_m * b_m) * (((-2.0d0) * ((a * c) / (a - c))) + ((2.0d0 * a) + ((b_m * b_m) * ((0.5d0 * ((a * c) / ((a - c) * ((a - c) * (a - c))))) + (0.5d0 * (1.0d0 / (a - c)))))))))))) / t_0
else
tmp = 0.0d0 - (sqrt(2.0d0) * sqrt((f / 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 <= 1.05e-141) {
tmp = Math.sqrt((-16.0 * (C * (A * (C * F))))) / t_0;
} else if (B_m <= 6.2e-27) {
tmp = Math.sqrt((F * ((-16.0 * (C * (A * A))) + (2.0 * ((B_m * B_m) * ((-2.0 * ((A * C) / (A - C))) + ((2.0 * A) + ((B_m * B_m) * ((0.5 * ((A * C) / ((A - C) * ((A - C) * (A - C))))) + (0.5 * (1.0 / (A - C)))))))))))) / t_0;
} else {
tmp = 0.0 - (Math.sqrt(2.0) * Math.sqrt((F / B_m)));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = ((4.0 * A) * C) - (B_m * B_m) tmp = 0 if B_m <= 1.05e-141: tmp = math.sqrt((-16.0 * (C * (A * (C * F))))) / t_0 elif B_m <= 6.2e-27: tmp = math.sqrt((F * ((-16.0 * (C * (A * A))) + (2.0 * ((B_m * B_m) * ((-2.0 * ((A * C) / (A - C))) + ((2.0 * A) + ((B_m * B_m) * ((0.5 * ((A * C) / ((A - C) * ((A - C) * (A - C))))) + (0.5 * (1.0 / (A - C)))))))))))) / t_0 else: tmp = 0.0 - (math.sqrt(2.0) * math.sqrt((F / B_m))) return tmp
B_m = abs(B) function code(A, B_m, C, F) t_0 = Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m)) tmp = 0.0 if (B_m <= 1.05e-141) tmp = Float64(sqrt(Float64(-16.0 * Float64(C * Float64(A * Float64(C * F))))) / t_0); elseif (B_m <= 6.2e-27) tmp = Float64(sqrt(Float64(F * Float64(Float64(-16.0 * Float64(C * Float64(A * A))) + Float64(2.0 * Float64(Float64(B_m * B_m) * Float64(Float64(-2.0 * Float64(Float64(A * C) / Float64(A - C))) + Float64(Float64(2.0 * A) + Float64(Float64(B_m * B_m) * Float64(Float64(0.5 * Float64(Float64(A * C) / Float64(Float64(A - C) * Float64(Float64(A - C) * Float64(A - C))))) + Float64(0.5 * Float64(1.0 / Float64(A - C)))))))))))) / t_0); else tmp = Float64(0.0 - Float64(sqrt(2.0) * sqrt(Float64(F / B_m)))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) t_0 = ((4.0 * A) * C) - (B_m * B_m); tmp = 0.0; if (B_m <= 1.05e-141) tmp = sqrt((-16.0 * (C * (A * (C * F))))) / t_0; elseif (B_m <= 6.2e-27) tmp = sqrt((F * ((-16.0 * (C * (A * A))) + (2.0 * ((B_m * B_m) * ((-2.0 * ((A * C) / (A - C))) + ((2.0 * A) + ((B_m * B_m) * ((0.5 * ((A * C) / ((A - C) * ((A - C) * (A - C))))) + (0.5 * (1.0 / (A - C)))))))))))) / t_0; else tmp = 0.0 - (sqrt(2.0) * sqrt((F / B_m))); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision]
code[A_, B$95$m_, C_, F_] := Block[{t$95$0 = N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[B$95$m, 1.05e-141], N[(N[Sqrt[N[(-16.0 * N[(C * N[(A * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[B$95$m, 6.2e-27], N[(N[Sqrt[N[(F * N[(N[(-16.0 * N[(C * N[(A * A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(N[(B$95$m * B$95$m), $MachinePrecision] * N[(N[(-2.0 * N[(N[(A * C), $MachinePrecision] / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(2.0 * A), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] * N[(N[(0.5 * N[(N[(A * C), $MachinePrecision] / N[(N[(A - C), $MachinePrecision] * N[(N[(A - C), $MachinePrecision] * N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(1.0 / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(0.0 - N[(N[Sqrt[2.0], $MachinePrecision] * N[Sqrt[N[(F / B$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
t_0 := \left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m\\
\mathbf{if}\;B\_m \leq 1.05 \cdot 10^{-141}:\\
\;\;\;\;\frac{\sqrt{-16 \cdot \left(C \cdot \left(A \cdot \left(C \cdot F\right)\right)\right)}}{t\_0}\\
\mathbf{elif}\;B\_m \leq 6.2 \cdot 10^{-27}:\\
\;\;\;\;\frac{\sqrt{F \cdot \left(-16 \cdot \left(C \cdot \left(A \cdot A\right)\right) + 2 \cdot \left(\left(B\_m \cdot B\_m\right) \cdot \left(-2 \cdot \frac{A \cdot C}{A - C} + \left(2 \cdot A + \left(B\_m \cdot B\_m\right) \cdot \left(0.5 \cdot \frac{A \cdot C}{\left(A - C\right) \cdot \left(\left(A - C\right) \cdot \left(A - C\right)\right)} + 0.5 \cdot \frac{1}{A - C}\right)\right)\right)\right)\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;0 - \sqrt{2} \cdot \sqrt{\frac{F}{B\_m}}\\
\end{array}
\end{array}
if B < 1.05e-141Initial program 23.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified28.4%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6412.9%
Simplified12.9%
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6416.6%
Applied egg-rr16.6%
if 1.05e-141 < B < 6.1999999999999997e-27Initial program 32.0%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified32.5%
Taylor expanded in B around 0
Simplified23.3%
Taylor expanded in F around 0
Simplified27.2%
if 6.1999999999999997e-27 < B Initial program 16.2%
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
sqrt-lowering-sqrt.f6437.2%
Simplified37.2%
Final simplification23.6%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= A -6.5e-82) (* (sqrt (/ (* F -0.5) A)) (- 0.0 (sqrt 2.0))) (* (sqrt (/ F B_m)) (/ -1.0 (sqrt 0.5)))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (A <= -6.5e-82) {
tmp = sqrt(((F * -0.5) / A)) * (0.0 - sqrt(2.0));
} else {
tmp = sqrt((F / B_m)) * (-1.0 / sqrt(0.5));
}
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 (a <= (-6.5d-82)) then
tmp = sqrt(((f * (-0.5d0)) / a)) * (0.0d0 - sqrt(2.0d0))
else
tmp = sqrt((f / b_m)) * ((-1.0d0) / sqrt(0.5d0))
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 (A <= -6.5e-82) {
tmp = Math.sqrt(((F * -0.5) / A)) * (0.0 - Math.sqrt(2.0));
} else {
tmp = Math.sqrt((F / B_m)) * (-1.0 / Math.sqrt(0.5));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if A <= -6.5e-82: tmp = math.sqrt(((F * -0.5) / A)) * (0.0 - math.sqrt(2.0)) else: tmp = math.sqrt((F / B_m)) * (-1.0 / math.sqrt(0.5)) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (A <= -6.5e-82) tmp = Float64(sqrt(Float64(Float64(F * -0.5) / A)) * Float64(0.0 - sqrt(2.0))); else tmp = Float64(sqrt(Float64(F / B_m)) * Float64(-1.0 / sqrt(0.5))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (A <= -6.5e-82) tmp = sqrt(((F * -0.5) / A)) * (0.0 - sqrt(2.0)); else tmp = sqrt((F / B_m)) * (-1.0 / sqrt(0.5)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[A, -6.5e-82], N[(N[Sqrt[N[(N[(F * -0.5), $MachinePrecision] / A), $MachinePrecision]], $MachinePrecision] * N[(0.0 - N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(F / B$95$m), $MachinePrecision]], $MachinePrecision] * N[(-1.0 / N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;A \leq -6.5 \cdot 10^{-82}:\\
\;\;\;\;\sqrt{\frac{F \cdot -0.5}{A}} \cdot \left(0 - \sqrt{2}\right)\\
\mathbf{else}:\\
\;\;\;\;\sqrt{\frac{F}{B\_m}} \cdot \frac{-1}{\sqrt{0.5}}\\
\end{array}
\end{array}
if A < -6.4999999999999997e-82Initial program 8.2%
Taylor expanded in F around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
*-lowering-*.f64N/A
Simplified10.4%
Taylor expanded in C around inf
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f6436.4%
Simplified36.4%
if -6.4999999999999997e-82 < A Initial program 28.9%
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
+-commutativeN/A
unpow2N/A
unpow2N/A
hypot-defineN/A
hypot-lowering-hypot.f6422.3%
Simplified22.3%
pow1/2N/A
*-commutativeN/A
unpow-prod-downN/A
*-lowering-*.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
hypot-defineN/A
hypot-lowering-hypot.f64N/A
pow1/2N/A
sqrt-lowering-sqrt.f6429.8%
Applied egg-rr29.8%
clear-numN/A
div-invN/A
associate-/r*N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
pow1/2N/A
pow-flipN/A
metadata-evalN/A
metadata-evalN/A
pow-lowering-pow.f64N/A
metadata-eval29.8%
Applied egg-rr29.8%
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
/-lowering-/.f64N/A
sqrt-lowering-sqrt.f6417.6%
Simplified17.6%
Final simplification23.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))) (t_1 (* (- A C) (- A C))))
(if (<= A -5.5e+135)
(/ (sqrt (* (* C (* A C)) (* F -16.0))) t_0)
(if (<= A -6.8e-140)
(- 0.0 (pow (* (/ F A) (/ F A)) 0.25))
(if (<= A 3.7e-170)
(/
(sqrt
(*
(* B_m (* B_m B_m))
(+
(* 2.0 F)
(*
2.0
(+
(/ (* F (+ A C)) B_m)
(/ (* F (+ (* -4.0 (* A C)) (* 0.5 t_1))) (* B_m B_m)))))))
(- 0.0 (* B_m B_m)))
(/
(sqrt
(*
F
(+
(* -16.0 (* C (* A A)))
(*
2.0
(*
(* B_m B_m)
(+
(* -2.0 (/ (* A C) (- A C)))
(+
(* 2.0 A)
(*
(* B_m B_m)
(+
(* 0.5 (/ (* A C) (* (- A C) t_1)))
(* 0.5 (/ 1.0 (- A C))))))))))))
t_0))))))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 t_1 = (A - C) * (A - C);
double tmp;
if (A <= -5.5e+135) {
tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -6.8e-140) {
tmp = 0.0 - pow(((F / A) * (F / A)), 0.25);
} else if (A <= 3.7e-170) {
tmp = sqrt(((B_m * (B_m * B_m)) * ((2.0 * F) + (2.0 * (((F * (A + C)) / B_m) + ((F * ((-4.0 * (A * C)) + (0.5 * t_1))) / (B_m * B_m))))))) / (0.0 - (B_m * B_m));
} else {
tmp = sqrt((F * ((-16.0 * (C * (A * A))) + (2.0 * ((B_m * B_m) * ((-2.0 * ((A * C) / (A - C))) + ((2.0 * A) + ((B_m * B_m) * ((0.5 * ((A * C) / ((A - C) * t_1))) + (0.5 * (1.0 / (A - C)))))))))))) / t_0;
}
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) :: t_1
real(8) :: tmp
t_0 = ((4.0d0 * a) * c) - (b_m * b_m)
t_1 = (a - c) * (a - c)
if (a <= (-5.5d+135)) then
tmp = sqrt(((c * (a * c)) * (f * (-16.0d0)))) / t_0
else if (a <= (-6.8d-140)) then
tmp = 0.0d0 - (((f / a) * (f / a)) ** 0.25d0)
else if (a <= 3.7d-170) then
tmp = sqrt(((b_m * (b_m * b_m)) * ((2.0d0 * f) + (2.0d0 * (((f * (a + c)) / b_m) + ((f * (((-4.0d0) * (a * c)) + (0.5d0 * t_1))) / (b_m * b_m))))))) / (0.0d0 - (b_m * b_m))
else
tmp = sqrt((f * (((-16.0d0) * (c * (a * a))) + (2.0d0 * ((b_m * b_m) * (((-2.0d0) * ((a * c) / (a - c))) + ((2.0d0 * a) + ((b_m * b_m) * ((0.5d0 * ((a * c) / ((a - c) * t_1))) + (0.5d0 * (1.0d0 / (a - c)))))))))))) / t_0
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 t_1 = (A - C) * (A - C);
double tmp;
if (A <= -5.5e+135) {
tmp = Math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -6.8e-140) {
tmp = 0.0 - Math.pow(((F / A) * (F / A)), 0.25);
} else if (A <= 3.7e-170) {
tmp = Math.sqrt(((B_m * (B_m * B_m)) * ((2.0 * F) + (2.0 * (((F * (A + C)) / B_m) + ((F * ((-4.0 * (A * C)) + (0.5 * t_1))) / (B_m * B_m))))))) / (0.0 - (B_m * B_m));
} else {
tmp = Math.sqrt((F * ((-16.0 * (C * (A * A))) + (2.0 * ((B_m * B_m) * ((-2.0 * ((A * C) / (A - C))) + ((2.0 * A) + ((B_m * B_m) * ((0.5 * ((A * C) / ((A - C) * t_1))) + (0.5 * (1.0 / (A - C)))))))))))) / t_0;
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): t_0 = ((4.0 * A) * C) - (B_m * B_m) t_1 = (A - C) * (A - C) tmp = 0 if A <= -5.5e+135: tmp = math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0 elif A <= -6.8e-140: tmp = 0.0 - math.pow(((F / A) * (F / A)), 0.25) elif A <= 3.7e-170: tmp = math.sqrt(((B_m * (B_m * B_m)) * ((2.0 * F) + (2.0 * (((F * (A + C)) / B_m) + ((F * ((-4.0 * (A * C)) + (0.5 * t_1))) / (B_m * B_m))))))) / (0.0 - (B_m * B_m)) else: tmp = math.sqrt((F * ((-16.0 * (C * (A * A))) + (2.0 * ((B_m * B_m) * ((-2.0 * ((A * C) / (A - C))) + ((2.0 * A) + ((B_m * B_m) * ((0.5 * ((A * C) / ((A - C) * t_1))) + (0.5 * (1.0 / (A - C)))))))))))) / t_0 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)) t_1 = Float64(Float64(A - C) * Float64(A - C)) tmp = 0.0 if (A <= -5.5e+135) tmp = Float64(sqrt(Float64(Float64(C * Float64(A * C)) * Float64(F * -16.0))) / t_0); elseif (A <= -6.8e-140) tmp = Float64(0.0 - (Float64(Float64(F / A) * Float64(F / A)) ^ 0.25)); elseif (A <= 3.7e-170) tmp = Float64(sqrt(Float64(Float64(B_m * Float64(B_m * B_m)) * Float64(Float64(2.0 * F) + Float64(2.0 * Float64(Float64(Float64(F * Float64(A + C)) / B_m) + Float64(Float64(F * Float64(Float64(-4.0 * Float64(A * C)) + Float64(0.5 * t_1))) / Float64(B_m * B_m))))))) / Float64(0.0 - Float64(B_m * B_m))); else tmp = Float64(sqrt(Float64(F * Float64(Float64(-16.0 * Float64(C * Float64(A * A))) + Float64(2.0 * Float64(Float64(B_m * B_m) * Float64(Float64(-2.0 * Float64(Float64(A * C) / Float64(A - C))) + Float64(Float64(2.0 * A) + Float64(Float64(B_m * B_m) * Float64(Float64(0.5 * Float64(Float64(A * C) / Float64(Float64(A - C) * t_1))) + Float64(0.5 * Float64(1.0 / Float64(A - C)))))))))))) / t_0); 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); t_1 = (A - C) * (A - C); tmp = 0.0; if (A <= -5.5e+135) tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0; elseif (A <= -6.8e-140) tmp = 0.0 - (((F / A) * (F / A)) ^ 0.25); elseif (A <= 3.7e-170) tmp = sqrt(((B_m * (B_m * B_m)) * ((2.0 * F) + (2.0 * (((F * (A + C)) / B_m) + ((F * ((-4.0 * (A * C)) + (0.5 * t_1))) / (B_m * B_m))))))) / (0.0 - (B_m * B_m)); else tmp = sqrt((F * ((-16.0 * (C * (A * A))) + (2.0 * ((B_m * B_m) * ((-2.0 * ((A * C) / (A - C))) + ((2.0 * A) + ((B_m * B_m) * ((0.5 * ((A * C) / ((A - C) * t_1))) + (0.5 * (1.0 / (A - C)))))))))))) / t_0; 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]}, Block[{t$95$1 = N[(N[(A - C), $MachinePrecision] * N[(A - C), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[A, -5.5e+135], N[(N[Sqrt[N[(N[(C * N[(A * C), $MachinePrecision]), $MachinePrecision] * N[(F * -16.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[A, -6.8e-140], N[(0.0 - N[Power[N[(N[(F / A), $MachinePrecision] * N[(F / A), $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 3.7e-170], N[(N[Sqrt[N[(N[(B$95$m * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 * F), $MachinePrecision] + N[(2.0 * N[(N[(N[(F * N[(A + C), $MachinePrecision]), $MachinePrecision] / B$95$m), $MachinePrecision] + N[(N[(F * N[(N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision] + N[(0.5 * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(F * N[(N[(-16.0 * N[(C * N[(A * A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(N[(B$95$m * B$95$m), $MachinePrecision] * N[(N[(-2.0 * N[(N[(A * C), $MachinePrecision] / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(2.0 * A), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] * N[(N[(0.5 * N[(N[(A * C), $MachinePrecision] / N[(N[(A - C), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(1.0 / N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $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\\
t_1 := \left(A - C\right) \cdot \left(A - C\right)\\
\mathbf{if}\;A \leq -5.5 \cdot 10^{+135}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot \left(A \cdot C\right)\right) \cdot \left(F \cdot -16\right)}}{t\_0}\\
\mathbf{elif}\;A \leq -6.8 \cdot 10^{-140}:\\
\;\;\;\;0 - {\left(\frac{F}{A} \cdot \frac{F}{A}\right)}^{0.25}\\
\mathbf{elif}\;A \leq 3.7 \cdot 10^{-170}:\\
\;\;\;\;\frac{\sqrt{\left(B\_m \cdot \left(B\_m \cdot B\_m\right)\right) \cdot \left(2 \cdot F + 2 \cdot \left(\frac{F \cdot \left(A + C\right)}{B\_m} + \frac{F \cdot \left(-4 \cdot \left(A \cdot C\right) + 0.5 \cdot t\_1\right)}{B\_m \cdot B\_m}\right)\right)}}{0 - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{F \cdot \left(-16 \cdot \left(C \cdot \left(A \cdot A\right)\right) + 2 \cdot \left(\left(B\_m \cdot B\_m\right) \cdot \left(-2 \cdot \frac{A \cdot C}{A - C} + \left(2 \cdot A + \left(B\_m \cdot B\_m\right) \cdot \left(0.5 \cdot \frac{A \cdot C}{\left(A - C\right) \cdot t\_1} + 0.5 \cdot \frac{1}{A - C}\right)\right)\right)\right)\right)}}{t\_0}\\
\end{array}
\end{array}
if A < -5.4999999999999999e135Initial program 1.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified2.5%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.7%
Simplified18.7%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6436.6%
Applied egg-rr36.6%
if -5.4999999999999999e135 < A < -6.80000000000000017e-140Initial program 13.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified14.1%
Taylor expanded in B around 0
Simplified9.9%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f649.8%
Simplified9.8%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f640.2%
Simplified0.2%
pow1/2N/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval28.4%
Applied egg-rr28.4%
if -6.80000000000000017e-140 < A < 3.7e-170Initial program 32.8%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified36.5%
Taylor expanded in A around 0
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6429.5%
Simplified29.5%
Taylor expanded in B around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
distribute-lft-outN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified15.0%
if 3.7e-170 < A Initial program 27.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified32.7%
Taylor expanded in B around 0
Simplified20.0%
Taylor expanded in F around 0
Simplified24.0%
Final simplification24.6%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= A -4e+135)
(/ (sqrt (* (* C (* A C)) (* F -16.0))) t_0)
(if (<= A -6.5e-140)
(- 0.0 (pow (* (/ F A) (/ F A)) 0.25))
(if (<= A 1.7e-59)
(/
(sqrt
(*
(* B_m (* B_m B_m))
(+
(* 2.0 F)
(*
2.0
(+
(/ (* F (+ A C)) B_m)
(/
(* F (+ (* -4.0 (* A C)) (* 0.5 (* (- A C) (- A C)))))
(* B_m B_m)))))))
(- 0.0 (* B_m B_m)))
(/
(sqrt
(*
(* A A)
(+
(* -16.0 (* C F))
(/
(* 2.0 (* F (+ (* 2.0 (* B_m B_m)) (* -4.0 (* C (* C 0.0))))))
A))))
t_0))))))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 (A <= -4e+135) {
tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -6.5e-140) {
tmp = 0.0 - pow(((F / A) * (F / A)), 0.25);
} else if (A <= 1.7e-59) {
tmp = sqrt(((B_m * (B_m * B_m)) * ((2.0 * F) + (2.0 * (((F * (A + C)) / B_m) + ((F * ((-4.0 * (A * C)) + (0.5 * ((A - C) * (A - C))))) / (B_m * B_m))))))) / (0.0 - (B_m * B_m));
} else {
tmp = sqrt(((A * A) * ((-16.0 * (C * F)) + ((2.0 * (F * ((2.0 * (B_m * B_m)) + (-4.0 * (C * (C * 0.0)))))) / A)))) / t_0;
}
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 (a <= (-4d+135)) then
tmp = sqrt(((c * (a * c)) * (f * (-16.0d0)))) / t_0
else if (a <= (-6.5d-140)) then
tmp = 0.0d0 - (((f / a) * (f / a)) ** 0.25d0)
else if (a <= 1.7d-59) then
tmp = sqrt(((b_m * (b_m * b_m)) * ((2.0d0 * f) + (2.0d0 * (((f * (a + c)) / b_m) + ((f * (((-4.0d0) * (a * c)) + (0.5d0 * ((a - c) * (a - c))))) / (b_m * b_m))))))) / (0.0d0 - (b_m * b_m))
else
tmp = sqrt(((a * a) * (((-16.0d0) * (c * f)) + ((2.0d0 * (f * ((2.0d0 * (b_m * b_m)) + ((-4.0d0) * (c * (c * 0.0d0)))))) / a)))) / t_0
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 (A <= -4e+135) {
tmp = Math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -6.5e-140) {
tmp = 0.0 - Math.pow(((F / A) * (F / A)), 0.25);
} else if (A <= 1.7e-59) {
tmp = Math.sqrt(((B_m * (B_m * B_m)) * ((2.0 * F) + (2.0 * (((F * (A + C)) / B_m) + ((F * ((-4.0 * (A * C)) + (0.5 * ((A - C) * (A - C))))) / (B_m * B_m))))))) / (0.0 - (B_m * B_m));
} else {
tmp = Math.sqrt(((A * A) * ((-16.0 * (C * F)) + ((2.0 * (F * ((2.0 * (B_m * B_m)) + (-4.0 * (C * (C * 0.0)))))) / A)))) / t_0;
}
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 A <= -4e+135: tmp = math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0 elif A <= -6.5e-140: tmp = 0.0 - math.pow(((F / A) * (F / A)), 0.25) elif A <= 1.7e-59: tmp = math.sqrt(((B_m * (B_m * B_m)) * ((2.0 * F) + (2.0 * (((F * (A + C)) / B_m) + ((F * ((-4.0 * (A * C)) + (0.5 * ((A - C) * (A - C))))) / (B_m * B_m))))))) / (0.0 - (B_m * B_m)) else: tmp = math.sqrt(((A * A) * ((-16.0 * (C * F)) + ((2.0 * (F * ((2.0 * (B_m * B_m)) + (-4.0 * (C * (C * 0.0)))))) / A)))) / t_0 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 (A <= -4e+135) tmp = Float64(sqrt(Float64(Float64(C * Float64(A * C)) * Float64(F * -16.0))) / t_0); elseif (A <= -6.5e-140) tmp = Float64(0.0 - (Float64(Float64(F / A) * Float64(F / A)) ^ 0.25)); elseif (A <= 1.7e-59) tmp = Float64(sqrt(Float64(Float64(B_m * Float64(B_m * B_m)) * Float64(Float64(2.0 * F) + Float64(2.0 * Float64(Float64(Float64(F * Float64(A + C)) / B_m) + Float64(Float64(F * Float64(Float64(-4.0 * Float64(A * C)) + Float64(0.5 * Float64(Float64(A - C) * Float64(A - C))))) / Float64(B_m * B_m))))))) / Float64(0.0 - Float64(B_m * B_m))); else tmp = Float64(sqrt(Float64(Float64(A * A) * Float64(Float64(-16.0 * Float64(C * F)) + Float64(Float64(2.0 * Float64(F * Float64(Float64(2.0 * Float64(B_m * B_m)) + Float64(-4.0 * Float64(C * Float64(C * 0.0)))))) / A)))) / t_0); 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 (A <= -4e+135) tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0; elseif (A <= -6.5e-140) tmp = 0.0 - (((F / A) * (F / A)) ^ 0.25); elseif (A <= 1.7e-59) tmp = sqrt(((B_m * (B_m * B_m)) * ((2.0 * F) + (2.0 * (((F * (A + C)) / B_m) + ((F * ((-4.0 * (A * C)) + (0.5 * ((A - C) * (A - C))))) / (B_m * B_m))))))) / (0.0 - (B_m * B_m)); else tmp = sqrt(((A * A) * ((-16.0 * (C * F)) + ((2.0 * (F * ((2.0 * (B_m * B_m)) + (-4.0 * (C * (C * 0.0)))))) / A)))) / t_0; 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[A, -4e+135], N[(N[Sqrt[N[(N[(C * N[(A * C), $MachinePrecision]), $MachinePrecision] * N[(F * -16.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[A, -6.5e-140], N[(0.0 - N[Power[N[(N[(F / A), $MachinePrecision] * N[(F / A), $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.7e-59], N[(N[Sqrt[N[(N[(B$95$m * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 * F), $MachinePrecision] + N[(2.0 * N[(N[(N[(F * N[(A + C), $MachinePrecision]), $MachinePrecision] / B$95$m), $MachinePrecision] + N[(N[(F * N[(N[(-4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision] + N[(0.5 * N[(N[(A - C), $MachinePrecision] * N[(A - C), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(N[(A * A), $MachinePrecision] * N[(N[(-16.0 * N[(C * F), $MachinePrecision]), $MachinePrecision] + N[(N[(2.0 * N[(F * N[(N[(2.0 * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] + N[(-4.0 * N[(C * N[(C * 0.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $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}\;A \leq -4 \cdot 10^{+135}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot \left(A \cdot C\right)\right) \cdot \left(F \cdot -16\right)}}{t\_0}\\
\mathbf{elif}\;A \leq -6.5 \cdot 10^{-140}:\\
\;\;\;\;0 - {\left(\frac{F}{A} \cdot \frac{F}{A}\right)}^{0.25}\\
\mathbf{elif}\;A \leq 1.7 \cdot 10^{-59}:\\
\;\;\;\;\frac{\sqrt{\left(B\_m \cdot \left(B\_m \cdot B\_m\right)\right) \cdot \left(2 \cdot F + 2 \cdot \left(\frac{F \cdot \left(A + C\right)}{B\_m} + \frac{F \cdot \left(-4 \cdot \left(A \cdot C\right) + 0.5 \cdot \left(\left(A - C\right) \cdot \left(A - C\right)\right)\right)}{B\_m \cdot B\_m}\right)\right)}}{0 - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{\left(A \cdot A\right) \cdot \left(-16 \cdot \left(C \cdot F\right) + \frac{2 \cdot \left(F \cdot \left(2 \cdot \left(B\_m \cdot B\_m\right) + -4 \cdot \left(C \cdot \left(C \cdot 0\right)\right)\right)\right)}{A}\right)}}{t\_0}\\
\end{array}
\end{array}
if A < -3.99999999999999985e135Initial program 1.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified2.5%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.7%
Simplified18.7%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6436.6%
Applied egg-rr36.6%
if -3.99999999999999985e135 < A < -6.4999999999999995e-140Initial program 13.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified14.1%
Taylor expanded in B around 0
Simplified9.9%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f649.8%
Simplified9.8%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f640.2%
Simplified0.2%
pow1/2N/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval28.4%
Applied egg-rr28.4%
if -6.4999999999999995e-140 < A < 1.70000000000000009e-59Initial program 30.7%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified33.4%
Taylor expanded in A around 0
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6426.8%
Simplified26.8%
Taylor expanded in B around inf
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
distribute-lft-outN/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
Simplified12.1%
if 1.70000000000000009e-59 < A Initial program 28.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified34.7%
Taylor expanded in A around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
Simplified24.7%
Final simplification23.4%
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 (<= A -3e+136)
(/ (sqrt (* (* C (* A C)) (* F -16.0))) t_0)
(if (<= A -1.9e-136)
(- 0.0 (pow (* (/ F A) (/ F A)) 0.25))
(if (<= A 1.65e-60)
(/ (sqrt (* 2.0 (* F (* B_m (* B_m B_m))))) t_0)
(/
(sqrt
(*
(* A A)
(+
(* -16.0 (* C F))
(/
(* 2.0 (* F (+ (* 2.0 (* B_m B_m)) (* -4.0 (* C (* C 0.0))))))
A))))
t_0))))))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 (A <= -3e+136) {
tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -1.9e-136) {
tmp = 0.0 - pow(((F / A) * (F / A)), 0.25);
} else if (A <= 1.65e-60) {
tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = sqrt(((A * A) * ((-16.0 * (C * F)) + ((2.0 * (F * ((2.0 * (B_m * B_m)) + (-4.0 * (C * (C * 0.0)))))) / A)))) / t_0;
}
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 (a <= (-3d+136)) then
tmp = sqrt(((c * (a * c)) * (f * (-16.0d0)))) / t_0
else if (a <= (-1.9d-136)) then
tmp = 0.0d0 - (((f / a) * (f / a)) ** 0.25d0)
else if (a <= 1.65d-60) then
tmp = sqrt((2.0d0 * (f * (b_m * (b_m * b_m))))) / t_0
else
tmp = sqrt(((a * a) * (((-16.0d0) * (c * f)) + ((2.0d0 * (f * ((2.0d0 * (b_m * b_m)) + ((-4.0d0) * (c * (c * 0.0d0)))))) / a)))) / t_0
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 (A <= -3e+136) {
tmp = Math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -1.9e-136) {
tmp = 0.0 - Math.pow(((F / A) * (F / A)), 0.25);
} else if (A <= 1.65e-60) {
tmp = Math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = Math.sqrt(((A * A) * ((-16.0 * (C * F)) + ((2.0 * (F * ((2.0 * (B_m * B_m)) + (-4.0 * (C * (C * 0.0)))))) / A)))) / t_0;
}
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 A <= -3e+136: tmp = math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0 elif A <= -1.9e-136: tmp = 0.0 - math.pow(((F / A) * (F / A)), 0.25) elif A <= 1.65e-60: tmp = math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0 else: tmp = math.sqrt(((A * A) * ((-16.0 * (C * F)) + ((2.0 * (F * ((2.0 * (B_m * B_m)) + (-4.0 * (C * (C * 0.0)))))) / A)))) / t_0 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 (A <= -3e+136) tmp = Float64(sqrt(Float64(Float64(C * Float64(A * C)) * Float64(F * -16.0))) / t_0); elseif (A <= -1.9e-136) tmp = Float64(0.0 - (Float64(Float64(F / A) * Float64(F / A)) ^ 0.25)); elseif (A <= 1.65e-60) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(B_m * Float64(B_m * B_m))))) / t_0); else tmp = Float64(sqrt(Float64(Float64(A * A) * Float64(Float64(-16.0 * Float64(C * F)) + Float64(Float64(2.0 * Float64(F * Float64(Float64(2.0 * Float64(B_m * B_m)) + Float64(-4.0 * Float64(C * Float64(C * 0.0)))))) / A)))) / t_0); 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 (A <= -3e+136) tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0; elseif (A <= -1.9e-136) tmp = 0.0 - (((F / A) * (F / A)) ^ 0.25); elseif (A <= 1.65e-60) tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0; else tmp = sqrt(((A * A) * ((-16.0 * (C * F)) + ((2.0 * (F * ((2.0 * (B_m * B_m)) + (-4.0 * (C * (C * 0.0)))))) / A)))) / t_0; 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[A, -3e+136], N[(N[Sqrt[N[(N[(C * N[(A * C), $MachinePrecision]), $MachinePrecision] * N[(F * -16.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[A, -1.9e-136], N[(0.0 - N[Power[N[(N[(F / A), $MachinePrecision] * N[(F / A), $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.65e-60], N[(N[Sqrt[N[(2.0 * N[(F * N[(B$95$m * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[Sqrt[N[(N[(A * A), $MachinePrecision] * N[(N[(-16.0 * N[(C * F), $MachinePrecision]), $MachinePrecision] + N[(N[(2.0 * N[(F * N[(N[(2.0 * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] + N[(-4.0 * N[(C * N[(C * 0.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $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}\;A \leq -3 \cdot 10^{+136}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot \left(A \cdot C\right)\right) \cdot \left(F \cdot -16\right)}}{t\_0}\\
\mathbf{elif}\;A \leq -1.9 \cdot 10^{-136}:\\
\;\;\;\;0 - {\left(\frac{F}{A} \cdot \frac{F}{A}\right)}^{0.25}\\
\mathbf{elif}\;A \leq 1.65 \cdot 10^{-60}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{\left(A \cdot A\right) \cdot \left(-16 \cdot \left(C \cdot F\right) + \frac{2 \cdot \left(F \cdot \left(2 \cdot \left(B\_m \cdot B\_m\right) + -4 \cdot \left(C \cdot \left(C \cdot 0\right)\right)\right)\right)}{A}\right)}}{t\_0}\\
\end{array}
\end{array}
if A < -2.99999999999999979e136Initial program 1.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified2.5%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.7%
Simplified18.7%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6436.6%
Applied egg-rr36.6%
if -2.99999999999999979e136 < A < -1.9000000000000001e-136Initial program 14.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified14.3%
Taylor expanded in B around 0
Simplified10.1%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6410.0%
Simplified10.0%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f640.2%
Simplified0.2%
pow1/2N/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval28.9%
Applied egg-rr28.9%
if -1.9000000000000001e-136 < A < 1.6499999999999999e-60Initial program 30.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified33.0%
Taylor expanded in B around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.9%
Simplified11.9%
if 1.6499999999999999e-60 < A Initial program 28.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified34.7%
Taylor expanded in A around inf
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
Simplified24.7%
Final simplification23.4%
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 (<= A -4.3e+135)
(/ (sqrt (* (* C (* A C)) (* F -16.0))) t_0)
(if (<= A -1e-134)
(- 0.0 (pow (* (/ F A) (/ F A)) 0.25))
(if (<= A 9.2e-61)
(/ (sqrt (* 2.0 (* F (* B_m (* B_m B_m))))) t_0)
(*
(/ -1.0 (+ (* B_m B_m) (* C (* A -4.0))))
(sqrt
(+
(* F (* C (* -16.0 (* A A))))
(* B_m (* B_m (+ (/ (* F (* B_m B_m)) A) (* 4.0 (* A F)))))))))))))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 (A <= -4.3e+135) {
tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -1e-134) {
tmp = 0.0 - pow(((F / A) * (F / A)), 0.25);
} else if (A <= 9.2e-61) {
tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = (-1.0 / ((B_m * B_m) + (C * (A * -4.0)))) * sqrt(((F * (C * (-16.0 * (A * A)))) + (B_m * (B_m * (((F * (B_m * B_m)) / A) + (4.0 * (A * F)))))));
}
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 (a <= (-4.3d+135)) then
tmp = sqrt(((c * (a * c)) * (f * (-16.0d0)))) / t_0
else if (a <= (-1d-134)) then
tmp = 0.0d0 - (((f / a) * (f / a)) ** 0.25d0)
else if (a <= 9.2d-61) then
tmp = sqrt((2.0d0 * (f * (b_m * (b_m * b_m))))) / t_0
else
tmp = ((-1.0d0) / ((b_m * b_m) + (c * (a * (-4.0d0))))) * sqrt(((f * (c * ((-16.0d0) * (a * a)))) + (b_m * (b_m * (((f * (b_m * b_m)) / a) + (4.0d0 * (a * f)))))))
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 (A <= -4.3e+135) {
tmp = Math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -1e-134) {
tmp = 0.0 - Math.pow(((F / A) * (F / A)), 0.25);
} else if (A <= 9.2e-61) {
tmp = Math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = (-1.0 / ((B_m * B_m) + (C * (A * -4.0)))) * Math.sqrt(((F * (C * (-16.0 * (A * A)))) + (B_m * (B_m * (((F * (B_m * B_m)) / A) + (4.0 * (A * F)))))));
}
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 A <= -4.3e+135: tmp = math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0 elif A <= -1e-134: tmp = 0.0 - math.pow(((F / A) * (F / A)), 0.25) elif A <= 9.2e-61: tmp = math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0 else: tmp = (-1.0 / ((B_m * B_m) + (C * (A * -4.0)))) * math.sqrt(((F * (C * (-16.0 * (A * A)))) + (B_m * (B_m * (((F * (B_m * B_m)) / A) + (4.0 * (A * F))))))) 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 (A <= -4.3e+135) tmp = Float64(sqrt(Float64(Float64(C * Float64(A * C)) * Float64(F * -16.0))) / t_0); elseif (A <= -1e-134) tmp = Float64(0.0 - (Float64(Float64(F / A) * Float64(F / A)) ^ 0.25)); elseif (A <= 9.2e-61) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(B_m * Float64(B_m * B_m))))) / t_0); else tmp = Float64(Float64(-1.0 / Float64(Float64(B_m * B_m) + Float64(C * Float64(A * -4.0)))) * sqrt(Float64(Float64(F * Float64(C * Float64(-16.0 * Float64(A * A)))) + Float64(B_m * Float64(B_m * Float64(Float64(Float64(F * Float64(B_m * B_m)) / A) + Float64(4.0 * Float64(A * F)))))))); 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 (A <= -4.3e+135) tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0; elseif (A <= -1e-134) tmp = 0.0 - (((F / A) * (F / A)) ^ 0.25); elseif (A <= 9.2e-61) tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0; else tmp = (-1.0 / ((B_m * B_m) + (C * (A * -4.0)))) * sqrt(((F * (C * (-16.0 * (A * A)))) + (B_m * (B_m * (((F * (B_m * B_m)) / A) + (4.0 * (A * F))))))); 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[A, -4.3e+135], N[(N[Sqrt[N[(N[(C * N[(A * C), $MachinePrecision]), $MachinePrecision] * N[(F * -16.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[A, -1e-134], N[(0.0 - N[Power[N[(N[(F / A), $MachinePrecision] * N[(F / A), $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 9.2e-61], N[(N[Sqrt[N[(2.0 * N[(F * N[(B$95$m * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[(-1.0 / N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(C * N[(A * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[(F * N[(C * N[(-16.0 * N[(A * A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(B$95$m * N[(B$95$m * N[(N[(N[(F * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision] + N[(4.0 * N[(A * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $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}\;A \leq -4.3 \cdot 10^{+135}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot \left(A \cdot C\right)\right) \cdot \left(F \cdot -16\right)}}{t\_0}\\
\mathbf{elif}\;A \leq -1 \cdot 10^{-134}:\\
\;\;\;\;0 - {\left(\frac{F}{A} \cdot \frac{F}{A}\right)}^{0.25}\\
\mathbf{elif}\;A \leq 9.2 \cdot 10^{-61}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{-1}{B\_m \cdot B\_m + C \cdot \left(A \cdot -4\right)} \cdot \sqrt{F \cdot \left(C \cdot \left(-16 \cdot \left(A \cdot A\right)\right)\right) + B\_m \cdot \left(B\_m \cdot \left(\frac{F \cdot \left(B\_m \cdot B\_m\right)}{A} + 4 \cdot \left(A \cdot F\right)\right)\right)}\\
\end{array}
\end{array}
if A < -4.29999999999999972e135Initial program 1.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified2.5%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.7%
Simplified18.7%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6436.6%
Applied egg-rr36.6%
if -4.29999999999999972e135 < A < -1.00000000000000004e-134Initial program 14.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified14.3%
Taylor expanded in B around 0
Simplified10.1%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6410.0%
Simplified10.0%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f640.2%
Simplified0.2%
pow1/2N/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval28.9%
Applied egg-rr28.9%
if -1.00000000000000004e-134 < A < 9.19999999999999967e-61Initial program 30.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified33.0%
Taylor expanded in B around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.9%
Simplified11.9%
if 9.19999999999999967e-61 < A Initial program 28.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified34.7%
Taylor expanded in B around 0
Simplified22.3%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6422.3%
Simplified22.3%
Applied egg-rr22.5%
Final simplification22.6%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= A -2.1e+136)
(/ (sqrt (* (* C (* A C)) (* F -16.0))) t_0)
(if (<= A -1e-134)
(- 0.0 (pow (* (/ F A) (/ F A)) 0.25))
(if (<= A 4.6e-60)
(/ (sqrt (* 2.0 (* F (* B_m (* B_m B_m))))) t_0)
(/
(sqrt
(+
(* F (* C (* -16.0 (* A A))))
(* B_m (* B_m (+ (/ (* F (* B_m B_m)) A) (* 4.0 (* A F)))))))
t_0))))))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 (A <= -2.1e+136) {
tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -1e-134) {
tmp = 0.0 - pow(((F / A) * (F / A)), 0.25);
} else if (A <= 4.6e-60) {
tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = sqrt(((F * (C * (-16.0 * (A * A)))) + (B_m * (B_m * (((F * (B_m * B_m)) / A) + (4.0 * (A * F))))))) / t_0;
}
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 (a <= (-2.1d+136)) then
tmp = sqrt(((c * (a * c)) * (f * (-16.0d0)))) / t_0
else if (a <= (-1d-134)) then
tmp = 0.0d0 - (((f / a) * (f / a)) ** 0.25d0)
else if (a <= 4.6d-60) then
tmp = sqrt((2.0d0 * (f * (b_m * (b_m * b_m))))) / t_0
else
tmp = sqrt(((f * (c * ((-16.0d0) * (a * a)))) + (b_m * (b_m * (((f * (b_m * b_m)) / a) + (4.0d0 * (a * f))))))) / t_0
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 (A <= -2.1e+136) {
tmp = Math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -1e-134) {
tmp = 0.0 - Math.pow(((F / A) * (F / A)), 0.25);
} else if (A <= 4.6e-60) {
tmp = Math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = Math.sqrt(((F * (C * (-16.0 * (A * A)))) + (B_m * (B_m * (((F * (B_m * B_m)) / A) + (4.0 * (A * F))))))) / t_0;
}
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 A <= -2.1e+136: tmp = math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0 elif A <= -1e-134: tmp = 0.0 - math.pow(((F / A) * (F / A)), 0.25) elif A <= 4.6e-60: tmp = math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0 else: tmp = math.sqrt(((F * (C * (-16.0 * (A * A)))) + (B_m * (B_m * (((F * (B_m * B_m)) / A) + (4.0 * (A * F))))))) / t_0 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 (A <= -2.1e+136) tmp = Float64(sqrt(Float64(Float64(C * Float64(A * C)) * Float64(F * -16.0))) / t_0); elseif (A <= -1e-134) tmp = Float64(0.0 - (Float64(Float64(F / A) * Float64(F / A)) ^ 0.25)); elseif (A <= 4.6e-60) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(B_m * Float64(B_m * B_m))))) / t_0); else tmp = Float64(sqrt(Float64(Float64(F * Float64(C * Float64(-16.0 * Float64(A * A)))) + Float64(B_m * Float64(B_m * Float64(Float64(Float64(F * Float64(B_m * B_m)) / A) + Float64(4.0 * Float64(A * F))))))) / t_0); 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 (A <= -2.1e+136) tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0; elseif (A <= -1e-134) tmp = 0.0 - (((F / A) * (F / A)) ^ 0.25); elseif (A <= 4.6e-60) tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0; else tmp = sqrt(((F * (C * (-16.0 * (A * A)))) + (B_m * (B_m * (((F * (B_m * B_m)) / A) + (4.0 * (A * F))))))) / t_0; 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[A, -2.1e+136], N[(N[Sqrt[N[(N[(C * N[(A * C), $MachinePrecision]), $MachinePrecision] * N[(F * -16.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[A, -1e-134], N[(0.0 - N[Power[N[(N[(F / A), $MachinePrecision] * N[(F / A), $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 4.6e-60], N[(N[Sqrt[N[(2.0 * N[(F * N[(B$95$m * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[Sqrt[N[(N[(F * N[(C * N[(-16.0 * N[(A * A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(B$95$m * N[(B$95$m * N[(N[(N[(F * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision] + N[(4.0 * N[(A * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $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}\;A \leq -2.1 \cdot 10^{+136}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot \left(A \cdot C\right)\right) \cdot \left(F \cdot -16\right)}}{t\_0}\\
\mathbf{elif}\;A \leq -1 \cdot 10^{-134}:\\
\;\;\;\;0 - {\left(\frac{F}{A} \cdot \frac{F}{A}\right)}^{0.25}\\
\mathbf{elif}\;A \leq 4.6 \cdot 10^{-60}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{F \cdot \left(C \cdot \left(-16 \cdot \left(A \cdot A\right)\right)\right) + B\_m \cdot \left(B\_m \cdot \left(\frac{F \cdot \left(B\_m \cdot B\_m\right)}{A} + 4 \cdot \left(A \cdot F\right)\right)\right)}}{t\_0}\\
\end{array}
\end{array}
if A < -2.0999999999999999e136Initial program 1.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified2.5%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.7%
Simplified18.7%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6436.6%
Applied egg-rr36.6%
if -2.0999999999999999e136 < A < -1.00000000000000004e-134Initial program 14.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified14.3%
Taylor expanded in B around 0
Simplified10.1%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6410.0%
Simplified10.0%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f640.2%
Simplified0.2%
pow1/2N/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval28.9%
Applied egg-rr28.9%
if -1.00000000000000004e-134 < A < 4.6000000000000003e-60Initial program 30.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified33.0%
Taylor expanded in B around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.9%
Simplified11.9%
if 4.6000000000000003e-60 < A Initial program 28.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified34.7%
Taylor expanded in B around 0
Simplified22.3%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6422.3%
Simplified22.3%
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
associate-*r*N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
distribute-lft-inN/A
Applied egg-rr22.4%
Final simplification22.6%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= A -1.15e+136)
(/ (sqrt (* (* C (* A C)) (* F -16.0))) t_0)
(if (<= A -4.6e-133)
(- 0.0 (pow (* (/ F A) (/ F A)) 0.25))
(if (<= A 4.5e-59)
(/ (sqrt (* 2.0 (* F (* B_m (* B_m B_m))))) t_0)
(*
(sqrt
(*
F
(+
(* -16.0 (* C (* A A)))
(/ (* (* B_m B_m) (+ (* B_m B_m) (* 4.0 (* A A)))) A))))
(/ 1.0 (- (* 4.0 (* A C)) (* B_m 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 (A <= -1.15e+136) {
tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -4.6e-133) {
tmp = 0.0 - pow(((F / A) * (F / A)), 0.25);
} else if (A <= 4.5e-59) {
tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = sqrt((F * ((-16.0 * (C * (A * A))) + (((B_m * B_m) * ((B_m * B_m) + (4.0 * (A * A)))) / A)))) * (1.0 / ((4.0 * (A * C)) - (B_m * 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 (a <= (-1.15d+136)) then
tmp = sqrt(((c * (a * c)) * (f * (-16.0d0)))) / t_0
else if (a <= (-4.6d-133)) then
tmp = 0.0d0 - (((f / a) * (f / a)) ** 0.25d0)
else if (a <= 4.5d-59) then
tmp = sqrt((2.0d0 * (f * (b_m * (b_m * b_m))))) / t_0
else
tmp = sqrt((f * (((-16.0d0) * (c * (a * a))) + (((b_m * b_m) * ((b_m * b_m) + (4.0d0 * (a * a)))) / a)))) * (1.0d0 / ((4.0d0 * (a * c)) - (b_m * 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 (A <= -1.15e+136) {
tmp = Math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -4.6e-133) {
tmp = 0.0 - Math.pow(((F / A) * (F / A)), 0.25);
} else if (A <= 4.5e-59) {
tmp = Math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = Math.sqrt((F * ((-16.0 * (C * (A * A))) + (((B_m * B_m) * ((B_m * B_m) + (4.0 * (A * A)))) / A)))) * (1.0 / ((4.0 * (A * C)) - (B_m * 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 A <= -1.15e+136: tmp = math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0 elif A <= -4.6e-133: tmp = 0.0 - math.pow(((F / A) * (F / A)), 0.25) elif A <= 4.5e-59: tmp = math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0 else: tmp = math.sqrt((F * ((-16.0 * (C * (A * A))) + (((B_m * B_m) * ((B_m * B_m) + (4.0 * (A * A)))) / A)))) * (1.0 / ((4.0 * (A * C)) - (B_m * 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 (A <= -1.15e+136) tmp = Float64(sqrt(Float64(Float64(C * Float64(A * C)) * Float64(F * -16.0))) / t_0); elseif (A <= -4.6e-133) tmp = Float64(0.0 - (Float64(Float64(F / A) * Float64(F / A)) ^ 0.25)); elseif (A <= 4.5e-59) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(B_m * Float64(B_m * B_m))))) / t_0); else tmp = Float64(sqrt(Float64(F * Float64(Float64(-16.0 * Float64(C * Float64(A * A))) + Float64(Float64(Float64(B_m * B_m) * Float64(Float64(B_m * B_m) + Float64(4.0 * Float64(A * A)))) / A)))) * Float64(1.0 / Float64(Float64(4.0 * Float64(A * C)) - Float64(B_m * 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 (A <= -1.15e+136) tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0; elseif (A <= -4.6e-133) tmp = 0.0 - (((F / A) * (F / A)) ^ 0.25); elseif (A <= 4.5e-59) tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0; else tmp = sqrt((F * ((-16.0 * (C * (A * A))) + (((B_m * B_m) * ((B_m * B_m) + (4.0 * (A * A)))) / A)))) * (1.0 / ((4.0 * (A * C)) - (B_m * 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[A, -1.15e+136], N[(N[Sqrt[N[(N[(C * N[(A * C), $MachinePrecision]), $MachinePrecision] * N[(F * -16.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[A, -4.6e-133], N[(0.0 - N[Power[N[(N[(F / A), $MachinePrecision] * N[(F / A), $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 4.5e-59], N[(N[Sqrt[N[(2.0 * N[(F * N[(B$95$m * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[Sqrt[N[(F * N[(N[(-16.0 * N[(C * N[(A * A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(B$95$m * B$95$m), $MachinePrecision] * N[(N[(B$95$m * B$95$m), $MachinePrecision] + N[(4.0 * N[(A * A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(1.0 / N[(N[(4.0 * N[(A * C), $MachinePrecision]), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $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}\;A \leq -1.15 \cdot 10^{+136}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot \left(A \cdot C\right)\right) \cdot \left(F \cdot -16\right)}}{t\_0}\\
\mathbf{elif}\;A \leq -4.6 \cdot 10^{-133}:\\
\;\;\;\;0 - {\left(\frac{F}{A} \cdot \frac{F}{A}\right)}^{0.25}\\
\mathbf{elif}\;A \leq 4.5 \cdot 10^{-59}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\sqrt{F \cdot \left(-16 \cdot \left(C \cdot \left(A \cdot A\right)\right) + \frac{\left(B\_m \cdot B\_m\right) \cdot \left(B\_m \cdot B\_m + 4 \cdot \left(A \cdot A\right)\right)}{A}\right)} \cdot \frac{1}{4 \cdot \left(A \cdot C\right) - B\_m \cdot B\_m}\\
\end{array}
\end{array}
if A < -1.15e136Initial program 1.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified2.5%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.7%
Simplified18.7%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6436.6%
Applied egg-rr36.6%
if -1.15e136 < A < -4.6000000000000001e-133Initial program 14.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified14.3%
Taylor expanded in B around 0
Simplified10.1%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6410.0%
Simplified10.0%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f640.2%
Simplified0.2%
pow1/2N/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval28.9%
Applied egg-rr28.9%
if -4.6000000000000001e-133 < A < 4.50000000000000012e-59Initial program 30.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified33.0%
Taylor expanded in B around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.9%
Simplified11.9%
if 4.50000000000000012e-59 < A Initial program 28.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified34.7%
Taylor expanded in B around 0
Simplified22.3%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6422.3%
Simplified22.3%
Taylor expanded in A around 0
/-lowering-/.f64N/A
+-commutativeN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6421.1%
Simplified21.1%
Taylor expanded in F around 0
*-lowering-*.f64N/A
Simplified22.4%
Final simplification22.6%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= A -1.6e+136)
(/ (sqrt (* (* C (* A C)) (* F -16.0))) t_0)
(if (<= A -4.8e-133)
(- 0.0 (pow (* (/ F A) (/ F A)) 0.25))
(if (<= A 1.85e-60)
(/ (sqrt (* 2.0 (* F (* B_m (* B_m B_m))))) t_0)
(/
(sqrt
(+ (* (* C F) (* -16.0 (* A A))) (* (* B_m B_m) (* 4.0 (* A F)))))
t_0))))))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 (A <= -1.6e+136) {
tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -4.8e-133) {
tmp = 0.0 - pow(((F / A) * (F / A)), 0.25);
} else if (A <= 1.85e-60) {
tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = sqrt((((C * F) * (-16.0 * (A * A))) + ((B_m * B_m) * (4.0 * (A * F))))) / t_0;
}
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 (a <= (-1.6d+136)) then
tmp = sqrt(((c * (a * c)) * (f * (-16.0d0)))) / t_0
else if (a <= (-4.8d-133)) then
tmp = 0.0d0 - (((f / a) * (f / a)) ** 0.25d0)
else if (a <= 1.85d-60) then
tmp = sqrt((2.0d0 * (f * (b_m * (b_m * b_m))))) / t_0
else
tmp = sqrt((((c * f) * ((-16.0d0) * (a * a))) + ((b_m * b_m) * (4.0d0 * (a * f))))) / t_0
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 (A <= -1.6e+136) {
tmp = Math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -4.8e-133) {
tmp = 0.0 - Math.pow(((F / A) * (F / A)), 0.25);
} else if (A <= 1.85e-60) {
tmp = Math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = Math.sqrt((((C * F) * (-16.0 * (A * A))) + ((B_m * B_m) * (4.0 * (A * F))))) / t_0;
}
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 A <= -1.6e+136: tmp = math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0 elif A <= -4.8e-133: tmp = 0.0 - math.pow(((F / A) * (F / A)), 0.25) elif A <= 1.85e-60: tmp = math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0 else: tmp = math.sqrt((((C * F) * (-16.0 * (A * A))) + ((B_m * B_m) * (4.0 * (A * F))))) / t_0 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 (A <= -1.6e+136) tmp = Float64(sqrt(Float64(Float64(C * Float64(A * C)) * Float64(F * -16.0))) / t_0); elseif (A <= -4.8e-133) tmp = Float64(0.0 - (Float64(Float64(F / A) * Float64(F / A)) ^ 0.25)); elseif (A <= 1.85e-60) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(B_m * Float64(B_m * B_m))))) / t_0); else tmp = Float64(sqrt(Float64(Float64(Float64(C * F) * Float64(-16.0 * Float64(A * A))) + Float64(Float64(B_m * B_m) * Float64(4.0 * Float64(A * F))))) / t_0); 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 (A <= -1.6e+136) tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0; elseif (A <= -4.8e-133) tmp = 0.0 - (((F / A) * (F / A)) ^ 0.25); elseif (A <= 1.85e-60) tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0; else tmp = sqrt((((C * F) * (-16.0 * (A * A))) + ((B_m * B_m) * (4.0 * (A * F))))) / t_0; 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[A, -1.6e+136], N[(N[Sqrt[N[(N[(C * N[(A * C), $MachinePrecision]), $MachinePrecision] * N[(F * -16.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[A, -4.8e-133], N[(0.0 - N[Power[N[(N[(F / A), $MachinePrecision] * N[(F / A), $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 1.85e-60], N[(N[Sqrt[N[(2.0 * N[(F * N[(B$95$m * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[Sqrt[N[(N[(N[(C * F), $MachinePrecision] * N[(-16.0 * N[(A * A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(B$95$m * B$95$m), $MachinePrecision] * N[(4.0 * N[(A * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $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}\;A \leq -1.6 \cdot 10^{+136}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot \left(A \cdot C\right)\right) \cdot \left(F \cdot -16\right)}}{t\_0}\\
\mathbf{elif}\;A \leq -4.8 \cdot 10^{-133}:\\
\;\;\;\;0 - {\left(\frac{F}{A} \cdot \frac{F}{A}\right)}^{0.25}\\
\mathbf{elif}\;A \leq 1.85 \cdot 10^{-60}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot F\right) \cdot \left(-16 \cdot \left(A \cdot A\right)\right) + \left(B\_m \cdot B\_m\right) \cdot \left(4 \cdot \left(A \cdot F\right)\right)}}{t\_0}\\
\end{array}
\end{array}
if A < -1.59999999999999994e136Initial program 1.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified2.5%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.7%
Simplified18.7%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6436.6%
Applied egg-rr36.6%
if -1.59999999999999994e136 < A < -4.8e-133Initial program 14.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified14.3%
Taylor expanded in B around 0
Simplified10.1%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6410.0%
Simplified10.0%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f640.2%
Simplified0.2%
pow1/2N/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval28.9%
Applied egg-rr28.9%
if -4.8e-133 < A < 1.85000000000000012e-60Initial program 30.3%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified33.0%
Taylor expanded in B around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.9%
Simplified11.9%
if 1.85000000000000012e-60 < A Initial program 28.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified34.7%
Taylor expanded in B around 0
Simplified22.3%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6422.3%
Simplified22.3%
Taylor expanded in B around 0
*-lowering-*.f64N/A
*-lowering-*.f6422.3%
Simplified22.3%
Final simplification22.5%
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 (<= A -9.5e+135)
(/ (sqrt (* (* C (* A C)) (* F -16.0))) t_0)
(if (<= A -1.3e-138)
(- 0.0 (pow (* (/ F A) (/ F A)) 0.25))
(if (<= A 3.6e-35)
(/ (sqrt (* 2.0 (* F (* B_m (* B_m B_m))))) t_0)
(/ 1.0 (/ t_0 (sqrt (* -16.0 (* (* A A) (* C F)))))))))))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 (A <= -9.5e+135) {
tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -1.3e-138) {
tmp = 0.0 - pow(((F / A) * (F / A)), 0.25);
} else if (A <= 3.6e-35) {
tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = 1.0 / (t_0 / sqrt((-16.0 * ((A * A) * (C * F)))));
}
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 (a <= (-9.5d+135)) then
tmp = sqrt(((c * (a * c)) * (f * (-16.0d0)))) / t_0
else if (a <= (-1.3d-138)) then
tmp = 0.0d0 - (((f / a) * (f / a)) ** 0.25d0)
else if (a <= 3.6d-35) then
tmp = sqrt((2.0d0 * (f * (b_m * (b_m * b_m))))) / t_0
else
tmp = 1.0d0 / (t_0 / sqrt(((-16.0d0) * ((a * a) * (c * f)))))
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 (A <= -9.5e+135) {
tmp = Math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -1.3e-138) {
tmp = 0.0 - Math.pow(((F / A) * (F / A)), 0.25);
} else if (A <= 3.6e-35) {
tmp = Math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = 1.0 / (t_0 / Math.sqrt((-16.0 * ((A * A) * (C * F)))));
}
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 A <= -9.5e+135: tmp = math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0 elif A <= -1.3e-138: tmp = 0.0 - math.pow(((F / A) * (F / A)), 0.25) elif A <= 3.6e-35: tmp = math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0 else: tmp = 1.0 / (t_0 / math.sqrt((-16.0 * ((A * A) * (C * F))))) 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 (A <= -9.5e+135) tmp = Float64(sqrt(Float64(Float64(C * Float64(A * C)) * Float64(F * -16.0))) / t_0); elseif (A <= -1.3e-138) tmp = Float64(0.0 - (Float64(Float64(F / A) * Float64(F / A)) ^ 0.25)); elseif (A <= 3.6e-35) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(B_m * Float64(B_m * B_m))))) / t_0); else tmp = Float64(1.0 / Float64(t_0 / sqrt(Float64(-16.0 * Float64(Float64(A * A) * Float64(C * F)))))); 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 (A <= -9.5e+135) tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0; elseif (A <= -1.3e-138) tmp = 0.0 - (((F / A) * (F / A)) ^ 0.25); elseif (A <= 3.6e-35) tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0; else tmp = 1.0 / (t_0 / sqrt((-16.0 * ((A * A) * (C * F))))); 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[A, -9.5e+135], N[(N[Sqrt[N[(N[(C * N[(A * C), $MachinePrecision]), $MachinePrecision] * N[(F * -16.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[A, -1.3e-138], N[(0.0 - N[Power[N[(N[(F / A), $MachinePrecision] * N[(F / A), $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 3.6e-35], N[(N[Sqrt[N[(2.0 * N[(F * N[(B$95$m * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(1.0 / N[(t$95$0 / N[Sqrt[N[(-16.0 * N[(N[(A * A), $MachinePrecision] * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $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}\;A \leq -9.5 \cdot 10^{+135}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot \left(A \cdot C\right)\right) \cdot \left(F \cdot -16\right)}}{t\_0}\\
\mathbf{elif}\;A \leq -1.3 \cdot 10^{-138}:\\
\;\;\;\;0 - {\left(\frac{F}{A} \cdot \frac{F}{A}\right)}^{0.25}\\
\mathbf{elif}\;A \leq 3.6 \cdot 10^{-35}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{1}{\frac{t\_0}{\sqrt{-16 \cdot \left(\left(A \cdot A\right) \cdot \left(C \cdot F\right)\right)}}}\\
\end{array}
\end{array}
if A < -9.50000000000000036e135Initial program 1.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified2.5%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.7%
Simplified18.7%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6436.6%
Applied egg-rr36.6%
if -9.50000000000000036e135 < A < -1.3e-138Initial program 14.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified14.3%
Taylor expanded in B around 0
Simplified10.1%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6410.0%
Simplified10.0%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f640.2%
Simplified0.2%
pow1/2N/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval28.9%
Applied egg-rr28.9%
if -1.3e-138 < A < 3.60000000000000019e-35Initial program 32.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified34.6%
Taylor expanded in B around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.0%
Simplified11.0%
if 3.60000000000000019e-35 < A Initial program 25.8%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified33.1%
Applied egg-rr29.9%
Taylor expanded in B around 0
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6420.0%
Simplified20.0%
Final simplification21.2%
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 (<= A -2.4e+136)
(/ (sqrt (* (* C (* A C)) (* F -16.0))) t_0)
(if (<= A -2.8e-133)
(- 0.0 (pow (* (/ F A) (/ F A)) 0.25))
(if (<= A 4.2e-35)
(/ (sqrt (* 2.0 (* F (* B_m (* B_m B_m))))) t_0)
(/ (sqrt (* (* C F) (* -16.0 (* A A)))) t_0))))))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 (A <= -2.4e+136) {
tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -2.8e-133) {
tmp = 0.0 - pow(((F / A) * (F / A)), 0.25);
} else if (A <= 4.2e-35) {
tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = sqrt(((C * F) * (-16.0 * (A * A)))) / t_0;
}
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 (a <= (-2.4d+136)) then
tmp = sqrt(((c * (a * c)) * (f * (-16.0d0)))) / t_0
else if (a <= (-2.8d-133)) then
tmp = 0.0d0 - (((f / a) * (f / a)) ** 0.25d0)
else if (a <= 4.2d-35) then
tmp = sqrt((2.0d0 * (f * (b_m * (b_m * b_m))))) / t_0
else
tmp = sqrt(((c * f) * ((-16.0d0) * (a * a)))) / t_0
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 (A <= -2.4e+136) {
tmp = Math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0;
} else if (A <= -2.8e-133) {
tmp = 0.0 - Math.pow(((F / A) * (F / A)), 0.25);
} else if (A <= 4.2e-35) {
tmp = Math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = Math.sqrt(((C * F) * (-16.0 * (A * A)))) / t_0;
}
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 A <= -2.4e+136: tmp = math.sqrt(((C * (A * C)) * (F * -16.0))) / t_0 elif A <= -2.8e-133: tmp = 0.0 - math.pow(((F / A) * (F / A)), 0.25) elif A <= 4.2e-35: tmp = math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0 else: tmp = math.sqrt(((C * F) * (-16.0 * (A * A)))) / t_0 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 (A <= -2.4e+136) tmp = Float64(sqrt(Float64(Float64(C * Float64(A * C)) * Float64(F * -16.0))) / t_0); elseif (A <= -2.8e-133) tmp = Float64(0.0 - (Float64(Float64(F / A) * Float64(F / A)) ^ 0.25)); elseif (A <= 4.2e-35) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(B_m * Float64(B_m * B_m))))) / t_0); else tmp = Float64(sqrt(Float64(Float64(C * F) * Float64(-16.0 * Float64(A * A)))) / t_0); 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 (A <= -2.4e+136) tmp = sqrt(((C * (A * C)) * (F * -16.0))) / t_0; elseif (A <= -2.8e-133) tmp = 0.0 - (((F / A) * (F / A)) ^ 0.25); elseif (A <= 4.2e-35) tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0; else tmp = sqrt(((C * F) * (-16.0 * (A * A)))) / t_0; 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[A, -2.4e+136], N[(N[Sqrt[N[(N[(C * N[(A * C), $MachinePrecision]), $MachinePrecision] * N[(F * -16.0), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[A, -2.8e-133], N[(0.0 - N[Power[N[(N[(F / A), $MachinePrecision] * N[(F / A), $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 4.2e-35], N[(N[Sqrt[N[(2.0 * N[(F * N[(B$95$m * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[Sqrt[N[(N[(C * F), $MachinePrecision] * N[(-16.0 * N[(A * A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $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}\;A \leq -2.4 \cdot 10^{+136}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot \left(A \cdot C\right)\right) \cdot \left(F \cdot -16\right)}}{t\_0}\\
\mathbf{elif}\;A \leq -2.8 \cdot 10^{-133}:\\
\;\;\;\;0 - {\left(\frac{F}{A} \cdot \frac{F}{A}\right)}^{0.25}\\
\mathbf{elif}\;A \leq 4.2 \cdot 10^{-35}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot F\right) \cdot \left(-16 \cdot \left(A \cdot A\right)\right)}}{t\_0}\\
\end{array}
\end{array}
if A < -2.4e136Initial program 1.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified2.5%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.7%
Simplified18.7%
*-commutativeN/A
associate-*r*N/A
associate-*l*N/A
*-lowering-*.f64N/A
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6436.6%
Applied egg-rr36.6%
if -2.4e136 < A < -2.7999999999999999e-133Initial program 14.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified14.3%
Taylor expanded in B around 0
Simplified10.1%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6410.0%
Simplified10.0%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f640.2%
Simplified0.2%
pow1/2N/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval28.9%
Applied egg-rr28.9%
if -2.7999999999999999e-133 < A < 4.2e-35Initial program 32.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified34.6%
Taylor expanded in B around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.0%
Simplified11.0%
if 4.2e-35 < A Initial program 25.8%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified33.1%
Taylor expanded in B around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6419.9%
Simplified19.9%
Final simplification21.2%
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 (<= A -5.5e-133)
(- 0.0 (pow (* (/ F A) (/ F A)) 0.25))
(if (<= A 4.7e-35)
(/ (sqrt (* 2.0 (* F (* B_m (* B_m B_m))))) t_0)
(/ (sqrt (* (* C F) (* -16.0 (* A A)))) t_0)))))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 (A <= -5.5e-133) {
tmp = 0.0 - pow(((F / A) * (F / A)), 0.25);
} else if (A <= 4.7e-35) {
tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = sqrt(((C * F) * (-16.0 * (A * A)))) / t_0;
}
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 (a <= (-5.5d-133)) then
tmp = 0.0d0 - (((f / a) * (f / a)) ** 0.25d0)
else if (a <= 4.7d-35) then
tmp = sqrt((2.0d0 * (f * (b_m * (b_m * b_m))))) / t_0
else
tmp = sqrt(((c * f) * ((-16.0d0) * (a * a)))) / t_0
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 (A <= -5.5e-133) {
tmp = 0.0 - Math.pow(((F / A) * (F / A)), 0.25);
} else if (A <= 4.7e-35) {
tmp = Math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = Math.sqrt(((C * F) * (-16.0 * (A * A)))) / t_0;
}
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 A <= -5.5e-133: tmp = 0.0 - math.pow(((F / A) * (F / A)), 0.25) elif A <= 4.7e-35: tmp = math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0 else: tmp = math.sqrt(((C * F) * (-16.0 * (A * A)))) / t_0 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 (A <= -5.5e-133) tmp = Float64(0.0 - (Float64(Float64(F / A) * Float64(F / A)) ^ 0.25)); elseif (A <= 4.7e-35) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(B_m * Float64(B_m * B_m))))) / t_0); else tmp = Float64(sqrt(Float64(Float64(C * F) * Float64(-16.0 * Float64(A * A)))) / t_0); 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 (A <= -5.5e-133) tmp = 0.0 - (((F / A) * (F / A)) ^ 0.25); elseif (A <= 4.7e-35) tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0; else tmp = sqrt(((C * F) * (-16.0 * (A * A)))) / t_0; 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[A, -5.5e-133], N[(0.0 - N[Power[N[(N[(F / A), $MachinePrecision] * N[(F / A), $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]), $MachinePrecision], If[LessEqual[A, 4.7e-35], N[(N[Sqrt[N[(2.0 * N[(F * N[(B$95$m * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(N[Sqrt[N[(N[(C * F), $MachinePrecision] * N[(-16.0 * N[(A * A), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $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}\;A \leq -5.5 \cdot 10^{-133}:\\
\;\;\;\;0 - {\left(\frac{F}{A} \cdot \frac{F}{A}\right)}^{0.25}\\
\mathbf{elif}\;A \leq 4.7 \cdot 10^{-35}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{\left(C \cdot F\right) \cdot \left(-16 \cdot \left(A \cdot A\right)\right)}}{t\_0}\\
\end{array}
\end{array}
if A < -5.49999999999999977e-133Initial program 8.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified9.5%
Taylor expanded in B around 0
Simplified6.2%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f646.1%
Simplified6.1%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f641.1%
Simplified1.1%
pow1/2N/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval27.4%
Applied egg-rr27.4%
if -5.49999999999999977e-133 < A < 4.7e-35Initial program 32.2%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified34.6%
Taylor expanded in B around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6411.0%
Simplified11.0%
if 4.7e-35 < A Initial program 25.8%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified33.1%
Taylor expanded in B around 0
associate-*r*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f6419.9%
Simplified19.9%
Final simplification19.6%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(let* ((t_0 (- (* (* 4.0 A) C) (* B_m B_m))))
(if (<= B_m 7.4e-71)
(/ (sqrt (* -16.0 (* C (* A (* C F))))) t_0)
(if (<= B_m 9.8e+78)
(/ (sqrt (* 2.0 (* F (* B_m (* B_m B_m))))) t_0)
(- 0.0 (pow (* (/ F A) (/ F A)) 0.25))))))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 <= 7.4e-71) {
tmp = sqrt((-16.0 * (C * (A * (C * F))))) / t_0;
} else if (B_m <= 9.8e+78) {
tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = 0.0 - pow(((F / A) * (F / A)), 0.25);
}
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 <= 7.4d-71) then
tmp = sqrt(((-16.0d0) * (c * (a * (c * f))))) / t_0
else if (b_m <= 9.8d+78) then
tmp = sqrt((2.0d0 * (f * (b_m * (b_m * b_m))))) / t_0
else
tmp = 0.0d0 - (((f / a) * (f / a)) ** 0.25d0)
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 <= 7.4e-71) {
tmp = Math.sqrt((-16.0 * (C * (A * (C * F))))) / t_0;
} else if (B_m <= 9.8e+78) {
tmp = Math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0;
} else {
tmp = 0.0 - Math.pow(((F / A) * (F / A)), 0.25);
}
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 <= 7.4e-71: tmp = math.sqrt((-16.0 * (C * (A * (C * F))))) / t_0 elif B_m <= 9.8e+78: tmp = math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0 else: tmp = 0.0 - math.pow(((F / A) * (F / A)), 0.25) 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 <= 7.4e-71) tmp = Float64(sqrt(Float64(-16.0 * Float64(C * Float64(A * Float64(C * F))))) / t_0); elseif (B_m <= 9.8e+78) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(B_m * Float64(B_m * B_m))))) / t_0); else tmp = Float64(0.0 - (Float64(Float64(F / A) * Float64(F / A)) ^ 0.25)); 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 <= 7.4e-71) tmp = sqrt((-16.0 * (C * (A * (C * F))))) / t_0; elseif (B_m <= 9.8e+78) tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / t_0; else tmp = 0.0 - (((F / A) * (F / A)) ^ 0.25); 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, 7.4e-71], N[(N[Sqrt[N[(-16.0 * N[(C * N[(A * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], If[LessEqual[B$95$m, 9.8e+78], N[(N[Sqrt[N[(2.0 * N[(F * N[(B$95$m * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / t$95$0), $MachinePrecision], N[(0.0 - N[Power[N[(N[(F / A), $MachinePrecision] * N[(F / A), $MachinePrecision]), $MachinePrecision], 0.25], $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 7.4 \cdot 10^{-71}:\\
\;\;\;\;\frac{\sqrt{-16 \cdot \left(C \cdot \left(A \cdot \left(C \cdot F\right)\right)\right)}}{t\_0}\\
\mathbf{elif}\;B\_m \leq 9.8 \cdot 10^{+78}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{t\_0}\\
\mathbf{else}:\\
\;\;\;\;0 - {\left(\frac{F}{A} \cdot \frac{F}{A}\right)}^{0.25}\\
\end{array}
\end{array}
if B < 7.3999999999999993e-71Initial program 24.6%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified29.4%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6412.1%
Simplified12.1%
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6416.8%
Applied egg-rr16.8%
if 7.3999999999999993e-71 < B < 9.8000000000000004e78Initial program 36.0%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified36.7%
Taylor expanded in B around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6427.1%
Simplified27.1%
if 9.8000000000000004e78 < B Initial program 5.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified5.9%
Taylor expanded in B around 0
Simplified0.6%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f640.3%
Simplified0.3%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f643.2%
Simplified3.2%
pow1/2N/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval9.8%
Applied egg-rr9.8%
Final simplification16.5%
B_m = (fabs.f64 B)
(FPCore (A B_m C F)
:precision binary64
(if (<= B_m 1.45e-69)
(/ (sqrt (* -16.0 (* C (* A (* C F))))) (- (* (* 4.0 A) C) (* B_m B_m)))
(if (<= B_m 4e+77)
(/ (sqrt (* 2.0 (* F (* B_m (* B_m B_m))))) (- 0.0 (* B_m B_m)))
(- 0.0 (pow (* (/ F A) (/ F A)) 0.25)))))B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (B_m <= 1.45e-69) {
tmp = sqrt((-16.0 * (C * (A * (C * F))))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (B_m <= 4e+77) {
tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / (0.0 - (B_m * B_m));
} else {
tmp = 0.0 - pow(((F / A) * (F / A)), 0.25);
}
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.45d-69) then
tmp = sqrt(((-16.0d0) * (c * (a * (c * f))))) / (((4.0d0 * a) * c) - (b_m * b_m))
else if (b_m <= 4d+77) then
tmp = sqrt((2.0d0 * (f * (b_m * (b_m * b_m))))) / (0.0d0 - (b_m * b_m))
else
tmp = 0.0d0 - (((f / a) * (f / a)) ** 0.25d0)
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.45e-69) {
tmp = Math.sqrt((-16.0 * (C * (A * (C * F))))) / (((4.0 * A) * C) - (B_m * B_m));
} else if (B_m <= 4e+77) {
tmp = Math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / (0.0 - (B_m * B_m));
} else {
tmp = 0.0 - Math.pow(((F / A) * (F / A)), 0.25);
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if B_m <= 1.45e-69: tmp = math.sqrt((-16.0 * (C * (A * (C * F))))) / (((4.0 * A) * C) - (B_m * B_m)) elif B_m <= 4e+77: tmp = math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / (0.0 - (B_m * B_m)) else: tmp = 0.0 - math.pow(((F / A) * (F / A)), 0.25) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (B_m <= 1.45e-69) tmp = Float64(sqrt(Float64(-16.0 * Float64(C * Float64(A * Float64(C * F))))) / Float64(Float64(Float64(4.0 * A) * C) - Float64(B_m * B_m))); elseif (B_m <= 4e+77) tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(B_m * Float64(B_m * B_m))))) / Float64(0.0 - Float64(B_m * B_m))); else tmp = Float64(0.0 - (Float64(Float64(F / A) * Float64(F / A)) ^ 0.25)); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (B_m <= 1.45e-69) tmp = sqrt((-16.0 * (C * (A * (C * F))))) / (((4.0 * A) * C) - (B_m * B_m)); elseif (B_m <= 4e+77) tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / (0.0 - (B_m * B_m)); else tmp = 0.0 - (((F / A) * (F / A)) ^ 0.25); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[B$95$m, 1.45e-69], N[(N[Sqrt[N[(-16.0 * N[(C * N[(A * N[(C * F), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(N[(N[(4.0 * A), $MachinePrecision] * C), $MachinePrecision] - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[B$95$m, 4e+77], N[(N[Sqrt[N[(2.0 * N[(F * N[(B$95$m * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.0 - N[Power[N[(N[(F / A), $MachinePrecision] * N[(F / A), $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;B\_m \leq 1.45 \cdot 10^{-69}:\\
\;\;\;\;\frac{\sqrt{-16 \cdot \left(C \cdot \left(A \cdot \left(C \cdot F\right)\right)\right)}}{\left(4 \cdot A\right) \cdot C - B\_m \cdot B\_m}\\
\mathbf{elif}\;B\_m \leq 4 \cdot 10^{+77}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{0 - B\_m \cdot B\_m}\\
\mathbf{else}:\\
\;\;\;\;0 - {\left(\frac{F}{A} \cdot \frac{F}{A}\right)}^{0.25}\\
\end{array}
\end{array}
if B < 1.4499999999999999e-69Initial program 24.6%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified29.4%
Taylor expanded in A around -inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6412.1%
Simplified12.1%
*-commutativeN/A
associate-*l*N/A
associate-*l*N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-commutativeN/A
*-lowering-*.f6416.8%
Applied egg-rr16.8%
if 1.4499999999999999e-69 < B < 3.99999999999999993e77Initial program 36.0%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified36.7%
Taylor expanded in A around 0
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6433.6%
Simplified33.6%
Taylor expanded in B around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6426.6%
Simplified26.6%
if 3.99999999999999993e77 < B Initial program 5.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified5.9%
Taylor expanded in B around 0
Simplified0.6%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f640.3%
Simplified0.3%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f643.2%
Simplified3.2%
pow1/2N/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval9.8%
Applied egg-rr9.8%
Final simplification16.5%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (if (<= A -4.2e-133) (- 0.0 (pow (* (/ F A) (/ F A)) 0.25)) (/ (sqrt (* 2.0 (* F (* B_m (* B_m B_m))))) (- 0.0 (* B_m B_m)))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
double tmp;
if (A <= -4.2e-133) {
tmp = 0.0 - pow(((F / A) * (F / A)), 0.25);
} else {
tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / (0.0 - (B_m * 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 (a <= (-4.2d-133)) then
tmp = 0.0d0 - (((f / a) * (f / a)) ** 0.25d0)
else
tmp = sqrt((2.0d0 * (f * (b_m * (b_m * b_m))))) / (0.0d0 - (b_m * 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 (A <= -4.2e-133) {
tmp = 0.0 - Math.pow(((F / A) * (F / A)), 0.25);
} else {
tmp = Math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / (0.0 - (B_m * B_m));
}
return tmp;
}
B_m = math.fabs(B) def code(A, B_m, C, F): tmp = 0 if A <= -4.2e-133: tmp = 0.0 - math.pow(((F / A) * (F / A)), 0.25) else: tmp = math.sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / (0.0 - (B_m * B_m)) return tmp
B_m = abs(B) function code(A, B_m, C, F) tmp = 0.0 if (A <= -4.2e-133) tmp = Float64(0.0 - (Float64(Float64(F / A) * Float64(F / A)) ^ 0.25)); else tmp = Float64(sqrt(Float64(2.0 * Float64(F * Float64(B_m * Float64(B_m * B_m))))) / Float64(0.0 - Float64(B_m * B_m))); end return tmp end
B_m = abs(B); function tmp_2 = code(A, B_m, C, F) tmp = 0.0; if (A <= -4.2e-133) tmp = 0.0 - (((F / A) * (F / A)) ^ 0.25); else tmp = sqrt((2.0 * (F * (B_m * (B_m * B_m))))) / (0.0 - (B_m * B_m)); end tmp_2 = tmp; end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := If[LessEqual[A, -4.2e-133], N[(0.0 - N[Power[N[(N[(F / A), $MachinePrecision] * N[(F / A), $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]), $MachinePrecision], N[(N[Sqrt[N[(2.0 * N[(F * N[(B$95$m * N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[(0.0 - N[(B$95$m * B$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
B_m = \left|B\right|
\\
\begin{array}{l}
\mathbf{if}\;A \leq -4.2 \cdot 10^{-133}:\\
\;\;\;\;0 - {\left(\frac{F}{A} \cdot \frac{F}{A}\right)}^{0.25}\\
\mathbf{else}:\\
\;\;\;\;\frac{\sqrt{2 \cdot \left(F \cdot \left(B\_m \cdot \left(B\_m \cdot B\_m\right)\right)\right)}}{0 - B\_m \cdot B\_m}\\
\end{array}
\end{array}
if A < -4.2000000000000002e-133Initial program 8.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified9.5%
Taylor expanded in B around 0
Simplified6.2%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f646.1%
Simplified6.1%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f641.1%
Simplified1.1%
pow1/2N/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval27.4%
Applied egg-rr27.4%
if -4.2000000000000002e-133 < A Initial program 29.1%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified33.9%
Taylor expanded in A around 0
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6418.3%
Simplified18.3%
Taylor expanded in B around inf
*-lowering-*.f64N/A
*-lowering-*.f64N/A
cube-multN/A
unpow2N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f645.9%
Simplified5.9%
Final simplification13.5%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (- 0.0 (pow (* (/ F A) (/ F A)) 0.25)))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
return 0.0 - pow(((F / A) * (F / A)), 0.25);
}
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 - (((f / a) * (f / a)) ** 0.25d0)
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
return 0.0 - Math.pow(((F / A) * (F / A)), 0.25);
}
B_m = math.fabs(B) def code(A, B_m, C, F): return 0.0 - math.pow(((F / A) * (F / A)), 0.25)
B_m = abs(B) function code(A, B_m, C, F) return Float64(0.0 - (Float64(Float64(F / A) * Float64(F / A)) ^ 0.25)) end
B_m = abs(B); function tmp = code(A, B_m, C, F) tmp = 0.0 - (((F / A) * (F / A)) ^ 0.25); end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := N[(0.0 - N[Power[N[(N[(F / A), $MachinePrecision] * N[(F / A), $MachinePrecision]), $MachinePrecision], 0.25], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
B_m = \left|B\right|
\\
0 - {\left(\frac{F}{A} \cdot \frac{F}{A}\right)}^{0.25}
\end{array}
Initial program 21.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified25.2%
Taylor expanded in B around 0
Simplified10.7%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6410.2%
Simplified10.2%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f642.9%
Simplified2.9%
pow1/2N/A
sqr-powN/A
pow-prod-downN/A
pow-lowering-pow.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f64N/A
metadata-eval12.5%
Applied egg-rr12.5%
Final simplification12.5%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (- 0.0 (pow (/ A F) -0.5)))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
return 0.0 - pow((A / F), -0.5);
}
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 - ((a / f) ** (-0.5d0))
end function
B_m = Math.abs(B);
public static double code(double A, double B_m, double C, double F) {
return 0.0 - Math.pow((A / F), -0.5);
}
B_m = math.fabs(B) def code(A, B_m, C, F): return 0.0 - math.pow((A / F), -0.5)
B_m = abs(B) function code(A, B_m, C, F) return Float64(0.0 - (Float64(A / F) ^ -0.5)) end
B_m = abs(B); function tmp = code(A, B_m, C, F) tmp = 0.0 - ((A / F) ^ -0.5); end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := N[(0.0 - N[Power[N[(A / F), $MachinePrecision], -0.5], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
B_m = \left|B\right|
\\
0 - {\left(\frac{A}{F}\right)}^{-0.5}
\end{array}
Initial program 21.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified25.2%
Taylor expanded in B around 0
Simplified10.7%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6410.2%
Simplified10.2%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f642.9%
Simplified2.9%
pow1/2N/A
clear-numN/A
inv-powN/A
pow-powN/A
metadata-evalN/A
pow-lowering-pow.f64N/A
/-lowering-/.f643.0%
Applied egg-rr3.0%
Final simplification3.0%
B_m = (fabs.f64 B) (FPCore (A B_m C F) :precision binary64 (- 0.0 (sqrt (/ F A))))
B_m = fabs(B);
double code(double A, double B_m, double C, double F) {
return 0.0 - sqrt((F / A));
}
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 / a))
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 / A));
}
B_m = math.fabs(B) def code(A, B_m, C, F): return 0.0 - math.sqrt((F / A))
B_m = abs(B) function code(A, B_m, C, F) return Float64(0.0 - sqrt(Float64(F / A))) end
B_m = abs(B); function tmp = code(A, B_m, C, F) tmp = 0.0 - sqrt((F / A)); end
B_m = N[Abs[B], $MachinePrecision] code[A_, B$95$m_, C_, F_] := N[(0.0 - N[Sqrt[N[(F / A), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
B_m = \left|B\right|
\\
0 - \sqrt{\frac{F}{A}}
\end{array}
Initial program 21.9%
distribute-frac-negN/A
distribute-neg-frac2N/A
/-lowering-/.f64N/A
Simplified25.2%
Taylor expanded in B around 0
Simplified10.7%
Taylor expanded in C around 0
+-lowering-+.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f6410.2%
Simplified10.2%
Taylor expanded in A around 0
mul-1-negN/A
neg-lowering-neg.f64N/A
sqrt-lowering-sqrt.f64N/A
/-lowering-/.f642.9%
Simplified2.9%
Final simplification2.9%
herbie shell --seed 2024170
(FPCore (A B C F)
:name "ABCF->ab-angle a"
:precision binary64
(/ (- (sqrt (* (* 2.0 (* (- (pow B 2.0) (* (* 4.0 A) C)) F)) (+ (+ A C) (sqrt (+ (pow (- A C) 2.0) (pow B 2.0))))))) (- (pow B 2.0) (* (* 4.0 A) C))))