# ?

Average Error: 0.6 → 0.3
Time: 16.4s
Precision: binary64
Cost: 832

# ?

$2.04 \leq x \land x \leq 2.66$
$\frac{\left(4 \cdot x\right) \cdot x}{1 + \frac{x}{1.11} \cdot \frac{x}{1.11}}$
$\frac{x \cdot \left(4 \cdot x\right)}{1 + \frac{x \cdot x}{1.2321000000000002}}$
(FPCore (x)
:precision binary64
(/ (* (* 4.0 x) x) (+ 1.0 (* (/ x 1.11) (/ x 1.11)))))
(FPCore (x)
:precision binary64
(/ (* x (* 4.0 x)) (+ 1.0 (/ (* x x) 1.2321000000000002))))
double code(double x) {
return ((4.0 * x) * x) / (1.0 + ((x / 1.11) * (x / 1.11)));
}

double code(double x) {
return (x * (4.0 * x)) / (1.0 + ((x * x) / 1.2321000000000002));
}

real(8) function code(x)
real(8), intent (in) :: x
code = ((4.0d0 * x) * x) / (1.0d0 + ((x / 1.11d0) * (x / 1.11d0)))
end function

real(8) function code(x)
real(8), intent (in) :: x
code = (x * (4.0d0 * x)) / (1.0d0 + ((x * x) / 1.2321000000000002d0))
end function

public static double code(double x) {
return ((4.0 * x) * x) / (1.0 + ((x / 1.11) * (x / 1.11)));
}

public static double code(double x) {
return (x * (4.0 * x)) / (1.0 + ((x * x) / 1.2321000000000002));
}

def code(x):
return ((4.0 * x) * x) / (1.0 + ((x / 1.11) * (x / 1.11)))

def code(x):
return (x * (4.0 * x)) / (1.0 + ((x * x) / 1.2321000000000002))

function code(x)
return Float64(Float64(Float64(4.0 * x) * x) / Float64(1.0 + Float64(Float64(x / 1.11) * Float64(x / 1.11))))
end

function code(x)
return Float64(Float64(x * Float64(4.0 * x)) / Float64(1.0 + Float64(Float64(x * x) / 1.2321000000000002)))
end

function tmp = code(x)
tmp = ((4.0 * x) * x) / (1.0 + ((x / 1.11) * (x / 1.11)));
end

function tmp = code(x)
tmp = (x * (4.0 * x)) / (1.0 + ((x * x) / 1.2321000000000002));
end

code[x_] := N[(N[(N[(4.0 * x), $MachinePrecision] * x),$MachinePrecision] / N[(1.0 + N[(N[(x / 1.11), $MachinePrecision] * N[(x / 1.11),$MachinePrecision]), $MachinePrecision]),$MachinePrecision]), $MachinePrecision]  code[x_] := N[(N[(x * N[(4.0 * x),$MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(N[(x * x),$MachinePrecision] / 1.2321000000000002), $MachinePrecision]),$MachinePrecision]), \$MachinePrecision]

\frac{\left(4 \cdot x\right) \cdot x}{1 + \frac{x}{1.11} \cdot \frac{x}{1.11}}

\frac{x \cdot \left(4 \cdot x\right)}{1 + \frac{x \cdot x}{1.2321000000000002}}


# Try it out?

Your Program's Arguments

Results

 In Out
Enter valid numbers for all inputs

# Derivation?

1. Initial program 0.6

$\frac{\left(4 \cdot x\right) \cdot x}{1 + \frac{x}{1.11} \cdot \frac{x}{1.11}}$
2. Applied egg-rr0.3

$\leadsto \frac{\left(4 \cdot x\right) \cdot x}{1 + \color{blue}{\frac{x \cdot x}{1.2321000000000002}}}$
3. Final simplification0.3

$\leadsto \frac{x \cdot \left(4 \cdot x\right)}{1 + \frac{x \cdot x}{1.2321000000000002}}$

# Alternatives

Alternative 1
Error0.3
Cost832
$\frac{x \cdot \left(4 \cdot x\right)}{1 + \left(x \cdot x\right) \cdot 0.8116224332440547}$
Alternative 2
Error0.4
Cost704
$\frac{4 \cdot x}{x \cdot 0.8116224332440547 + \frac{1}{x}}$
Alternative 3
Error48.4
Cost448
$4.928400000000001 + \frac{-6.072281640000002}{x \cdot x}$
Alternative 4
Error48.4
Cost448
$4.928400000000001 + \frac{\frac{-6.072281640000002}{x}}{x}$
Alternative 5
Error49.9
Cost64
$4.928400000000001$

# Reproduce?

herbie shell --seed 1
(FPCore (x)
:name "((4.0 * x) * x) / (1.0 + ((x / 1.11) * (x / 1.11)))"
:precision binary64
:pre (and (<= 2.04 x) (<= x 2.66))
(/ (* (* 4.0 x) x) (+ 1.0 (* (/ x 1.11) (/ x 1.11)))))