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

Average Error: 62.0 → 50.8

Time: 6.9s

Precision: binary64

Cost: 13376

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

Math

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

↓

\[\log \left(\left(1 - \frac{lo}{hi}\right) \cdot e^{\frac{x}{hi}}\right) \]

FPCore

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

↓

(FPCore (lo hi x)
 :precision binary64
 (log (* (- 1.0 (/ lo hi)) (exp (/ x hi)))))

C

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

↓

double code(double lo, double hi, double x) {
	return log(((1.0 - (lo / hi)) * exp((x / hi))));
}

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
    code = log(((1.0d0 - (lo / hi)) * exp((x / hi))))
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) {
	return Math.log(((1.0 - (lo / hi)) * Math.exp((x / hi))));
}

Python

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

↓

def code(lo, hi, x):
	return math.log(((1.0 - (lo / hi)) * math.exp((x / hi))))

Julia

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

↓

function code(lo, hi, x)
	return log(Float64(Float64(1.0 - Float64(lo / hi)) * exp(Float64(x / hi))))
end

MATLAB

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

↓

function tmp = code(lo, hi, x)
	tmp = log(((1.0 - (lo / hi)) * exp((x / hi))));
end

Wolfram

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

↓

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

Derivation

1. Initial program 62.0

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

2. Taylor expanded in hi around inf 52.0

   \[\leadsto \color{blue}{\frac{x - lo}{hi}} \]

3. Applied egg-rr 52.0

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

4. Applied egg-rr 52.0

   \[\leadsto \color{blue}{\log \left(e^{\frac{x - lo}{hi}}\right)} \]

5. Taylor expanded in lo around 0 50.8

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

6. Simplified 50.8

   \[\leadsto \log \color{blue}{\left(\left(1 - \frac{lo}{hi}\right) \cdot e^{\frac{x}{hi}}\right)} \]
   Proof
   (*.f64 (-.f64 1 (/.f64 lo hi)) (exp.f64 (/.f64 x hi))): 0 points increase in error, 0 points decrease in error
   (*.f64 (Rewrite=> sub-neg_binary64 (+.f64 1 (neg.f64 (/.f64 lo hi)))) (exp.f64 (/.f64 x hi))): 0 points increase in error, 0 points decrease in error
   (*.f64 (Rewrite=> +-commutative_binary64 (+.f64 (neg.f64 (/.f64 lo hi)) 1)) (exp.f64 (/.f64 x hi))): 0 points increase in error, 0 points decrease in error
   (Rewrite<= distribute-lft1-in_binary64 (+.f64 (*.f64 (neg.f64 (/.f64 lo hi)) (exp.f64 (/.f64 x hi))) (exp.f64 (/.f64 x hi)))): 2 points increase in error, 1 points decrease in error
   (+.f64 (Rewrite<= distribute-lft-neg-in_binary64 (neg.f64 (*.f64 (/.f64 lo hi) (exp.f64 (/.f64 x hi))))) (exp.f64 (/.f64 x hi))): 0 points increase in error, 0 points decrease in error
   (+.f64 (neg.f64 (Rewrite=> associate-*l/_binary64 (/.f64 (*.f64 lo (exp.f64 (/.f64 x hi))) hi))) (exp.f64 (/.f64 x hi))): 0 points increase in error, 0 points decrease in error
   (+.f64 (Rewrite<= mul-1-neg_binary64 (*.f64 -1 (/.f64 (*.f64 lo (exp.f64 (/.f64 x hi))) hi))) (exp.f64 (/.f64 x hi))): 0 points increase in error, 0 points decrease in error

7. Final simplification 50.8

   \[\leadsto \log \left(\left(1 - \frac{lo}{hi}\right) \cdot e^{\frac{x}{hi}}\right) \]

Alternatives

Alternative 1
Error	50.8
Cost	6848

\[\log \left(1 + \frac{x - lo}{hi}\right) \]

Alternative 2
Error	51.6
Cost	448

\[\frac{hi}{lo} \cdot \frac{hi}{lo} \]

Alternative 3
Error	52.0
Cost	320

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

Alternative 4
Error	52.0
Cost	256

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

Alternative 5
Error	52.1
Cost	64

\[1 \]

Reproduce

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