xlohi (overflows)

Percentage Accurate: 3.1% → 98.7%

Time: 10.4s

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: 98.7% accurate, 0.0× speedup

Math

\[\begin{array}{l} \\ e^{-\mathsf{log1p}\left(\frac{-hi}{lo}\right)} \end{array} \]

FPCore

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

C

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

Java

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

Python

def code(lo, hi, x):
	return math.exp(-math.log1p((-hi / lo)))

Julia

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

Wolfram

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

Derivation

1. Initial program 3.1%

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

3. Taylor expanded in x around 0 3.1%

   \[\leadsto \color{blue}{-1 \cdot \frac{lo}{hi - lo}} \]
4. Step-by-step derivation

   1. associate-*r/ 3.1%

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

   2. associate-/l* 3.1%

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

   3. div-sub 97.9%

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

   4. *-inverses 97.9%

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

5. Simplified 97.9%

   \[\leadsto \color{blue}{\frac{-1}{\frac{hi}{lo} - 1}} \]
6. Step-by-step derivation

   1. div-inv 97.5%

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

   2. fma-neg 97.6%

      \[\leadsto \frac{-1}{\color{blue}{\mathsf{fma}\left(hi, \frac{1}{lo}, -1\right)}} \]

   3. metadata-eval 97.6%

      \[\leadsto \frac{-1}{\mathsf{fma}\left(hi, \frac{1}{lo}, \color{blue}{-1}\right)} \]

7. Applied egg-rr 97.6%

   \[\leadsto \frac{-1}{\color{blue}{\mathsf{fma}\left(hi, \frac{1}{lo}, -1\right)}} \]
8. Step-by-step derivation

   1. fma-udef 97.5%

      \[\leadsto \frac{-1}{\color{blue}{hi \cdot \frac{1}{lo} + -1}} \]

   2. div-inv 97.9%

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

   3. +-commutative 97.9%

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

   4. add-exp-log 97.9%

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

   5. frac-2neg 97.9%

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

   6. metadata-eval 97.9%

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

   7. log-rec 97.8%

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

   8. distribute-neg-in 97.8%

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

   9. metadata-eval 97.8%

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

   10. *-rgt-identity 97.8%

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

   11. sub-neg 97.8%

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

   12. *-rgt-identity 97.8%

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

9. Applied egg-rr 97.8%

   \[\leadsto \color{blue}{e^{-\log \left(1 - \frac{hi}{lo}\right)}} \]
10. Step-by-step derivation

    1. add-sqr-sqrt 97.6%

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

    2. sqrt-unprod 97.8%

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

    3. sqr-neg 97.8%

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

    4. sqrt-unprod 0.0%

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

    5. add-sqr-sqrt 17.2%

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

    6. neg-log 17.2%

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

    7. metadata-eval 17.2%

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

    8. sub-neg 17.2%

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

    9. metadata-eval 17.2%

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

    10. distribute-neg-in 17.2%

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

    11. frac-2neg 17.2%

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

    12. log1p-expm1-u 17.2%

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

    13. *-un-lft-identity 17.2%

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

    14. log1p-expm1-u 17.2%

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

    15. log-prod 17.2%

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

    16. metadata-eval 17.2%

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

    17. clear-num 17.2%

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

    18. frac-2neg 17.2%

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

11. Applied egg-rr 98.1%

    \[\leadsto e^{-\color{blue}{\left(0 + \mathsf{log1p}\left(\frac{-hi}{lo}\right)\right)}} \]
12. Step-by-step derivation

    1. +-lft-identity 98.1%

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

13. Simplified 98.1%

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

14. Final simplification 98.1%

    \[\leadsto e^{-\mathsf{log1p}\left(\frac{-hi}{lo}\right)} \]
15. Add Preprocessing

Alternative 2: 98.5% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 3.1%

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

3. Taylor expanded in x around 0 3.1%

   \[\leadsto \color{blue}{-1 \cdot \frac{lo}{hi - lo}} \]
4. Step-by-step derivation

   1. associate-*r/ 3.1%

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

   2. associate-/l* 3.1%

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

   3. div-sub 97.9%

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

   4. *-inverses 97.9%

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

5. Simplified 97.9%

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

6. Final simplification 97.9%

   \[\leadsto \frac{-1}{-1 + \frac{hi}{lo}} \]
7. Add Preprocessing

Alternative 3: 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.8%

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

4. Final simplification 18.8%

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

Alternative 4: 18.8% accurate, 1.8× speedup

Math

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

FPCore

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

C

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 3.1%

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

3. Taylor expanded in x around 0 3.1%

   \[\leadsto \color{blue}{-1 \cdot \frac{lo}{hi - lo}} \]
4. Step-by-step derivation

   1. associate-*r/ 3.1%

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

   2. associate-/l* 3.1%

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

   3. div-sub 97.9%

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

   4. *-inverses 97.9%

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

5. Simplified 97.9%

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

6. Taylor expanded in hi around inf 18.8%

   \[\leadsto \color{blue}{-1 \cdot \frac{lo}{hi}} \]
7. Step-by-step derivation

   1. associate-*r/ 18.8%

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

   2. neg-mul-1 18.8%

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

8. Simplified 18.8%

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

9. Final simplification 18.8%

   \[\leadsto \frac{-lo}{hi} \]
10. 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. Final simplification 18.7%

   \[\leadsto 1 \]
5. Add Preprocessing

Reproduce

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