Cubic critical, narrow range

Percentage Accurate: 54.9% → 99.1%

Time: 18.6s

Alternatives: 9

Speedup: 1.0×

Specification

\[\left(\left(1.0536712127723509 \cdot 10^{-8} < a \land a < 94906265.62425156\right) \land \left(1.0536712127723509 \cdot 10^{-8} < b \land b < 94906265.62425156\right)\right) \land \left(1.0536712127723509 \cdot 10^{-8} < c \land c < 94906265.62425156\right)\]

Math

\[\begin{array}{l} \\ \frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (/ (+ (- b) (sqrt (- (* b b) (* (* 3.0 a) c)))) (* 3.0 a)))

C

double code(double a, double b, double c) {
	return (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    code = (-b + sqrt(((b * b) - ((3.0d0 * a) * c)))) / (3.0d0 * a)
end function

Java

public static double code(double a, double b, double c) {
	return (-b + Math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
}

Python

def code(a, b, c):
	return (-b + math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a)

Julia

function code(a, b, c)
	return Float64(Float64(Float64(-b) + sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c)))) / Float64(3.0 * a))
end

MATLAB

function tmp = code(a, b, c)
	tmp = (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
end

Wolfram

code[a_, b_, c_] := N[(N[((-b) + N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision]

Initial Program: 54.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (/ (+ (- b) (sqrt (- (* b b) (* (* 3.0 a) c)))) (* 3.0 a)))

C

double code(double a, double b, double c) {
	return (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    code = (-b + sqrt(((b * b) - ((3.0d0 * a) * c)))) / (3.0d0 * a)
end function

Java

public static double code(double a, double b, double c) {
	return (-b + Math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
}

Python

def code(a, b, c):
	return (-b + math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a)

Julia

function code(a, b, c)
	return Float64(Float64(Float64(-b) + sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c)))) / Float64(3.0 * a))
end

MATLAB

function tmp = code(a, b, c)
	tmp = (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
end

Wolfram

code[a_, b_, c_] := N[(N[((-b) + N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.1% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := a \cdot \left(-3 \cdot c\right)\\ t_1 := b + {\left(b \cdot b + t\_0\right)}^{0.5}\\ \frac{\frac{0}{t\_1}}{a \cdot -3} - \frac{\frac{t\_0}{t\_1}}{a \cdot -3} \end{array} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (let* ((t_0 (* a (* -3.0 c))) (t_1 (+ b (pow (+ (* b b) t_0) 0.5))))
   (- (/ (/ 0.0 t_1) (* a -3.0)) (/ (/ t_0 t_1) (* a -3.0)))))

C

double code(double a, double b, double c) {
	double t_0 = a * (-3.0 * c);
	double t_1 = b + pow(((b * b) + t_0), 0.5);
	return ((0.0 / t_1) / (a * -3.0)) - ((t_0 / t_1) / (a * -3.0));
}

Fortran

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) :: t_1
    t_0 = a * ((-3.0d0) * c)
    t_1 = b + (((b * b) + t_0) ** 0.5d0)
    code = ((0.0d0 / t_1) / (a * (-3.0d0))) - ((t_0 / t_1) / (a * (-3.0d0)))
end function

Java

public static double code(double a, double b, double c) {
	double t_0 = a * (-3.0 * c);
	double t_1 = b + Math.pow(((b * b) + t_0), 0.5);
	return ((0.0 / t_1) / (a * -3.0)) - ((t_0 / t_1) / (a * -3.0));
}

Python

def code(a, b, c):
	t_0 = a * (-3.0 * c)
	t_1 = b + math.pow(((b * b) + t_0), 0.5)
	return ((0.0 / t_1) / (a * -3.0)) - ((t_0 / t_1) / (a * -3.0))

Julia

function code(a, b, c)
	t_0 = Float64(a * Float64(-3.0 * c))
	t_1 = Float64(b + (Float64(Float64(b * b) + t_0) ^ 0.5))
	return Float64(Float64(Float64(0.0 / t_1) / Float64(a * -3.0)) - Float64(Float64(t_0 / t_1) / Float64(a * -3.0)))
end

MATLAB

function tmp = code(a, b, c)
	t_0 = a * (-3.0 * c);
	t_1 = b + (((b * b) + t_0) ^ 0.5);
	tmp = ((0.0 / t_1) / (a * -3.0)) - ((t_0 / t_1) / (a * -3.0));
end

Wolfram

code[a_, b_, c_] := Block[{t$95$0 = N[(a * N[(-3.0 * c), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(b + N[Power[N[(N[(b * b), $MachinePrecision] + t$95$0), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision]}, N[(N[(N[(0.0 / t$95$1), $MachinePrecision] / N[(a * -3.0), $MachinePrecision]), $MachinePrecision] - N[(N[(t$95$0 / t$95$1), $MachinePrecision] / N[(a * -3.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Initial program 57.7%

   \[\frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a} \]

3. Applied egg-rr 0

   \[\leadsto expr\]

5. Applied egg-rr 0

   \[\leadsto expr\]

7. Applied egg-rr 0

   \[\leadsto expr\]
8. Add Preprocessing

Alternative 2: 75.8% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a}\\ \mathbf{if}\;t\_0 \leq -2.4 \cdot 10^{-7}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;-1 \cdot \frac{c}{b + {\left(a \cdot \left(c \cdot 3\right) + b \cdot b\right)}^{0.5}}\\ \end{array} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (let* ((t_0 (/ (+ (- b) (sqrt (- (* b b) (* (* 3.0 a) c)))) (* 3.0 a))))
   (if (<= t_0 -2.4e-7)
     t_0
     (- (* 1.0 (/ c (+ b (pow (+ (* a (* c 3.0)) (* b b)) 0.5))))))))

C

double code(double a, double b, double c) {
	double t_0 = (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
	double tmp;
	if (t_0 <= -2.4e-7) {
		tmp = t_0;
	} else {
		tmp = -(1.0 * (c / (b + pow(((a * (c * 3.0)) + (b * b)), 0.5))));
	}
	return tmp;
}

Fortran

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 = (-b + sqrt(((b * b) - ((3.0d0 * a) * c)))) / (3.0d0 * a)
    if (t_0 <= (-2.4d-7)) then
        tmp = t_0
    else
        tmp = -(1.0d0 * (c / (b + (((a * (c * 3.0d0)) + (b * b)) ** 0.5d0))))
    end if
    code = tmp
end function

Java

public static double code(double a, double b, double c) {
	double t_0 = (-b + Math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
	double tmp;
	if (t_0 <= -2.4e-7) {
		tmp = t_0;
	} else {
		tmp = -(1.0 * (c / (b + Math.pow(((a * (c * 3.0)) + (b * b)), 0.5))));
	}
	return tmp;
}

Python

def code(a, b, c):
	t_0 = (-b + math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a)
	tmp = 0
	if t_0 <= -2.4e-7:
		tmp = t_0
	else:
		tmp = -(1.0 * (c / (b + math.pow(((a * (c * 3.0)) + (b * b)), 0.5))))
	return tmp

Julia

function code(a, b, c)
	t_0 = Float64(Float64(Float64(-b) + sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c)))) / Float64(3.0 * a))
	tmp = 0.0
	if (t_0 <= -2.4e-7)
		tmp = t_0;
	else
		tmp = Float64(-Float64(1.0 * Float64(c / Float64(b + (Float64(Float64(a * Float64(c * 3.0)) + Float64(b * b)) ^ 0.5)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b, c)
	t_0 = (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
	tmp = 0.0;
	if (t_0 <= -2.4e-7)
		tmp = t_0;
	else
		tmp = -(1.0 * (c / (b + (((a * (c * 3.0)) + (b * b)) ^ 0.5))));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_, c_] := Block[{t$95$0 = N[(N[((-b) + N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$0, -2.4e-7], t$95$0, (-N[(1.0 * N[(c / N[(b + N[Power[N[(N[(a * N[(c * 3.0), $MachinePrecision]), $MachinePrecision] + N[(b * b), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision])]]

Derivation

1. Split input into 2 regimes

2. if (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a)) < -2.39999999999999979e-7

   1. Initial program 72.4%

      \[\frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a} \]

   if -2.39999999999999979e-7 < (/.f64 (+.f64 (neg.f64 b) (sqrt.f64 (-.f64 (*.f64 b b) (*.f64 (*.f64 #s(literal 3 binary64) a) c)))) (*.f64 #s(literal 3 binary64) a))

   1. Initial program 30.4%

      \[\frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a} \]

   3. Applied egg-rr 0

      \[\leadsto expr\]

   5. Applied egg-rr 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   9. Applied egg-rr 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 99.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := a \cdot \left(-3 \cdot c\right)\\ \frac{0 - \frac{t\_0}{-3}}{a \cdot \left(b + {\left(b \cdot b + t\_0\right)}^{0.5}\right)} \end{array} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (let* ((t_0 (* a (* -3.0 c))))
   (/ (- 0.0 (/ t_0 -3.0)) (* a (+ b (pow (+ (* b b) t_0) 0.5))))))

C

double code(double a, double b, double c) {
	double t_0 = a * (-3.0 * c);
	return (0.0 - (t_0 / -3.0)) / (a * (b + pow(((b * b) + t_0), 0.5)));
}

Fortran

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
    t_0 = a * ((-3.0d0) * c)
    code = (0.0d0 - (t_0 / (-3.0d0))) / (a * (b + (((b * b) + t_0) ** 0.5d0)))
end function

Java

public static double code(double a, double b, double c) {
	double t_0 = a * (-3.0 * c);
	return (0.0 - (t_0 / -3.0)) / (a * (b + Math.pow(((b * b) + t_0), 0.5)));
}

Python

def code(a, b, c):
	t_0 = a * (-3.0 * c)
	return (0.0 - (t_0 / -3.0)) / (a * (b + math.pow(((b * b) + t_0), 0.5)))

Julia

function code(a, b, c)
	t_0 = Float64(a * Float64(-3.0 * c))
	return Float64(Float64(0.0 - Float64(t_0 / -3.0)) / Float64(a * Float64(b + (Float64(Float64(b * b) + t_0) ^ 0.5))))
end

MATLAB

function tmp = code(a, b, c)
	t_0 = a * (-3.0 * c);
	tmp = (0.0 - (t_0 / -3.0)) / (a * (b + (((b * b) + t_0) ^ 0.5)));
end

Wolfram

code[a_, b_, c_] := Block[{t$95$0 = N[(a * N[(-3.0 * c), $MachinePrecision]), $MachinePrecision]}, N[(N[(0.0 - N[(t$95$0 / -3.0), $MachinePrecision]), $MachinePrecision] / N[(a * N[(b + N[Power[N[(N[(b * b), $MachinePrecision] + t$95$0), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Initial program 57.7%

   \[\frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a} \]

3. Applied egg-rr 0

   \[\leadsto expr\]

5. Applied egg-rr 0

   \[\leadsto expr\]

7. Applied egg-rr 0

   \[\leadsto expr\]
8. Add Preprocessing

Alternative 4: 99.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \frac{0 + 3 \cdot \left(a \cdot c\right)}{\left(a \cdot -3\right) \cdot \left(b + {\left(b \cdot b + a \cdot \left(-3 \cdot c\right)\right)}^{0.5}\right)} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (/
  (+ 0.0 (* 3.0 (* a c)))
  (* (* a -3.0) (+ b (pow (+ (* b b) (* a (* -3.0 c))) 0.5)))))

C

double code(double a, double b, double c) {
	return (0.0 + (3.0 * (a * c))) / ((a * -3.0) * (b + pow(((b * b) + (a * (-3.0 * c))), 0.5)));
}

Fortran

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 + (3.0d0 * (a * c))) / ((a * (-3.0d0)) * (b + (((b * b) + (a * ((-3.0d0) * c))) ** 0.5d0)))
end function

Java

public static double code(double a, double b, double c) {
	return (0.0 + (3.0 * (a * c))) / ((a * -3.0) * (b + Math.pow(((b * b) + (a * (-3.0 * c))), 0.5)));
}

Python

def code(a, b, c):
	return (0.0 + (3.0 * (a * c))) / ((a * -3.0) * (b + math.pow(((b * b) + (a * (-3.0 * c))), 0.5)))

Julia

function code(a, b, c)
	return Float64(Float64(0.0 + Float64(3.0 * Float64(a * c))) / Float64(Float64(a * -3.0) * Float64(b + (Float64(Float64(b * b) + Float64(a * Float64(-3.0 * c))) ^ 0.5))))
end

MATLAB

function tmp = code(a, b, c)
	tmp = (0.0 + (3.0 * (a * c))) / ((a * -3.0) * (b + (((b * b) + (a * (-3.0 * c))) ^ 0.5)));
end

Wolfram

code[a_, b_, c_] := N[(N[(0.0 + N[(3.0 * N[(a * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(a * -3.0), $MachinePrecision] * N[(b + N[Power[N[(N[(b * b), $MachinePrecision] + N[(a * N[(-3.0 * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 57.7%

   \[\frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a} \]

3. Applied egg-rr 0

   \[\leadsto expr\]

5. Applied egg-rr 0

   \[\leadsto expr\]

7. Applied egg-rr 0

   \[\leadsto expr\]
8. Add Preprocessing

Alternative 5: 99.0% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := a \cdot \left(-3 \cdot c\right)\\ \frac{-0.3333333333333333}{a} \cdot \frac{0 - t\_0}{b + {\left(b \cdot b + t\_0\right)}^{0.5}} \end{array} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (let* ((t_0 (* a (* -3.0 c))))
   (*
    (/ -0.3333333333333333 a)
    (/ (- 0.0 t_0) (+ b (pow (+ (* b b) t_0) 0.5))))))

C

double code(double a, double b, double c) {
	double t_0 = a * (-3.0 * c);
	return (-0.3333333333333333 / a) * ((0.0 - t_0) / (b + pow(((b * b) + t_0), 0.5)));
}

Fortran

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
    t_0 = a * ((-3.0d0) * c)
    code = ((-0.3333333333333333d0) / a) * ((0.0d0 - t_0) / (b + (((b * b) + t_0) ** 0.5d0)))
end function

Java

public static double code(double a, double b, double c) {
	double t_0 = a * (-3.0 * c);
	return (-0.3333333333333333 / a) * ((0.0 - t_0) / (b + Math.pow(((b * b) + t_0), 0.5)));
}

Python

def code(a, b, c):
	t_0 = a * (-3.0 * c)
	return (-0.3333333333333333 / a) * ((0.0 - t_0) / (b + math.pow(((b * b) + t_0), 0.5)))

Julia

function code(a, b, c)
	t_0 = Float64(a * Float64(-3.0 * c))
	return Float64(Float64(-0.3333333333333333 / a) * Float64(Float64(0.0 - t_0) / Float64(b + (Float64(Float64(b * b) + t_0) ^ 0.5))))
end

MATLAB

function tmp = code(a, b, c)
	t_0 = a * (-3.0 * c);
	tmp = (-0.3333333333333333 / a) * ((0.0 - t_0) / (b + (((b * b) + t_0) ^ 0.5)));
end

Wolfram

code[a_, b_, c_] := Block[{t$95$0 = N[(a * N[(-3.0 * c), $MachinePrecision]), $MachinePrecision]}, N[(N[(-0.3333333333333333 / a), $MachinePrecision] * N[(N[(0.0 - t$95$0), $MachinePrecision] / N[(b + N[Power[N[(N[(b * b), $MachinePrecision] + t$95$0), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Initial program 57.7%

   \[\frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a} \]

3. Applied egg-rr 0

   \[\leadsto expr\]

5. Applied egg-rr 0

   \[\leadsto expr\]

7. Applied egg-rr 0

   \[\leadsto expr\]
8. Add Preprocessing

Alternative 6: 99.0% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \frac{-0.3333333333333333}{a} \cdot \frac{0 + 3 \cdot \left(a \cdot c\right)}{b + {\left(b \cdot b + a \cdot \left(-3 \cdot c\right)\right)}^{0.5}} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (*
  (/ -0.3333333333333333 a)
  (/ (+ 0.0 (* 3.0 (* a c))) (+ b (pow (+ (* b b) (* a (* -3.0 c))) 0.5)))))

C

double code(double a, double b, double c) {
	return (-0.3333333333333333 / a) * ((0.0 + (3.0 * (a * c))) / (b + pow(((b * b) + (a * (-3.0 * c))), 0.5)));
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    code = ((-0.3333333333333333d0) / a) * ((0.0d0 + (3.0d0 * (a * c))) / (b + (((b * b) + (a * ((-3.0d0) * c))) ** 0.5d0)))
end function

Java

public static double code(double a, double b, double c) {
	return (-0.3333333333333333 / a) * ((0.0 + (3.0 * (a * c))) / (b + Math.pow(((b * b) + (a * (-3.0 * c))), 0.5)));
}

Python

def code(a, b, c):
	return (-0.3333333333333333 / a) * ((0.0 + (3.0 * (a * c))) / (b + math.pow(((b * b) + (a * (-3.0 * c))), 0.5)))

Julia

function code(a, b, c)
	return Float64(Float64(-0.3333333333333333 / a) * Float64(Float64(0.0 + Float64(3.0 * Float64(a * c))) / Float64(b + (Float64(Float64(b * b) + Float64(a * Float64(-3.0 * c))) ^ 0.5))))
end

MATLAB

function tmp = code(a, b, c)
	tmp = (-0.3333333333333333 / a) * ((0.0 + (3.0 * (a * c))) / (b + (((b * b) + (a * (-3.0 * c))) ^ 0.5)));
end

Wolfram

code[a_, b_, c_] := N[(N[(-0.3333333333333333 / a), $MachinePrecision] * N[(N[(0.0 + N[(3.0 * N[(a * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(b + N[Power[N[(N[(b * b), $MachinePrecision] + N[(a * N[(-3.0 * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 57.7%

   \[\frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a} \]

3. Applied egg-rr 0

   \[\leadsto expr\]

5. Applied egg-rr 0

   \[\leadsto expr\]

7. Applied egg-rr 0

   \[\leadsto expr\]
8. Add Preprocessing

Alternative 7: 54.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a} \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (/ (+ (- b) (sqrt (- (* b b) (* (* 3.0 a) c)))) (* 3.0 a)))

C

double code(double a, double b, double c) {
	return (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    code = (-b + sqrt(((b * b) - ((3.0d0 * a) * c)))) / (3.0d0 * a)
end function

Java

public static double code(double a, double b, double c) {
	return (-b + Math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
}

Python

def code(a, b, c):
	return (-b + math.sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a)

Julia

function code(a, b, c)
	return Float64(Float64(Float64(-b) + sqrt(Float64(Float64(b * b) - Float64(Float64(3.0 * a) * c)))) / Float64(3.0 * a))
end

MATLAB

function tmp = code(a, b, c)
	tmp = (-b + sqrt(((b * b) - ((3.0 * a) * c)))) / (3.0 * a);
end

Wolfram

code[a_, b_, c_] := N[(N[((-b) + N[Sqrt[N[(N[(b * b), $MachinePrecision] - N[(N[(3.0 * a), $MachinePrecision] * c), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / N[(3.0 * a), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 57.7%

   \[\frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a} \]
2. Add Preprocessing

Alternative 8: 54.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{-0.3333333333333333}{a} \cdot \left(b - {\left(b \cdot b + \left(a \cdot c\right) \cdot -3\right)}^{0.5}\right) \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (* (/ -0.3333333333333333 a) (- b (pow (+ (* b b) (* (* a c) -3.0)) 0.5))))

C

double code(double a, double b, double c) {
	return (-0.3333333333333333 / a) * (b - pow(((b * b) + ((a * c) * -3.0)), 0.5));
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    code = ((-0.3333333333333333d0) / a) * (b - (((b * b) + ((a * c) * (-3.0d0))) ** 0.5d0))
end function

Java

public static double code(double a, double b, double c) {
	return (-0.3333333333333333 / a) * (b - Math.pow(((b * b) + ((a * c) * -3.0)), 0.5));
}

Python

def code(a, b, c):
	return (-0.3333333333333333 / a) * (b - math.pow(((b * b) + ((a * c) * -3.0)), 0.5))

Julia

function code(a, b, c)
	return Float64(Float64(-0.3333333333333333 / a) * Float64(b - (Float64(Float64(b * b) + Float64(Float64(a * c) * -3.0)) ^ 0.5)))
end

MATLAB

function tmp = code(a, b, c)
	tmp = (-0.3333333333333333 / a) * (b - (((b * b) + ((a * c) * -3.0)) ^ 0.5));
end

Wolfram

code[a_, b_, c_] := N[(N[(-0.3333333333333333 / a), $MachinePrecision] * N[(b - N[Power[N[(N[(b * b), $MachinePrecision] + N[(N[(a * c), $MachinePrecision] * -3.0), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 57.7%

   \[\frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a} \]

3. Applied egg-rr 0

   \[\leadsto expr\]

5. Applied egg-rr 0

   \[\leadsto expr\]
6. Add Preprocessing

Alternative 9: 54.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{-0.3333333333333333}{a} \cdot \left(b - {\left(b \cdot b + a \cdot \left(-3 \cdot c\right)\right)}^{0.5}\right) \end{array} \]

FPCore

(FPCore (a b c)
 :precision binary64
 (* (/ -0.3333333333333333 a) (- b (pow (+ (* b b) (* a (* -3.0 c))) 0.5))))

C

double code(double a, double b, double c) {
	return (-0.3333333333333333 / a) * (b - pow(((b * b) + (a * (-3.0 * c))), 0.5));
}

Fortran

real(8) function code(a, b, c)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8), intent (in) :: c
    code = ((-0.3333333333333333d0) / a) * (b - (((b * b) + (a * ((-3.0d0) * c))) ** 0.5d0))
end function

Java

public static double code(double a, double b, double c) {
	return (-0.3333333333333333 / a) * (b - Math.pow(((b * b) + (a * (-3.0 * c))), 0.5));
}

Python

def code(a, b, c):
	return (-0.3333333333333333 / a) * (b - math.pow(((b * b) + (a * (-3.0 * c))), 0.5))

Julia

function code(a, b, c)
	return Float64(Float64(-0.3333333333333333 / a) * Float64(b - (Float64(Float64(b * b) + Float64(a * Float64(-3.0 * c))) ^ 0.5)))
end

MATLAB

function tmp = code(a, b, c)
	tmp = (-0.3333333333333333 / a) * (b - (((b * b) + (a * (-3.0 * c))) ^ 0.5));
end

Wolfram

code[a_, b_, c_] := N[(N[(-0.3333333333333333 / a), $MachinePrecision] * N[(b - N[Power[N[(N[(b * b), $MachinePrecision] + N[(a * N[(-3.0 * c), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 0.5], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 57.7%

   \[\frac{\left(-b\right) + \sqrt{b \cdot b - \left(3 \cdot a\right) \cdot c}}{3 \cdot a} \]

3. Applied egg-rr 0

   \[\leadsto expr\]
4. Add Preprocessing

Reproduce

herbie shell --seed 2024103 
(FPCore (a b c)
  :name "Cubic critical, narrow range"
  :precision binary64
  :pre (and (and (and (< 1.0536712127723509e-8 a) (< a 94906265.62425156)) (and (< 1.0536712127723509e-8 b) (< b 94906265.62425156))) (and (< 1.0536712127723509e-8 c) (< c 94906265.62425156)))
  (/ (+ (- b) (sqrt (- (* b b) (* (* 3.0 a) c)))) (* 3.0 a)))