xlohi (overflows)

Percentage Accurate: 3.1% → 18.9%

Time: 9.7s

Alternatives: 5

Speedup: 7.0×

Specification

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

Math

\[\begin{array}{l} \\ \frac{x - lo}{hi - lo} \end{array} \]

FPCore

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

C

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

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 3.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{x - lo}{hi - lo} \end{array} \]

FPCore

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

C

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

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 18.9% accurate, 0.0× speedup

Math

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

FPCore

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

C

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

Java

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

Julia

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

Wolfram

code[lo_, hi_, x_] := N[(N[(-1.0 * N[(x * N[(N[(1.0 / lo), $MachinePrecision] - N[(1.0 / x), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(hi * N[(N[(N[(1.0 / lo), $MachinePrecision] + N[(N[Power[N[Power[N[(hi * N[(N[(1.0 / lo), $MachinePrecision] - N[(x * N[Power[lo, -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision], 1/3], $MachinePrecision] / lo), $MachinePrecision]), $MachinePrecision] - N[(N[(x / lo), $MachinePrecision] * N[(1.0 / lo), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 3.1%

   \[\frac{x - lo}{hi - lo} \]
2. Add Preprocessing

3. Taylor expanded in hi around 0 18.8%

   \[\leadsto \color{blue}{-1 \cdot \frac{x - lo}{lo} + hi \cdot \left(\left(\frac{1}{lo} + \frac{hi \cdot \left(\frac{1}{lo} - \frac{x}{{lo}^{2}}\right)}{lo}\right) - \frac{x}{{lo}^{2}}\right)} \]
4. Step-by-step derivation

   1. add-cbrt-cube 18.8%

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

   2. pow3 18.8%

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

   3. div-inv 18.8%

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

   4. pow-flip 18.8%

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

   5. metadata-eval 18.8%

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

5. Applied egg-rr 18.8%

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

6. Taylor expanded in x around inf 18.9%

   \[\leadsto -1 \cdot \color{blue}{\left(x \cdot \left(\frac{1}{lo} - \frac{1}{x}\right)\right)} + hi \cdot \left(\left(\frac{1}{lo} + \frac{\sqrt[3]{{\left(hi \cdot \left(\frac{1}{lo} - x \cdot {lo}^{-2}\right)\right)}^{3}}}{lo}\right) - \frac{x}{{lo}^{2}}\right) \]
7. Step-by-step derivation

   1. *-un-lft-identity 18.9%

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

   2. unpow2 18.9%

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

   3. frac-times 18.9%

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

   4. *-commutative 18.9%

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

8. Applied egg-rr 18.9%

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

Alternative 2: 18.9% accurate, 0.1× speedup

Math

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

FPCore

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

C

double code(double lo, double hi, double x) {
	return (-1.0 * -1.0) + (hi * (((1.0 + (hi / lo)) / lo) - (x / pow(lo, 2.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 = ((-1.0d0) * (-1.0d0)) + (hi * (((1.0d0 + (hi / lo)) / lo) - (x / (lo ** 2.0d0))))
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 3.1%

   \[\frac{x - lo}{hi - lo} \]
2. Add Preprocessing

3. Taylor expanded in hi around 0 18.8%

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

4. Taylor expanded in x around 0 18.9%

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

5. Taylor expanded in lo around inf 18.9%

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

Alternative 3: 18.9% accurate, 0.2× speedup

Math

\[\begin{array}{l} \\ -1 \cdot \frac{x - lo}{lo} + hi \cdot \left(\left(\frac{1}{lo} + \frac{hi \cdot \left(\frac{1}{lo} - \frac{1}{lo} \cdot \frac{x}{lo}\right)}{lo}\right) - \frac{x}{lo} \cdot \frac{1}{lo}\right) \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 3.1%

   \[\frac{x - lo}{hi - lo} \]
2. Add Preprocessing

3. Taylor expanded in hi around 0 18.8%

   \[\leadsto \color{blue}{-1 \cdot \frac{x - lo}{lo} + hi \cdot \left(\left(\frac{1}{lo} + \frac{hi \cdot \left(\frac{1}{lo} - \frac{x}{{lo}^{2}}\right)}{lo}\right) - \frac{x}{{lo}^{2}}\right)} \]
4. Step-by-step derivation

   1. *-un-lft-identity 18.8%

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

   2. unpow2 18.8%

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

   3. times-frac 18.8%

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

5. Applied egg-rr 18.8%

   \[\leadsto -1 \cdot \frac{x - lo}{lo} + hi \cdot \left(\left(\frac{1}{lo} + \frac{hi \cdot \left(\frac{1}{lo} - \color{blue}{\frac{1}{lo} \cdot \frac{x}{lo}}\right)}{lo}\right) - \frac{x}{{lo}^{2}}\right) \]
6. Step-by-step derivation

   1. *-un-lft-identity 18.8%

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

   2. unpow2 18.8%

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

   3. frac-times 18.8%

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

   4. *-commutative 18.8%

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

7. Applied egg-rr 18.8%

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

Alternative 4: 18.8% accurate, 1.4× speedup

Math

\[\begin{array}{l} \\ \frac{x - lo}{hi} \end{array} \]

FPCore

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

C

double code(double lo, double hi, double x) {
	return (x - lo) / 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
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 3.1%

   \[\frac{x - lo}{hi - lo} \]
2. Add Preprocessing

3. Taylor expanded in hi around inf 18.7%

   \[\leadsto \color{blue}{\frac{x - lo}{hi}} \]
4. Add Preprocessing

Alternative 5: 18.7% accurate, 7.0× speedup

Math

\[\begin{array}{l} \\ 1 \end{array} \]

FPCore

(FPCore (lo hi x) :precision binary64 1.0)

C

double code(double lo, double hi, double x) {
	return 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 = 1.0d0
end function

Java

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

Python

def code(lo, hi, x):
	return 1.0

Julia

function code(lo, hi, x)
	return 1.0
end

MATLAB

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

Wolfram

code[lo_, hi_, x_] := 1.0

Derivation

1. Initial program 3.1%

   \[\frac{x - lo}{hi - lo} \]
2. Add Preprocessing

3. Taylor expanded in lo around inf 18.7%

   \[\leadsto \color{blue}{1} \]
4. Add Preprocessing

Reproduce

herbie shell --seed 2024052 -o generate:simplify
(FPCore (lo hi x)
  :name "xlohi (overflows)"
  :precision binary64
  :pre (and (< lo -1e+308) (> hi 1e+308))
  (/ (- x lo) (- hi lo)))