Cubic critical, narrow range

Percentage Accurate: 55.8% → 99.1%

Time: 15.9s

Alternatives: 11

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: 55.8% 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, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{-0.3333333333333333}{a} \cdot \left(\left(a \cdot 3\right) \cdot \frac{c}{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)
  (* (* a 3.0) (/ c (+ b (pow (+ (* b b) (* a (* -3.0 c))) 0.5))))))

C

double code(double a, double b, double c) {
	return (-0.3333333333333333 / a) * ((a * 3.0) * (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) * ((a * 3.0d0) * (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) * ((a * 3.0) * (c / (b + Math.pow(((b * b) + (a * (-3.0 * c))), 0.5))));
}

Python

def code(a, b, c):
	return (-0.3333333333333333 / a) * ((a * 3.0) * (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(a * 3.0) * Float64(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) * ((a * 3.0) * (c / (b + (((b * b) + (a * (-3.0 * c))) ^ 0.5))));
end

Wolfram

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

Derivation

1. Initial program 51.6%

   \[\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\]
10. Add Preprocessing

Alternative 2: 99.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{-0.3333333333333333}{a} \cdot \left(c \cdot \frac{a \cdot 3}{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)
  (* 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.3333333333333333 / 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.3333333333333333d0) / 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.3333333333333333 / a) * (c * ((a * 3.0) / (b + Math.pow(((b * b) + (a * (-3.0 * c))), 0.5))));
}

Python

def code(a, b, c):
	return (-0.3333333333333333 / 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.3333333333333333 / a) * Float64(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.3333333333333333 / a) * (c * ((a * 3.0) / (b + (((b * b) + (a * (-3.0 * c))) ^ 0.5))));
end

Wolfram

code[a_, b_, c_] := N[(N[(-0.3333333333333333 / a), $MachinePrecision] * N[(c * 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]), $MachinePrecision]

Derivation

1. Initial program 51.6%

   \[\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\]
10. Add Preprocessing

Alternative 3: 99.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{-0.3333333333333333}{a} \cdot \left(a \cdot \frac{c \cdot 3}{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)
  (* a (/ (* c 3.0) (+ b (pow (+ (* b b) (* a (* -3.0 c))) 0.5))))))

C

double code(double a, double b, double c) {
	return (-0.3333333333333333 / a) * (a * ((c * 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.3333333333333333d0) / a) * (a * ((c * 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.3333333333333333 / a) * (a * ((c * 3.0) / (b + Math.pow(((b * b) + (a * (-3.0 * c))), 0.5))));
}

Python

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

Julia

function code(a, b, c)
	return Float64(Float64(-0.3333333333333333 / a) * Float64(a * Float64(Float64(c * 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.3333333333333333 / a) * (a * ((c * 3.0) / (b + (((b * b) + (a * (-3.0 * c))) ^ 0.5))));
end

Wolfram

code[a_, b_, c_] := N[(N[(-0.3333333333333333 / a), $MachinePrecision] * N[(a * N[(N[(c * 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]), $MachinePrecision]

Derivation

1. Initial program 51.6%

   \[\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\]
10. Add Preprocessing

Alternative 4: 55.8% accurate, 1.0× speedup

Math

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

FPCore

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

C

double code(double a, double b, double c) {
	return 1.0 / (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 = 1.0d0 / (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 1.0 / (a * (-3.0 / (b - Math.pow(((b * b) + (a * (-3.0 * c))), 0.5))));
}

Python

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

Julia

function code(a, b, c)
	return Float64(1.0 / Float64(a * Float64(-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 = 1.0 / (a * (-3.0 / (b - (((b * b) + (a * (-3.0 * c))) ^ 0.5))));
end

Wolfram

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

Derivation

1. Initial program 51.6%

   \[\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 5: 55.8% accurate, 1.0× speedup

Math

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

FPCore

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

C

double code(double a, double b, double c) {
	return -1.0 / ((3.0 * 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 = (-1.0d0) / ((3.0d0 * a) / (b - (((b * b) + (a * ((-3.0d0) * c))) ** 0.5d0)))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[a_, b_, c_] := N[(-1.0 / N[(N[(3.0 * 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]), $MachinePrecision]

Derivation

1. Initial program 51.6%

   \[\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

Alternative 6: 55.8% accurate, 1.0× speedup

Math

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

FPCore

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

C

double code(double a, double b, double c) {
	return ((pow(((b * b) + (a * (-3.0 * c))), 0.5) - b) / 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 * b) + (a * ((-3.0d0) * c))) ** 0.5d0) - b) / 3.0d0) / a
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 51.6%

   \[\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 7: 55.8% accurate, 1.0× speedup

Math

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

FPCore

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

C

double code(double a, double b, double c) {
	return ((b - pow(((b * b) + (a * (-3.0 * c))), 0.5)) * -0.3333333333333333) / 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 - (((b * b) + (a * ((-3.0d0) * c))) ** 0.5d0)) * (-0.3333333333333333d0)) / a
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 51.6%

   \[\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 8: 55.8% 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 51.6%

   \[\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

Alternative 9: 55.8% accurate, 1.0× speedup

Math

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

FPCore

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

C

double code(double a, double b, double c) {
	return -0.3333333333333333 * ((b - pow(((b * b) + (a * (-3.0 * c))), 0.5)) / 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 = (-0.3333333333333333d0) * ((b - (((b * b) + (a * ((-3.0d0) * c))) ** 0.5d0)) / a)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 51.6%

   \[\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 10: 13.1% accurate, 1.0× speedup

Math

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

FPCore

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

C

double code(double a, double b, double c) {
	return -0.3333333333333333 / (pow((0.0 - (-3.0 * (a * c))), -0.5) * 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 = (-0.3333333333333333d0) / (((0.0d0 - ((-3.0d0) * (a * c))) ** (-0.5d0)) * a)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 51.6%

   \[\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 11: 0.0% accurate, 1.1× speedup

Math

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

FPCore

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

C

double code(double a, double b, double c) {
	return (-0.3333333333333333 / pow((a * (-3.0 * c)), -0.5)) / 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 = ((-0.3333333333333333d0) / ((a * ((-3.0d0) * c)) ** (-0.5d0))) / a
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 51.6%

   \[\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\]
10. Add Preprocessing

Reproduce

herbie shell --seed 2024107 
(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)))