(/ (- x lo) (- hi lo))

Average Error: 62.0 → 43.7

Time: 3.4s

Precision: binary64

\[lo < -1 \cdot 10^{+308} \land hi > 10^{+308}\]

Math

\[\frac{x - lo}{hi - lo} \]

↓

\[\begin{array}{l} t_0 := \frac{x - lo}{hi}\\ t_1 := {\left(\frac{lo}{hi}\right)}^{2}\\ \left({\left(\left(-1 - \frac{lo}{hi}\right) \cdot t_1\right)}^{3} + {t_0}^{3}\right) \cdot \frac{1}{{\left(-t_1\right)}^{2} + t_0 \cdot \left(t_0 + t_1 \cdot \left(\frac{lo}{hi} + 1\right)\right)} \end{array} \]

FPCore

(FPCore (lo hi x) :precision binary64 (/ (- x lo) (- hi lo)))

↓

(FPCore (lo hi x)
 :precision binary64
 (let* ((t_0 (/ (- x lo) hi)) (t_1 (pow (/ lo hi) 2.0)))
   (*
    (+ (pow (* (- -1.0 (/ lo hi)) t_1) 3.0) (pow t_0 3.0))
    (/ 1.0 (+ (pow (- t_1) 2.0) (* t_0 (+ t_0 (* t_1 (+ (/ lo hi) 1.0)))))))))

C

double code(double lo, double hi, double x) {
	return (x - lo) / (hi - lo);
}

↓

double code(double lo, double hi, double x) {
	double t_0 = (x - lo) / hi;
	double t_1 = pow((lo / hi), 2.0);
	return (pow(((-1.0 - (lo / hi)) * t_1), 3.0) + pow(t_0, 3.0)) * (1.0 / (pow(-t_1, 2.0) + (t_0 * (t_0 + (t_1 * ((lo / hi) + 1.0))))));
}

Fortran

real(8) function code(lo, hi, x)
    real(8), intent (in) :: lo
    real(8), intent (in) :: hi
    real(8), intent (in) :: x
    code = (x - lo) / (hi - lo)
end function

↓

real(8) function code(lo, hi, x)
    real(8), intent (in) :: lo
    real(8), intent (in) :: hi
    real(8), intent (in) :: x
    real(8) :: t_0
    real(8) :: t_1
    t_0 = (x - lo) / hi
    t_1 = (lo / hi) ** 2.0d0
    code = (((((-1.0d0) - (lo / hi)) * t_1) ** 3.0d0) + (t_0 ** 3.0d0)) * (1.0d0 / ((-t_1 ** 2.0d0) + (t_0 * (t_0 + (t_1 * ((lo / hi) + 1.0d0))))))
end function

Java

public static double code(double lo, double hi, double x) {
	return (x - lo) / (hi - lo);
}

↓

public static double code(double lo, double hi, double x) {
	double t_0 = (x - lo) / hi;
	double t_1 = Math.pow((lo / hi), 2.0);
	return (Math.pow(((-1.0 - (lo / hi)) * t_1), 3.0) + Math.pow(t_0, 3.0)) * (1.0 / (Math.pow(-t_1, 2.0) + (t_0 * (t_0 + (t_1 * ((lo / hi) + 1.0))))));
}

Python

def code(lo, hi, x):
	return (x - lo) / (hi - lo)

↓

def code(lo, hi, x):
	t_0 = (x - lo) / hi
	t_1 = math.pow((lo / hi), 2.0)
	return (math.pow(((-1.0 - (lo / hi)) * t_1), 3.0) + math.pow(t_0, 3.0)) * (1.0 / (math.pow(-t_1, 2.0) + (t_0 * (t_0 + (t_1 * ((lo / hi) + 1.0))))))

Julia

function code(lo, hi, x)
	return Float64(Float64(x - lo) / Float64(hi - lo))
end

↓

function code(lo, hi, x)
	t_0 = Float64(Float64(x - lo) / hi)
	t_1 = Float64(lo / hi) ^ 2.0
	return Float64(Float64((Float64(Float64(-1.0 - Float64(lo / hi)) * t_1) ^ 3.0) + (t_0 ^ 3.0)) * Float64(1.0 / Float64((Float64(-t_1) ^ 2.0) + Float64(t_0 * Float64(t_0 + Float64(t_1 * Float64(Float64(lo / hi) + 1.0)))))))
end

MATLAB

function tmp = code(lo, hi, x)
	tmp = (x - lo) / (hi - lo);
end

↓

function tmp = code(lo, hi, x)
	t_0 = (x - lo) / hi;
	t_1 = (lo / hi) ^ 2.0;
	tmp = ((((-1.0 - (lo / hi)) * t_1) ^ 3.0) + (t_0 ^ 3.0)) * (1.0 / ((-t_1 ^ 2.0) + (t_0 * (t_0 + (t_1 * ((lo / hi) + 1.0))))));
end

Wolfram

code[lo_, hi_, x_] := N[(N[(x - lo), $MachinePrecision] / N[(hi - lo), $MachinePrecision]), $MachinePrecision]

↓

code[lo_, hi_, x_] := Block[{t$95$0 = N[(N[(x - lo), $MachinePrecision] / hi), $MachinePrecision]}, Block[{t$95$1 = N[Power[N[(lo / hi), $MachinePrecision], 2.0], $MachinePrecision]}, N[(N[(N[Power[N[(N[(-1.0 - N[(lo / hi), $MachinePrecision]), $MachinePrecision] * t$95$1), $MachinePrecision], 3.0], $MachinePrecision] + N[Power[t$95$0, 3.0], $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(N[Power[(-t$95$1), 2.0], $MachinePrecision] + N[(t$95$0 * N[(t$95$0 + N[(t$95$1 * N[(N[(lo / hi), $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Initial program 62.0

   \[\frac{x - lo}{hi - lo} \]

2. Taylor expanded in hi around inf 64.0

   \[\leadsto \color{blue}{\left(\frac{x}{hi} + \left(\frac{lo \cdot \left(x - lo\right)}{{hi}^{2}} + \frac{{lo}^{2} \cdot \left(x - lo\right)}{{hi}^{3}}\right)\right) - \frac{lo}{hi}} \]

3. Simplified 51.9

   \[\leadsto \color{blue}{\frac{x - lo}{hi} \cdot \left(\frac{lo}{hi} + \frac{lo}{hi} \cdot \frac{lo}{hi}\right) + \frac{x - lo}{hi}} \]

4. Taylor expanded in x around 0 64.0

   \[\leadsto \color{blue}{-1 \cdot \frac{\left(\frac{lo}{hi} + \frac{{lo}^{2}}{{hi}^{2}}\right) \cdot lo}{hi}} + \frac{x - lo}{hi} \]

5. Simplified 51.9

   \[\leadsto \color{blue}{\left(\frac{lo}{hi} \cdot \frac{lo}{hi}\right) \cdot \left(-1 - \frac{lo}{hi}\right)} + \frac{x - lo}{hi} \]

6. Applied egg-rr 51.9

   \[\leadsto \color{blue}{\left({\left(\left(-1 - \frac{lo}{hi}\right) \cdot {\left(\frac{lo}{hi}\right)}^{2}\right)}^{3} + {\left(\frac{x - lo}{hi}\right)}^{3}\right) \cdot \frac{1}{{\left(\left(-1 - \frac{lo}{hi}\right) \cdot {\left(\frac{lo}{hi}\right)}^{2}\right)}^{2} + \frac{x - lo}{hi} \cdot \left(\frac{x - lo}{hi} - \left(-1 - \frac{lo}{hi}\right) \cdot {\left(\frac{lo}{hi}\right)}^{2}\right)}} \]

7. Taylor expanded in lo around 0 43.7

   \[\leadsto \left({\left(\left(-1 - \frac{lo}{hi}\right) \cdot {\left(\frac{lo}{hi}\right)}^{2}\right)}^{3} + {\left(\frac{x - lo}{hi}\right)}^{3}\right) \cdot \frac{1}{{\left(\color{blue}{-1} \cdot {\left(\frac{lo}{hi}\right)}^{2}\right)}^{2} + \frac{x - lo}{hi} \cdot \left(\frac{x - lo}{hi} - \left(-1 - \frac{lo}{hi}\right) \cdot {\left(\frac{lo}{hi}\right)}^{2}\right)} \]

8. Final simplification 43.7

   \[\leadsto \left({\left(\left(-1 - \frac{lo}{hi}\right) \cdot {\left(\frac{lo}{hi}\right)}^{2}\right)}^{3} + {\left(\frac{x - lo}{hi}\right)}^{3}\right) \cdot \frac{1}{{\left(-{\left(\frac{lo}{hi}\right)}^{2}\right)}^{2} + \frac{x - lo}{hi} \cdot \left(\frac{x - lo}{hi} + {\left(\frac{lo}{hi}\right)}^{2} \cdot \left(\frac{lo}{hi} + 1\right)\right)} \]

Reproduce

herbie shell --seed 2022185 
(FPCore (lo hi x)
  :name "(/ (- x lo) (- hi lo))"
  :precision binary64
  :pre (and (< lo -1e+308) (> hi 1e+308))
  (/ (- x lo) (- hi lo)))