Average Error: 17.0 → 0.2
Time: 4.5s
Precision: binary64
\[\alpha > -1 \land \beta > -1\]
\[\frac{\frac{\beta - \alpha}{\left(\alpha + \beta\right) + 2} + 1}{2} \]
↓
\[\begin{array}{l} \mathbf{if}\;\frac{\beta - \alpha}{\left(\alpha + \beta\right) + 2} \leq -0.95:\\ \;\;\;\;\frac{\left(2 \cdot \frac{\beta}{\alpha} + 2 \cdot \frac{1}{\alpha}\right) - \frac{4 + \beta \cdot 6}{\alpha \cdot \alpha}}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{{\left({\left(\frac{\beta - \alpha}{\alpha + \left(2 + \beta\right)} + 1\right)}^{3}\right)}^{0.3333333333333333}}{2}\\ \end{array} \]
(FPCore (alpha beta)
 :precision binary64
 (/ (+ (/ (- beta alpha) (+ (+ alpha beta) 2.0)) 1.0) 2.0))
↓
(FPCore (alpha beta)
 :precision binary64
 (if (<= (/ (- beta alpha) (+ (+ alpha beta) 2.0)) -0.95)
   (/
    (-
     (+ (* 2.0 (/ beta alpha)) (* 2.0 (/ 1.0 alpha)))
     (/ (+ 4.0 (* beta 6.0)) (* alpha alpha)))
    2.0)
   (/
    (pow
     (pow (+ (/ (- beta alpha) (+ alpha (+ 2.0 beta))) 1.0) 3.0)
     0.3333333333333333)
    2.0)))
double code(double alpha, double beta) {
	return (((beta - alpha) / ((alpha + beta) + 2.0)) + 1.0) / 2.0;
}
↓
double code(double alpha, double beta) {
	double tmp;
	if (((beta - alpha) / ((alpha + beta) + 2.0)) <= -0.95) {
		tmp = (((2.0 * (beta / alpha)) + (2.0 * (1.0 / alpha))) - ((4.0 + (beta * 6.0)) / (alpha * alpha))) / 2.0;
	} else {
		tmp = pow(pow((((beta - alpha) / (alpha + (2.0 + beta))) + 1.0), 3.0), 0.3333333333333333) / 2.0;
	}
	return tmp;
}

real(8) function code(alpha, beta)
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    code = (((beta - alpha) / ((alpha + beta) + 2.0d0)) + 1.0d0) / 2.0d0
end function
↓
real(8) function code(alpha, beta)
    real(8), intent (in) :: alpha
    real(8), intent (in) :: beta
    real(8) :: tmp
    if (((beta - alpha) / ((alpha + beta) + 2.0d0)) <= (-0.95d0)) then
        tmp = (((2.0d0 * (beta / alpha)) + (2.0d0 * (1.0d0 / alpha))) - ((4.0d0 + (beta * 6.0d0)) / (alpha * alpha))) / 2.0d0
    else
        tmp = (((((beta - alpha) / (alpha + (2.0d0 + beta))) + 1.0d0) ** 3.0d0) ** 0.3333333333333333d0) / 2.0d0
    end if
    code = tmp
end function

public static double code(double alpha, double beta) {
	return (((beta - alpha) / ((alpha + beta) + 2.0)) + 1.0) / 2.0;
}
↓
public static double code(double alpha, double beta) {
	double tmp;
	if (((beta - alpha) / ((alpha + beta) + 2.0)) <= -0.95) {
		tmp = (((2.0 * (beta / alpha)) + (2.0 * (1.0 / alpha))) - ((4.0 + (beta * 6.0)) / (alpha * alpha))) / 2.0;
	} else {
		tmp = Math.pow(Math.pow((((beta - alpha) / (alpha + (2.0 + beta))) + 1.0), 3.0), 0.3333333333333333) / 2.0;
	}
	return tmp;
}

def code(alpha, beta):
	return (((beta - alpha) / ((alpha + beta) + 2.0)) + 1.0) / 2.0
↓
def code(alpha, beta):
	tmp = 0
	if ((beta - alpha) / ((alpha + beta) + 2.0)) <= -0.95:
		tmp = (((2.0 * (beta / alpha)) + (2.0 * (1.0 / alpha))) - ((4.0 + (beta * 6.0)) / (alpha * alpha))) / 2.0
	else:
		tmp = math.pow(math.pow((((beta - alpha) / (alpha + (2.0 + beta))) + 1.0), 3.0), 0.3333333333333333) / 2.0
	return tmp

function code(alpha, beta)
	return Float64(Float64(Float64(Float64(beta - alpha) / Float64(Float64(alpha + beta) + 2.0)) + 1.0) / 2.0)
end
↓
function code(alpha, beta)
	tmp = 0.0
	if (Float64(Float64(beta - alpha) / Float64(Float64(alpha + beta) + 2.0)) <= -0.95)
		tmp = Float64(Float64(Float64(Float64(2.0 * Float64(beta / alpha)) + Float64(2.0 * Float64(1.0 / alpha))) - Float64(Float64(4.0 + Float64(beta * 6.0)) / Float64(alpha * alpha))) / 2.0);
	else
		tmp = Float64(((Float64(Float64(Float64(beta - alpha) / Float64(alpha + Float64(2.0 + beta))) + 1.0) ^ 3.0) ^ 0.3333333333333333) / 2.0);
	end
	return tmp
end

function tmp = code(alpha, beta)
	tmp = (((beta - alpha) / ((alpha + beta) + 2.0)) + 1.0) / 2.0;
end
↓
function tmp_2 = code(alpha, beta)
	tmp = 0.0;
	if (((beta - alpha) / ((alpha + beta) + 2.0)) <= -0.95)
		tmp = (((2.0 * (beta / alpha)) + (2.0 * (1.0 / alpha))) - ((4.0 + (beta * 6.0)) / (alpha * alpha))) / 2.0;
	else
		tmp = (((((beta - alpha) / (alpha + (2.0 + beta))) + 1.0) ^ 3.0) ^ 0.3333333333333333) / 2.0;
	end
	tmp_2 = tmp;
end

code[alpha_, beta_] := N[(N[(N[(N[(beta - alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] / 2.0), $MachinePrecision]
↓
code[alpha_, beta_] := If[LessEqual[N[(N[(beta - alpha), $MachinePrecision] / N[(N[(alpha + beta), $MachinePrecision] + 2.0), $MachinePrecision]), $MachinePrecision], -0.95], N[(N[(N[(N[(2.0 * N[(beta / alpha), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(1.0 / alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(N[(4.0 + N[(beta * 6.0), $MachinePrecision]), $MachinePrecision] / N[(alpha * alpha), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / 2.0), $MachinePrecision], N[(N[Power[N[Power[N[(N[(N[(beta - alpha), $MachinePrecision] / N[(alpha + N[(2.0 + beta), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision], 3.0], $MachinePrecision], 0.3333333333333333], $MachinePrecision] / 2.0), $MachinePrecision]]

\frac{\frac{\beta - \alpha}{\left(\alpha + \beta\right) + 2} + 1}{2}
↓
\begin{array}{l}
\mathbf{if}\;\frac{\beta - \alpha}{\left(\alpha + \beta\right) + 2} \leq -0.95:\\
\;\;\;\;\frac{\left(2 \cdot \frac{\beta}{\alpha} + 2 \cdot \frac{1}{\alpha}\right) - \frac{4 + \beta \cdot 6}{\alpha \cdot \alpha}}{2}\\

\mathbf{else}:\\
\;\;\;\;\frac{{\left({\left(\frac{\beta - \alpha}{\alpha + \left(2 + \beta\right)} + 1\right)}^{3}\right)}^{0.3333333333333333}}{2}\\


\end{array}

Error

Bits error versus alpha

Bits error versus beta

Try it out

Your Program's Arguments

Results

Enter valid numbers for all inputs

Derivation

  1. Split input into 2 regimes

  2. if (/.f64 (-.f64 beta alpha) (+.f64 (+.f64 alpha beta) 2)) < -0.94999999999999996

    1. Initial program 58.7

      \[\frac{\frac{\beta - \alpha}{\left(\alpha + \beta\right) + 2} + 1}{2} \]

    2. Taylor expanded in alpha around inf 4.0

      \[\leadsto \frac{\color{blue}{\left(2 \cdot \frac{\beta}{\alpha} + 2 \cdot \frac{1}{\alpha}\right) - \left(6 \cdot \frac{\beta}{{\alpha}^{2}} + \left(2 \cdot \frac{{\beta}^{2}}{{\alpha}^{2}} + 4 \cdot \frac{1}{{\alpha}^{2}}\right)\right)}}{2} \]

    3. Taylor expanded in beta around 0 0.7

      \[\leadsto \frac{\left(2 \cdot \frac{\beta}{\alpha} + 2 \cdot \frac{1}{\alpha}\right) - \color{blue}{\left(6 \cdot \frac{\beta}{{\alpha}^{2}} + 4 \cdot \frac{1}{{\alpha}^{2}}\right)}}{2} \]

    4. Simplified0.7

      \[\leadsto \frac{\left(2 \cdot \frac{\beta}{\alpha} + 2 \cdot \frac{1}{\alpha}\right) - \color{blue}{\frac{4 + \beta \cdot 6}{\alpha \cdot \alpha}}}{2} \]

    if -0.94999999999999996 < (/.f64 (-.f64 beta alpha) (+.f64 (+.f64 alpha beta) 2))

    1. Initial program 0.0

      \[\frac{\frac{\beta - \alpha}{\left(\alpha + \beta\right) + 2} + 1}{2} \]

    2. Applied egg-rr0.0

      \[\leadsto \frac{\color{blue}{{\left({\left(\frac{\beta - \alpha}{\alpha + \left(2 + \beta\right)} + 1\right)}^{3}\right)}^{0.3333333333333333}}}{2} \]
  3. Recombined 2 regimes into one program.

  4. Final simplification0.2

    \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{\beta - \alpha}{\left(\alpha + \beta\right) + 2} \leq -0.95:\\ \;\;\;\;\frac{\left(2 \cdot \frac{\beta}{\alpha} + 2 \cdot \frac{1}{\alpha}\right) - \frac{4 + \beta \cdot 6}{\alpha \cdot \alpha}}{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{{\left({\left(\frac{\beta - \alpha}{\alpha + \left(2 + \beta\right)} + 1\right)}^{3}\right)}^{0.3333333333333333}}{2}\\ \end{array} \]

Reproduce

herbie shell --seed 2022194 
(FPCore (alpha beta)
  :name "Octave 3.8, jcobi/1"
  :precision binary64
  :pre (and (> alpha -1.0) (> beta -1.0))
  (/ (+ (/ (- beta alpha) (+ (+ alpha beta) 2.0)) 1.0) 2.0))