
(FPCore (a b c) :precision binary64 (let* ((t_0 (sqrt (- (* b b) (* (* 4.0 a) c))))) (if (>= b 0.0) (/ (- (- b) t_0) (* 2.0 a)) (/ (* 2.0 c) (+ (- b) t_0)))))
double code(double a, double b, double c) {
double t_0 = sqrt(((b * b) - ((4.0 * a) * c)));
double tmp;
if (b >= 0.0) {
tmp = (-b - t_0) / (2.0 * a);
} else {
tmp = (2.0 * c) / (-b + t_0);
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: t_0
real(8) :: tmp
t_0 = sqrt(((b * b) - ((4.0d0 * a) * c)))
if (b >= 0.0d0) then
tmp = (-b - t_0) / (2.0d0 * a)
else
tmp = (2.0d0 * c) / (-b + t_0)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double t_0 = Math.sqrt(((b * b) - ((4.0 * a) * c)));
double tmp;
if (b >= 0.0) {
tmp = (-b - t_0) / (2.0 * a);
} else {
tmp = (2.0 * c) / (-b + t_0);
}
return tmp;
}
def code(a, b, c): t_0 = math.sqrt(((b * b) - ((4.0 * a) * c))) tmp = 0 if b >= 0.0: tmp = (-b - t_0) / (2.0 * a) else: tmp = (2.0 * c) / (-b + t_0) return tmp
function code(a, b, c) t_0 = sqrt(Float64(Float64(b * b) - Float64(Float64(4.0 * a) * c))) tmp = 0.0 if (b >= 0.0) tmp = Float64(Float64(Float64(-b) - t_0) / Float64(2.0 * a)); else tmp = Float64(Float64(2.0 * c) / Float64(Float64(-b) + t_0)); end return tmp end
function tmp_2 = code(a, b, c) t_0 = sqrt(((b * b) - ((4.0 * a) * c))); tmp = 0.0; if (b >= 0.0) tmp = (-b - t_0) / (2.0 * a); else tmp = (2.0 * c) / (-b + t_0); end tmp_2 = tmp; end
code[a_, b_, c_] := Block[{t$95$0 = N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[GreaterEqual[b, 0.0], N[(N[((-b) - t$95$0), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * c), $MachinePrecision] / N[((-b) + t$95$0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{b \cdot b - \left(4 \cdot a\right) \cdot c}\\
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{\left(-b\right) - t\_0}{2 \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{2 \cdot c}{\left(-b\right) + t\_0}\\
\end{array}
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 10 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (a b c) :precision binary64 (let* ((t_0 (sqrt (- (* b b) (* (* 4.0 a) c))))) (if (>= b 0.0) (/ (- (- b) t_0) (* 2.0 a)) (/ (* 2.0 c) (+ (- b) t_0)))))
double code(double a, double b, double c) {
double t_0 = sqrt(((b * b) - ((4.0 * a) * c)));
double tmp;
if (b >= 0.0) {
tmp = (-b - t_0) / (2.0 * a);
} else {
tmp = (2.0 * c) / (-b + t_0);
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: t_0
real(8) :: tmp
t_0 = sqrt(((b * b) - ((4.0d0 * a) * c)))
if (b >= 0.0d0) then
tmp = (-b - t_0) / (2.0d0 * a)
else
tmp = (2.0d0 * c) / (-b + t_0)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double t_0 = Math.sqrt(((b * b) - ((4.0 * a) * c)));
double tmp;
if (b >= 0.0) {
tmp = (-b - t_0) / (2.0 * a);
} else {
tmp = (2.0 * c) / (-b + t_0);
}
return tmp;
}
def code(a, b, c): t_0 = math.sqrt(((b * b) - ((4.0 * a) * c))) tmp = 0 if b >= 0.0: tmp = (-b - t_0) / (2.0 * a) else: tmp = (2.0 * c) / (-b + t_0) return tmp
function code(a, b, c) t_0 = sqrt(Float64(Float64(b * b) - Float64(Float64(4.0 * a) * c))) tmp = 0.0 if (b >= 0.0) tmp = Float64(Float64(Float64(-b) - t_0) / Float64(2.0 * a)); else tmp = Float64(Float64(2.0 * c) / Float64(Float64(-b) + t_0)); end return tmp end
function tmp_2 = code(a, b, c) t_0 = sqrt(((b * b) - ((4.0 * a) * c))); tmp = 0.0; if (b >= 0.0) tmp = (-b - t_0) / (2.0 * a); else tmp = (2.0 * c) / (-b + t_0); end tmp_2 = tmp; end
code[a_, b_, c_] := Block[{t$95$0 = N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(4.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[GreaterEqual[b, 0.0], N[(N[((-b) - t$95$0), $MachinePrecision] / N[(2.0 * a), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 * c), $MachinePrecision] / N[((-b) + t$95$0), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{b \cdot b - \left(4 \cdot a\right) \cdot c}\\
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{\left(-b\right) - t\_0}{2 \cdot a}\\
\mathbf{else}:\\
\;\;\;\;\frac{2 \cdot c}{\left(-b\right) + t\_0}\\
\end{array}
\end{array}
(FPCore (a b c)
:precision binary64
(let* ((t_0 (sqrt (+ (* b b) (* c (* a -4.0))))))
(if (<= b -2e+149)
(- 0.0 (/ c b))
(if (<= b 5.5e+57)
(if (>= b 0.0) (/ (/ (+ b t_0) -2.0) a) (/ (* c 2.0) (- t_0 b)))
(- 0.0 (/ b a))))))
double code(double a, double b, double c) {
double t_0 = sqrt(((b * b) + (c * (a * -4.0))));
double tmp;
if (b <= -2e+149) {
tmp = 0.0 - (c / b);
} else if (b <= 5.5e+57) {
double tmp_1;
if (b >= 0.0) {
tmp_1 = ((b + t_0) / -2.0) / a;
} else {
tmp_1 = (c * 2.0) / (t_0 - b);
}
tmp = tmp_1;
} else {
tmp = 0.0 - (b / a);
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: t_0
real(8) :: tmp
real(8) :: tmp_1
t_0 = sqrt(((b * b) + (c * (a * (-4.0d0)))))
if (b <= (-2d+149)) then
tmp = 0.0d0 - (c / b)
else if (b <= 5.5d+57) then
if (b >= 0.0d0) then
tmp_1 = ((b + t_0) / (-2.0d0)) / a
else
tmp_1 = (c * 2.0d0) / (t_0 - b)
end if
tmp = tmp_1
else
tmp = 0.0d0 - (b / a)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double t_0 = Math.sqrt(((b * b) + (c * (a * -4.0))));
double tmp;
if (b <= -2e+149) {
tmp = 0.0 - (c / b);
} else if (b <= 5.5e+57) {
double tmp_1;
if (b >= 0.0) {
tmp_1 = ((b + t_0) / -2.0) / a;
} else {
tmp_1 = (c * 2.0) / (t_0 - b);
}
tmp = tmp_1;
} else {
tmp = 0.0 - (b / a);
}
return tmp;
}
def code(a, b, c): t_0 = math.sqrt(((b * b) + (c * (a * -4.0)))) tmp = 0 if b <= -2e+149: tmp = 0.0 - (c / b) elif b <= 5.5e+57: tmp_1 = 0 if b >= 0.0: tmp_1 = ((b + t_0) / -2.0) / a else: tmp_1 = (c * 2.0) / (t_0 - b) tmp = tmp_1 else: tmp = 0.0 - (b / a) return tmp
function code(a, b, c) t_0 = sqrt(Float64(Float64(b * b) + Float64(c * Float64(a * -4.0)))) tmp = 0.0 if (b <= -2e+149) tmp = Float64(0.0 - Float64(c / b)); elseif (b <= 5.5e+57) tmp_1 = 0.0 if (b >= 0.0) tmp_1 = Float64(Float64(Float64(b + t_0) / -2.0) / a); else tmp_1 = Float64(Float64(c * 2.0) / Float64(t_0 - b)); end tmp = tmp_1; else tmp = Float64(0.0 - Float64(b / a)); end return tmp end
function tmp_3 = code(a, b, c) t_0 = sqrt(((b * b) + (c * (a * -4.0)))); tmp = 0.0; if (b <= -2e+149) tmp = 0.0 - (c / b); elseif (b <= 5.5e+57) tmp_2 = 0.0; if (b >= 0.0) tmp_2 = ((b + t_0) / -2.0) / a; else tmp_2 = (c * 2.0) / (t_0 - b); end tmp = tmp_2; else tmp = 0.0 - (b / a); end tmp_3 = tmp; end
code[a_, b_, c_] := Block[{t$95$0 = N[Sqrt[N[(N[(b * b), $MachinePrecision] + N[(c * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[b, -2e+149], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 5.5e+57], If[GreaterEqual[b, 0.0], N[(N[(N[(b + t$95$0), $MachinePrecision] / -2.0), $MachinePrecision] / a), $MachinePrecision], N[(N[(c * 2.0), $MachinePrecision] / N[(t$95$0 - b), $MachinePrecision]), $MachinePrecision]], N[(0.0 - N[(b / a), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}\\
\mathbf{if}\;b \leq -2 \cdot 10^{+149}:\\
\;\;\;\;0 - \frac{c}{b}\\
\mathbf{elif}\;b \leq 5.5 \cdot 10^{+57}:\\
\;\;\;\;\begin{array}{l}
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{\frac{b + t\_0}{-2}}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{c \cdot 2}{t\_0 - b}\\
\end{array}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{b}{a}\\
\end{array}
\end{array}
if b < -2.0000000000000001e149Initial program 29.0%
Simplified29.0%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr0.0%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f645.0%
Simplified5.0%
Taylor expanded in b around -inf
mul-1-negN/A
distribute-neg-frac2N/A
mul-1-negN/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6491.2%
Simplified91.2%
sub0-negN/A
neg-lowering-neg.f6491.2%
Applied egg-rr91.2%
if -2.0000000000000001e149 < b < 5.5000000000000002e57Initial program 88.3%
Simplified88.3%
if 5.5000000000000002e57 < b Initial program 70.9%
Simplified70.9%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr70.9%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6470.9%
Simplified70.9%
Taylor expanded in b around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64100.0%
Simplified100.0%
Final simplification91.8%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (sqrt (+ (* b b) (* c (* a -4.0))))))
(if (<= b -2e+149)
(- 0.0 (/ c b))
(if (<= b 5.9e+57)
(if (>= b 0.0) (* (+ b t_0) (/ -0.5 a)) (/ (* c 2.0) (- t_0 b)))
(- 0.0 (/ b a))))))
double code(double a, double b, double c) {
double t_0 = sqrt(((b * b) + (c * (a * -4.0))));
double tmp;
if (b <= -2e+149) {
tmp = 0.0 - (c / b);
} else if (b <= 5.9e+57) {
double tmp_1;
if (b >= 0.0) {
tmp_1 = (b + t_0) * (-0.5 / a);
} else {
tmp_1 = (c * 2.0) / (t_0 - b);
}
tmp = tmp_1;
} else {
tmp = 0.0 - (b / a);
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: t_0
real(8) :: tmp
real(8) :: tmp_1
t_0 = sqrt(((b * b) + (c * (a * (-4.0d0)))))
if (b <= (-2d+149)) then
tmp = 0.0d0 - (c / b)
else if (b <= 5.9d+57) then
if (b >= 0.0d0) then
tmp_1 = (b + t_0) * ((-0.5d0) / a)
else
tmp_1 = (c * 2.0d0) / (t_0 - b)
end if
tmp = tmp_1
else
tmp = 0.0d0 - (b / a)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double t_0 = Math.sqrt(((b * b) + (c * (a * -4.0))));
double tmp;
if (b <= -2e+149) {
tmp = 0.0 - (c / b);
} else if (b <= 5.9e+57) {
double tmp_1;
if (b >= 0.0) {
tmp_1 = (b + t_0) * (-0.5 / a);
} else {
tmp_1 = (c * 2.0) / (t_0 - b);
}
tmp = tmp_1;
} else {
tmp = 0.0 - (b / a);
}
return tmp;
}
def code(a, b, c): t_0 = math.sqrt(((b * b) + (c * (a * -4.0)))) tmp = 0 if b <= -2e+149: tmp = 0.0 - (c / b) elif b <= 5.9e+57: tmp_1 = 0 if b >= 0.0: tmp_1 = (b + t_0) * (-0.5 / a) else: tmp_1 = (c * 2.0) / (t_0 - b) tmp = tmp_1 else: tmp = 0.0 - (b / a) return tmp
function code(a, b, c) t_0 = sqrt(Float64(Float64(b * b) + Float64(c * Float64(a * -4.0)))) tmp = 0.0 if (b <= -2e+149) tmp = Float64(0.0 - Float64(c / b)); elseif (b <= 5.9e+57) tmp_1 = 0.0 if (b >= 0.0) tmp_1 = Float64(Float64(b + t_0) * Float64(-0.5 / a)); else tmp_1 = Float64(Float64(c * 2.0) / Float64(t_0 - b)); end tmp = tmp_1; else tmp = Float64(0.0 - Float64(b / a)); end return tmp end
function tmp_3 = code(a, b, c) t_0 = sqrt(((b * b) + (c * (a * -4.0)))); tmp = 0.0; if (b <= -2e+149) tmp = 0.0 - (c / b); elseif (b <= 5.9e+57) tmp_2 = 0.0; if (b >= 0.0) tmp_2 = (b + t_0) * (-0.5 / a); else tmp_2 = (c * 2.0) / (t_0 - b); end tmp = tmp_2; else tmp = 0.0 - (b / a); end tmp_3 = tmp; end
code[a_, b_, c_] := Block[{t$95$0 = N[Sqrt[N[(N[(b * b), $MachinePrecision] + N[(c * N[(a * -4.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[b, -2e+149], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 5.9e+57], If[GreaterEqual[b, 0.0], N[(N[(b + t$95$0), $MachinePrecision] * N[(-0.5 / a), $MachinePrecision]), $MachinePrecision], N[(N[(c * 2.0), $MachinePrecision] / N[(t$95$0 - b), $MachinePrecision]), $MachinePrecision]], N[(0.0 - N[(b / a), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{b \cdot b + c \cdot \left(a \cdot -4\right)}\\
\mathbf{if}\;b \leq -2 \cdot 10^{+149}:\\
\;\;\;\;0 - \frac{c}{b}\\
\mathbf{elif}\;b \leq 5.9 \cdot 10^{+57}:\\
\;\;\;\;\begin{array}{l}
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\left(b + t\_0\right) \cdot \frac{-0.5}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{c \cdot 2}{t\_0 - b}\\
\end{array}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{b}{a}\\
\end{array}
\end{array}
if b < -2.0000000000000001e149Initial program 29.0%
Simplified29.0%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr0.0%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f645.0%
Simplified5.0%
Taylor expanded in b around -inf
mul-1-negN/A
distribute-neg-frac2N/A
mul-1-negN/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6491.2%
Simplified91.2%
sub0-negN/A
neg-lowering-neg.f6491.2%
Applied egg-rr91.2%
if -2.0000000000000001e149 < b < 5.90000000000000013e57Initial program 88.3%
Simplified88.3%
div-invN/A
associate-/l*N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
rem-square-sqrtN/A
sqrt-lowering-sqrt.f64N/A
rem-square-sqrtN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
/-lowering-/.f64N/A
metadata-eval88.2%
Applied egg-rr88.2%
if 5.90000000000000013e57 < b Initial program 70.9%
Simplified70.9%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr70.9%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6470.9%
Simplified70.9%
Taylor expanded in b around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64100.0%
Simplified100.0%
Final simplification91.7%
(FPCore (a b c)
:precision binary64
(let* ((t_0 (sqrt (+ (* b b) (* -4.0 (* c a))))))
(if (<= b -5e+149)
(- 0.0 (/ c b))
(if (<= b 1.8e-235)
(/ (* c 2.0) (- t_0 b))
(if (<= b 5.9e+57) (/ (* -0.5 (+ b t_0)) a) (- 0.0 (/ b a)))))))
double code(double a, double b, double c) {
double t_0 = sqrt(((b * b) + (-4.0 * (c * a))));
double tmp;
if (b <= -5e+149) {
tmp = 0.0 - (c / b);
} else if (b <= 1.8e-235) {
tmp = (c * 2.0) / (t_0 - b);
} else if (b <= 5.9e+57) {
tmp = (-0.5 * (b + t_0)) / a;
} else {
tmp = 0.0 - (b / a);
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: t_0
real(8) :: tmp
t_0 = sqrt(((b * b) + ((-4.0d0) * (c * a))))
if (b <= (-5d+149)) then
tmp = 0.0d0 - (c / b)
else if (b <= 1.8d-235) then
tmp = (c * 2.0d0) / (t_0 - b)
else if (b <= 5.9d+57) then
tmp = ((-0.5d0) * (b + t_0)) / a
else
tmp = 0.0d0 - (b / a)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double t_0 = Math.sqrt(((b * b) + (-4.0 * (c * a))));
double tmp;
if (b <= -5e+149) {
tmp = 0.0 - (c / b);
} else if (b <= 1.8e-235) {
tmp = (c * 2.0) / (t_0 - b);
} else if (b <= 5.9e+57) {
tmp = (-0.5 * (b + t_0)) / a;
} else {
tmp = 0.0 - (b / a);
}
return tmp;
}
def code(a, b, c): t_0 = math.sqrt(((b * b) + (-4.0 * (c * a)))) tmp = 0 if b <= -5e+149: tmp = 0.0 - (c / b) elif b <= 1.8e-235: tmp = (c * 2.0) / (t_0 - b) elif b <= 5.9e+57: tmp = (-0.5 * (b + t_0)) / a else: tmp = 0.0 - (b / a) return tmp
function code(a, b, c) t_0 = sqrt(Float64(Float64(b * b) + Float64(-4.0 * Float64(c * a)))) tmp = 0.0 if (b <= -5e+149) tmp = Float64(0.0 - Float64(c / b)); elseif (b <= 1.8e-235) tmp = Float64(Float64(c * 2.0) / Float64(t_0 - b)); elseif (b <= 5.9e+57) tmp = Float64(Float64(-0.5 * Float64(b + t_0)) / a); else tmp = Float64(0.0 - Float64(b / a)); end return tmp end
function tmp_2 = code(a, b, c) t_0 = sqrt(((b * b) + (-4.0 * (c * a)))); tmp = 0.0; if (b <= -5e+149) tmp = 0.0 - (c / b); elseif (b <= 1.8e-235) tmp = (c * 2.0) / (t_0 - b); elseif (b <= 5.9e+57) tmp = (-0.5 * (b + t_0)) / a; else tmp = 0.0 - (b / a); end tmp_2 = tmp; end
code[a_, b_, c_] := Block[{t$95$0 = N[Sqrt[N[(N[(b * b), $MachinePrecision] + N[(-4.0 * N[(c * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]}, If[LessEqual[b, -5e+149], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.8e-235], N[(N[(c * 2.0), $MachinePrecision] / N[(t$95$0 - b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 5.9e+57], N[(N[(-0.5 * N[(b + t$95$0), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], N[(0.0 - N[(b / a), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_0 := \sqrt{b \cdot b + -4 \cdot \left(c \cdot a\right)}\\
\mathbf{if}\;b \leq -5 \cdot 10^{+149}:\\
\;\;\;\;0 - \frac{c}{b}\\
\mathbf{elif}\;b \leq 1.8 \cdot 10^{-235}:\\
\;\;\;\;\frac{c \cdot 2}{t\_0 - b}\\
\mathbf{elif}\;b \leq 5.9 \cdot 10^{+57}:\\
\;\;\;\;\frac{-0.5 \cdot \left(b + t\_0\right)}{a}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{b}{a}\\
\end{array}
\end{array}
if b < -4.9999999999999999e149Initial program 29.0%
Simplified29.0%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr0.0%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f645.0%
Simplified5.0%
Taylor expanded in b around -inf
mul-1-negN/A
distribute-neg-frac2N/A
mul-1-negN/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6491.2%
Simplified91.2%
sub0-negN/A
neg-lowering-neg.f6491.2%
Applied egg-rr91.2%
if -4.9999999999999999e149 < b < 1.79999999999999999e-235Initial program 90.0%
Simplified90.0%
+-commutativeN/A
flip-+N/A
/-lowering-/.f64N/A
--lowering--.f64N/A
rem-square-sqrtN/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
--lowering--.f64N/A
Applied egg-rr90.0%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
sub-negN/A
mul-1-negN/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
mul-1-negN/A
sub-negN/A
--lowering--.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6490.0%
Simplified90.0%
if 1.79999999999999999e-235 < b < 5.90000000000000013e57Initial program 85.3%
Simplified85.3%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr85.3%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6485.3%
Simplified85.3%
if 5.90000000000000013e57 < b Initial program 70.9%
Simplified70.9%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr70.9%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6470.9%
Simplified70.9%
Taylor expanded in b around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64100.0%
Simplified100.0%
Final simplification91.8%
(FPCore (a b c)
:precision binary64
(if (<= b -1.15e-7)
(- 0.0 (/ c b))
(if (<= b 5.7e+57)
(/ (* -0.5 (+ b (sqrt (+ (* b b) (* -4.0 (* c a)))))) a)
(- 0.0 (/ b a)))))
double code(double a, double b, double c) {
double tmp;
if (b <= -1.15e-7) {
tmp = 0.0 - (c / b);
} else if (b <= 5.7e+57) {
tmp = (-0.5 * (b + sqrt(((b * b) + (-4.0 * (c * a)))))) / a;
} else {
tmp = 0.0 - (b / a);
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (b <= (-1.15d-7)) then
tmp = 0.0d0 - (c / b)
else if (b <= 5.7d+57) then
tmp = ((-0.5d0) * (b + sqrt(((b * b) + ((-4.0d0) * (c * a)))))) / a
else
tmp = 0.0d0 - (b / a)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= -1.15e-7) {
tmp = 0.0 - (c / b);
} else if (b <= 5.7e+57) {
tmp = (-0.5 * (b + Math.sqrt(((b * b) + (-4.0 * (c * a)))))) / a;
} else {
tmp = 0.0 - (b / a);
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= -1.15e-7: tmp = 0.0 - (c / b) elif b <= 5.7e+57: tmp = (-0.5 * (b + math.sqrt(((b * b) + (-4.0 * (c * a)))))) / a else: tmp = 0.0 - (b / a) return tmp
function code(a, b, c) tmp = 0.0 if (b <= -1.15e-7) tmp = Float64(0.0 - Float64(c / b)); elseif (b <= 5.7e+57) tmp = Float64(Float64(-0.5 * Float64(b + sqrt(Float64(Float64(b * b) + Float64(-4.0 * Float64(c * a)))))) / a); else tmp = Float64(0.0 - Float64(b / a)); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= -1.15e-7) tmp = 0.0 - (c / b); elseif (b <= 5.7e+57) tmp = (-0.5 * (b + sqrt(((b * b) + (-4.0 * (c * a)))))) / a; else tmp = 0.0 - (b / a); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, -1.15e-7], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 5.7e+57], N[(N[(-0.5 * N[(b + N[Sqrt[N[(N[(b * b), $MachinePrecision] + N[(-4.0 * N[(c * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], N[(0.0 - N[(b / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -1.15 \cdot 10^{-7}:\\
\;\;\;\;0 - \frac{c}{b}\\
\mathbf{elif}\;b \leq 5.7 \cdot 10^{+57}:\\
\;\;\;\;\frac{-0.5 \cdot \left(b + \sqrt{b \cdot b + -4 \cdot \left(c \cdot a\right)}\right)}{a}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{b}{a}\\
\end{array}
\end{array}
if b < -1.14999999999999997e-7Initial program 65.7%
Simplified65.7%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr7.9%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6421.9%
Simplified21.9%
Taylor expanded in b around -inf
mul-1-negN/A
distribute-neg-frac2N/A
mul-1-negN/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6486.7%
Simplified86.7%
sub0-negN/A
neg-lowering-neg.f6486.7%
Applied egg-rr86.7%
if -1.14999999999999997e-7 < b < 5.6999999999999998e57Initial program 86.1%
Simplified86.1%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr81.2%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6481.5%
Simplified81.5%
if 5.6999999999999998e57 < b Initial program 70.9%
Simplified70.9%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr70.9%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6470.9%
Simplified70.9%
Taylor expanded in b around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64100.0%
Simplified100.0%
Final simplification87.9%
(FPCore (a b c)
:precision binary64
(if (<= b -9.5e-8)
(- 0.0 (/ c b))
(if (<= b 5.9e+57)
(* (/ -0.5 a) (+ b (sqrt (+ (* b b) (* -4.0 (* c a))))))
(- 0.0 (/ b a)))))
double code(double a, double b, double c) {
double tmp;
if (b <= -9.5e-8) {
tmp = 0.0 - (c / b);
} else if (b <= 5.9e+57) {
tmp = (-0.5 / a) * (b + sqrt(((b * b) + (-4.0 * (c * a)))));
} else {
tmp = 0.0 - (b / a);
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (b <= (-9.5d-8)) then
tmp = 0.0d0 - (c / b)
else if (b <= 5.9d+57) then
tmp = ((-0.5d0) / a) * (b + sqrt(((b * b) + ((-4.0d0) * (c * a)))))
else
tmp = 0.0d0 - (b / a)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= -9.5e-8) {
tmp = 0.0 - (c / b);
} else if (b <= 5.9e+57) {
tmp = (-0.5 / a) * (b + Math.sqrt(((b * b) + (-4.0 * (c * a)))));
} else {
tmp = 0.0 - (b / a);
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= -9.5e-8: tmp = 0.0 - (c / b) elif b <= 5.9e+57: tmp = (-0.5 / a) * (b + math.sqrt(((b * b) + (-4.0 * (c * a))))) else: tmp = 0.0 - (b / a) return tmp
function code(a, b, c) tmp = 0.0 if (b <= -9.5e-8) tmp = Float64(0.0 - Float64(c / b)); elseif (b <= 5.9e+57) tmp = Float64(Float64(-0.5 / a) * Float64(b + sqrt(Float64(Float64(b * b) + Float64(-4.0 * Float64(c * a)))))); else tmp = Float64(0.0 - Float64(b / a)); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= -9.5e-8) tmp = 0.0 - (c / b); elseif (b <= 5.9e+57) tmp = (-0.5 / a) * (b + sqrt(((b * b) + (-4.0 * (c * a))))); else tmp = 0.0 - (b / a); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, -9.5e-8], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 5.9e+57], N[(N[(-0.5 / a), $MachinePrecision] * N[(b + N[Sqrt[N[(N[(b * b), $MachinePrecision] + N[(-4.0 * N[(c * a), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(0.0 - N[(b / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -9.5 \cdot 10^{-8}:\\
\;\;\;\;0 - \frac{c}{b}\\
\mathbf{elif}\;b \leq 5.9 \cdot 10^{+57}:\\
\;\;\;\;\frac{-0.5}{a} \cdot \left(b + \sqrt{b \cdot b + -4 \cdot \left(c \cdot a\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{b}{a}\\
\end{array}
\end{array}
if b < -9.50000000000000036e-8Initial program 65.7%
Simplified65.7%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr7.9%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6421.9%
Simplified21.9%
Taylor expanded in b around -inf
mul-1-negN/A
distribute-neg-frac2N/A
mul-1-negN/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6486.7%
Simplified86.7%
sub0-negN/A
neg-lowering-neg.f6486.7%
Applied egg-rr86.7%
if -9.50000000000000036e-8 < b < 5.90000000000000013e57Initial program 86.1%
Simplified86.1%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr81.2%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6481.5%
Simplified81.5%
*-commutativeN/A
+-commutativeN/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
associate-/l*N/A
*-lowering-*.f64N/A
Applied egg-rr81.3%
if 5.90000000000000013e57 < b Initial program 70.9%
Simplified70.9%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr70.9%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6470.9%
Simplified70.9%
Taylor expanded in b around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f64100.0%
Simplified100.0%
Final simplification87.8%
(FPCore (a b c)
:precision binary64
(if (<= b -9.5e-8)
(- 0.0 (/ c b))
(if (<= b 1.65e-133)
(/ (* -0.5 (+ b (sqrt (* -4.0 (* c a))))) a)
(- (/ c b) (/ b a)))))
double code(double a, double b, double c) {
double tmp;
if (b <= -9.5e-8) {
tmp = 0.0 - (c / b);
} else if (b <= 1.65e-133) {
tmp = (-0.5 * (b + sqrt((-4.0 * (c * a))))) / a;
} else {
tmp = (c / b) - (b / a);
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (b <= (-9.5d-8)) then
tmp = 0.0d0 - (c / b)
else if (b <= 1.65d-133) then
tmp = ((-0.5d0) * (b + sqrt(((-4.0d0) * (c * a))))) / a
else
tmp = (c / b) - (b / a)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= -9.5e-8) {
tmp = 0.0 - (c / b);
} else if (b <= 1.65e-133) {
tmp = (-0.5 * (b + Math.sqrt((-4.0 * (c * a))))) / a;
} else {
tmp = (c / b) - (b / a);
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= -9.5e-8: tmp = 0.0 - (c / b) elif b <= 1.65e-133: tmp = (-0.5 * (b + math.sqrt((-4.0 * (c * a))))) / a else: tmp = (c / b) - (b / a) return tmp
function code(a, b, c) tmp = 0.0 if (b <= -9.5e-8) tmp = Float64(0.0 - Float64(c / b)); elseif (b <= 1.65e-133) tmp = Float64(Float64(-0.5 * Float64(b + sqrt(Float64(-4.0 * Float64(c * a))))) / a); else tmp = Float64(Float64(c / b) - Float64(b / a)); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= -9.5e-8) tmp = 0.0 - (c / b); elseif (b <= 1.65e-133) tmp = (-0.5 * (b + sqrt((-4.0 * (c * a))))) / a; else tmp = (c / b) - (b / a); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, -9.5e-8], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.65e-133], N[(N[(-0.5 * N[(b + N[Sqrt[N[(-4.0 * N[(c * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / a), $MachinePrecision], N[(N[(c / b), $MachinePrecision] - N[(b / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -9.5 \cdot 10^{-8}:\\
\;\;\;\;0 - \frac{c}{b}\\
\mathbf{elif}\;b \leq 1.65 \cdot 10^{-133}:\\
\;\;\;\;\frac{-0.5 \cdot \left(b + \sqrt{-4 \cdot \left(c \cdot a\right)}\right)}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{c}{b} - \frac{b}{a}\\
\end{array}
\end{array}
if b < -9.50000000000000036e-8Initial program 65.7%
Simplified65.7%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr7.9%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6421.9%
Simplified21.9%
Taylor expanded in b around -inf
mul-1-negN/A
distribute-neg-frac2N/A
mul-1-negN/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6486.7%
Simplified86.7%
sub0-negN/A
neg-lowering-neg.f6486.7%
Applied egg-rr86.7%
if -9.50000000000000036e-8 < b < 1.65000000000000005e-133Initial program 83.9%
Simplified83.9%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr76.5%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6477.0%
Simplified77.0%
Taylor expanded in a around inf
*-lowering-*.f64N/A
*-lowering-*.f6474.2%
Simplified74.2%
if 1.65000000000000005e-133 < b Initial program 78.0%
Simplified78.0%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr78.0%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6478.0%
Simplified78.0%
Taylor expanded in c around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6490.6%
Simplified90.6%
Final simplification84.6%
(FPCore (a b c)
:precision binary64
(if (<= b -9.5e-8)
(- 0.0 (/ c b))
(if (<= b 1.65e-133)
(* (/ -0.5 a) (+ b (sqrt (* -4.0 (* c a)))))
(- (/ c b) (/ b a)))))
double code(double a, double b, double c) {
double tmp;
if (b <= -9.5e-8) {
tmp = 0.0 - (c / b);
} else if (b <= 1.65e-133) {
tmp = (-0.5 / a) * (b + sqrt((-4.0 * (c * a))));
} else {
tmp = (c / b) - (b / a);
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (b <= (-9.5d-8)) then
tmp = 0.0d0 - (c / b)
else if (b <= 1.65d-133) then
tmp = ((-0.5d0) / a) * (b + sqrt(((-4.0d0) * (c * a))))
else
tmp = (c / b) - (b / a)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= -9.5e-8) {
tmp = 0.0 - (c / b);
} else if (b <= 1.65e-133) {
tmp = (-0.5 / a) * (b + Math.sqrt((-4.0 * (c * a))));
} else {
tmp = (c / b) - (b / a);
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= -9.5e-8: tmp = 0.0 - (c / b) elif b <= 1.65e-133: tmp = (-0.5 / a) * (b + math.sqrt((-4.0 * (c * a)))) else: tmp = (c / b) - (b / a) return tmp
function code(a, b, c) tmp = 0.0 if (b <= -9.5e-8) tmp = Float64(0.0 - Float64(c / b)); elseif (b <= 1.65e-133) tmp = Float64(Float64(-0.5 / a) * Float64(b + sqrt(Float64(-4.0 * Float64(c * a))))); else tmp = Float64(Float64(c / b) - Float64(b / a)); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= -9.5e-8) tmp = 0.0 - (c / b); elseif (b <= 1.65e-133) tmp = (-0.5 / a) * (b + sqrt((-4.0 * (c * a)))); else tmp = (c / b) - (b / a); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, -9.5e-8], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], If[LessEqual[b, 1.65e-133], N[(N[(-0.5 / a), $MachinePrecision] * N[(b + N[Sqrt[N[(-4.0 * N[(c * a), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(c / b), $MachinePrecision] - N[(b / a), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -9.5 \cdot 10^{-8}:\\
\;\;\;\;0 - \frac{c}{b}\\
\mathbf{elif}\;b \leq 1.65 \cdot 10^{-133}:\\
\;\;\;\;\frac{-0.5}{a} \cdot \left(b + \sqrt{-4 \cdot \left(c \cdot a\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{c}{b} - \frac{b}{a}\\
\end{array}
\end{array}
if b < -9.50000000000000036e-8Initial program 65.7%
Simplified65.7%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr7.9%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6421.9%
Simplified21.9%
Taylor expanded in b around -inf
mul-1-negN/A
distribute-neg-frac2N/A
mul-1-negN/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6486.7%
Simplified86.7%
sub0-negN/A
neg-lowering-neg.f6486.7%
Applied egg-rr86.7%
if -9.50000000000000036e-8 < b < 1.65000000000000005e-133Initial program 83.9%
Simplified83.9%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr76.5%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6477.0%
Simplified77.0%
*-commutativeN/A
+-commutativeN/A
*-commutativeN/A
*-commutativeN/A
associate-*r*N/A
associate-/l*N/A
*-lowering-*.f64N/A
Applied egg-rr76.9%
Taylor expanded in b around 0
*-lowering-*.f64N/A
*-lowering-*.f6474.1%
Simplified74.1%
if 1.65000000000000005e-133 < b Initial program 78.0%
Simplified78.0%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr78.0%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6478.0%
Simplified78.0%
Taylor expanded in c around 0
+-commutativeN/A
mul-1-negN/A
unsub-negN/A
--lowering--.f64N/A
/-lowering-/.f64N/A
/-lowering-/.f6490.6%
Simplified90.6%
Final simplification84.6%
(FPCore (a b c) :precision binary64 (if (>= b 0.0) (/ (/ (+ b b) -2.0) a) (/ (* c 2.0) (* b (- (- 0.0 2.0) (/ (* -2.0 (* c a)) (* b b)))))))
double code(double a, double b, double c) {
double tmp;
if (b >= 0.0) {
tmp = ((b + b) / -2.0) / a;
} else {
tmp = (c * 2.0) / (b * ((0.0 - 2.0) - ((-2.0 * (c * a)) / (b * b))));
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (b >= 0.0d0) then
tmp = ((b + b) / (-2.0d0)) / a
else
tmp = (c * 2.0d0) / (b * ((0.0d0 - 2.0d0) - (((-2.0d0) * (c * a)) / (b * b))))
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b >= 0.0) {
tmp = ((b + b) / -2.0) / a;
} else {
tmp = (c * 2.0) / (b * ((0.0 - 2.0) - ((-2.0 * (c * a)) / (b * b))));
}
return tmp;
}
def code(a, b, c): tmp = 0 if b >= 0.0: tmp = ((b + b) / -2.0) / a else: tmp = (c * 2.0) / (b * ((0.0 - 2.0) - ((-2.0 * (c * a)) / (b * b)))) return tmp
function code(a, b, c) tmp = 0.0 if (b >= 0.0) tmp = Float64(Float64(Float64(b + b) / -2.0) / a); else tmp = Float64(Float64(c * 2.0) / Float64(b * Float64(Float64(0.0 - 2.0) - Float64(Float64(-2.0 * Float64(c * a)) / Float64(b * b))))); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b >= 0.0) tmp = ((b + b) / -2.0) / a; else tmp = (c * 2.0) / (b * ((0.0 - 2.0) - ((-2.0 * (c * a)) / (b * b)))); end tmp_2 = tmp; end
code[a_, b_, c_] := If[GreaterEqual[b, 0.0], N[(N[(N[(b + b), $MachinePrecision] / -2.0), $MachinePrecision] / a), $MachinePrecision], N[(N[(c * 2.0), $MachinePrecision] / N[(b * N[(N[(0.0 - 2.0), $MachinePrecision] - N[(N[(-2.0 * N[(c * a), $MachinePrecision]), $MachinePrecision] / N[(b * b), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \geq 0:\\
\;\;\;\;\frac{\frac{b + b}{-2}}{a}\\
\mathbf{else}:\\
\;\;\;\;\frac{c \cdot 2}{b \cdot \left(\left(0 - 2\right) - \frac{-2 \cdot \left(c \cdot a\right)}{b \cdot b}\right)}\\
\end{array}
\end{array}
Initial program 76.4%
Simplified76.4%
Taylor expanded in b around inf
Simplified76.1%
Taylor expanded in b around -inf
associate-*r*N/A
*-lowering-*.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f64N/A
+-lowering-+.f64N/A
associate-*r/N/A
/-lowering-/.f64N/A
*-commutativeN/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6466.4%
Simplified66.4%
Final simplification66.4%
(FPCore (a b c) :precision binary64 (if (<= b -5e-310) (- 0.0 (/ c b)) (- 0.0 (/ b a))))
double code(double a, double b, double c) {
double tmp;
if (b <= -5e-310) {
tmp = 0.0 - (c / b);
} else {
tmp = 0.0 - (b / a);
}
return tmp;
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
real(8) :: tmp
if (b <= (-5d-310)) then
tmp = 0.0d0 - (c / b)
else
tmp = 0.0d0 - (b / a)
end if
code = tmp
end function
public static double code(double a, double b, double c) {
double tmp;
if (b <= -5e-310) {
tmp = 0.0 - (c / b);
} else {
tmp = 0.0 - (b / a);
}
return tmp;
}
def code(a, b, c): tmp = 0 if b <= -5e-310: tmp = 0.0 - (c / b) else: tmp = 0.0 - (b / a) return tmp
function code(a, b, c) tmp = 0.0 if (b <= -5e-310) tmp = Float64(0.0 - Float64(c / b)); else tmp = Float64(0.0 - Float64(b / a)); end return tmp end
function tmp_2 = code(a, b, c) tmp = 0.0; if (b <= -5e-310) tmp = 0.0 - (c / b); else tmp = 0.0 - (b / a); end tmp_2 = tmp; end
code[a_, b_, c_] := If[LessEqual[b, -5e-310], N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision], N[(0.0 - N[(b / a), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;b \leq -5 \cdot 10^{-310}:\\
\;\;\;\;0 - \frac{c}{b}\\
\mathbf{else}:\\
\;\;\;\;0 - \frac{b}{a}\\
\end{array}
\end{array}
if b < -4.999999999999985e-310Initial program 75.1%
Simplified75.1%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr37.8%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6446.0%
Simplified46.0%
Taylor expanded in b around -inf
mul-1-negN/A
distribute-neg-frac2N/A
mul-1-negN/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6456.8%
Simplified56.8%
sub0-negN/A
neg-lowering-neg.f6456.8%
Applied egg-rr56.8%
if -4.999999999999985e-310 < b Initial program 77.7%
Simplified77.7%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr77.7%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6477.7%
Simplified77.7%
Taylor expanded in b around inf
mul-1-negN/A
neg-sub0N/A
--lowering--.f6477.0%
Simplified77.0%
Final simplification67.2%
(FPCore (a b c) :precision binary64 (- 0.0 (/ c b)))
double code(double a, double b, double c) {
return 0.0 - (c / b);
}
real(8) function code(a, b, c)
real(8), intent (in) :: a
real(8), intent (in) :: b
real(8), intent (in) :: c
code = 0.0d0 - (c / b)
end function
public static double code(double a, double b, double c) {
return 0.0 - (c / b);
}
def code(a, b, c): return 0.0 - (c / b)
function code(a, b, c) return Float64(0.0 - Float64(c / b)) end
function tmp = code(a, b, c) tmp = 0.0 - (c / b); end
code[a_, b_, c_] := N[(0.0 - N[(c / b), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
0 - \frac{c}{b}
\end{array}
Initial program 76.4%
Simplified76.4%
flip--N/A
+-commutativeN/A
associate-/r/N/A
*-lowering-*.f64N/A
Applied egg-rr58.3%
Taylor expanded in b around 0
if-sameN/A
associate-*r/N/A
/-lowering-/.f64N/A
*-lowering-*.f64N/A
+-lowering-+.f64N/A
sqrt-lowering-sqrt.f64N/A
+-lowering-+.f64N/A
*-lowering-*.f64N/A
*-lowering-*.f64N/A
unpow2N/A
*-lowering-*.f6462.3%
Simplified62.3%
Taylor expanded in b around -inf
mul-1-negN/A
distribute-neg-frac2N/A
mul-1-negN/A
/-lowering-/.f64N/A
mul-1-negN/A
neg-sub0N/A
--lowering--.f6428.7%
Simplified28.7%
sub0-negN/A
neg-lowering-neg.f6428.7%
Applied egg-rr28.7%
Final simplification28.7%
herbie shell --seed 2024145
(FPCore (a b c)
:name "jeff quadratic root 1"
:precision binary64
(if (>= b 0.0) (/ (- (- b) (sqrt (- (* b b) (* (* 4.0 a) c)))) (* 2.0 a)) (/ (* 2.0 c) (+ (- b) (sqrt (- (* b b) (* (* 4.0 a) c)))))))