fabs fraction 2

Percentage Accurate: 100.0% → 100.0%

Time: 2.7s

Alternatives: 3

Speedup: 21.0×

Specification

Math

\[\begin{array}{l} \\ \frac{\left|a - b\right|}{2} \end{array} \]

FPCore

(FPCore (a b) :precision binary64 (/ (fabs (- a b)) 2.0))

C

double code(double a, double b) {
	return fabs((a - b)) / 2.0;
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = abs((a - b)) / 2.0d0
end function

Java

public static double code(double a, double b) {
	return Math.abs((a - b)) / 2.0;
}

Python

def code(a, b):
	return math.fabs((a - b)) / 2.0

Julia

function code(a, b)
	return Float64(abs(Float64(a - b)) / 2.0)
end

MATLAB

function tmp = code(a, b)
	tmp = abs((a - b)) / 2.0;
end

Wolfram

code[a_, b_] := N[(N[Abs[N[(a - b), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]

Initial Program: 100.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{\left|a - b\right|}{2} \end{array} \]

FPCore

(FPCore (a b) :precision binary64 (/ (fabs (- a b)) 2.0))

C

double code(double a, double b) {
	return fabs((a - b)) / 2.0;
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = abs((a - b)) / 2.0d0
end function

Java

public static double code(double a, double b) {
	return Math.abs((a - b)) / 2.0;
}

Python

def code(a, b):
	return math.fabs((a - b)) / 2.0

Julia

function code(a, b)
	return Float64(abs(Float64(a - b)) / 2.0)
end

MATLAB

function tmp = code(a, b)
	tmp = abs((a - b)) / 2.0;
end

Wolfram

code[a_, b_] := N[(N[Abs[N[(a - b), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]

Alternative 1: 100.0% accurate, 21.0× speedup

Math

\[\begin{array}{l} [a, b] = \mathsf{sort}([a, b])\\ \\ \frac{b - a}{2} \end{array} \]

FPCore

NOTE: a and b should be sorted in increasing order before calling this function.
(FPCore (a b) :precision binary64 (/ (- b a) 2.0))

C

assert(a < b);
double code(double a, double b) {
	return (b - a) / 2.0;
}

Fortran

NOTE: a and b should be sorted in increasing order before calling this function.
real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = (b - a) / 2.0d0
end function

Java

assert a < b;
public static double code(double a, double b) {
	return (b - a) / 2.0;
}

Python

[a, b] = sort([a, b])
def code(a, b):
	return (b - a) / 2.0

Julia

a, b = sort([a, b])
function code(a, b)
	return Float64(Float64(b - a) / 2.0)
end

MATLAB

a, b = num2cell(sort([a, b])){:}
function tmp = code(a, b)
	tmp = (b - a) / 2.0;
end

Wolfram

NOTE: a and b should be sorted in increasing order before calling this function.
code[a_, b_] := N[(N[(b - a), $MachinePrecision] / 2.0), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\frac{\left|a - b\right|}{2} \]
2. Step-by-step derivation

   1. fabs-sub 100.0%

      \[\leadsto \frac{\color{blue}{\left|b - a\right|}}{2} \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{\frac{\left|b - a\right|}{2}} \]
4. Add Preprocessing

5. Taylor expanded in b around -inf 100.0%

   \[\leadsto \frac{\color{blue}{\left|-\left(a + -1 \cdot b\right)\right|}}{2} \]
6. Step-by-step derivation

   1. fabs-neg 100.0%

      \[\leadsto \frac{\color{blue}{\left|a + -1 \cdot b\right|}}{2} \]

   2. mul-1-neg 100.0%

      \[\leadsto \frac{\left|a + \color{blue}{\left(-b\right)}\right|}{2} \]

   3. sub-neg 100.0%

      \[\leadsto \frac{\left|\color{blue}{a - b}\right|}{2} \]

   4. fabs-sub 100.0%

      \[\leadsto \frac{\color{blue}{\left|b - a\right|}}{2} \]

   5. rem-square-sqrt 46.5%

      \[\leadsto \frac{\left|\color{blue}{\sqrt{b - a} \cdot \sqrt{b - a}}\right|}{2} \]

   6. fabs-sqr 46.5%

      \[\leadsto \frac{\color{blue}{\sqrt{b - a} \cdot \sqrt{b - a}}}{2} \]

   7. rem-square-sqrt 47.4%

      \[\leadsto \frac{\color{blue}{b - a}}{2} \]

7. Simplified 47.4%

   \[\leadsto \frac{\color{blue}{b - a}}{2} \]
8. Add Preprocessing

Alternative 2: 82.8% accurate, 13.1× speedup

Math

\[\begin{array}{l} [a, b] = \mathsf{sort}([a, b])\\ \\ \begin{array}{l} \mathbf{if}\;a \leq -4.5 \cdot 10^{-111}:\\ \;\;\;\;a \cdot -0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{b}{2}\\ \end{array} \end{array} \]

FPCore

NOTE: a and b should be sorted in increasing order before calling this function.
(FPCore (a b) :precision binary64 (if (<= a -4.5e-111) (* a -0.5) (/ b 2.0)))

C

assert(a < b);
double code(double a, double b) {
	double tmp;
	if (a <= -4.5e-111) {
		tmp = a * -0.5;
	} else {
		tmp = b / 2.0;
	}
	return tmp;
}

Fortran

NOTE: a and b should be sorted in increasing order before calling this function.
real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (a <= (-4.5d-111)) then
        tmp = a * (-0.5d0)
    else
        tmp = b / 2.0d0
    end if
    code = tmp
end function

Java

assert a < b;
public static double code(double a, double b) {
	double tmp;
	if (a <= -4.5e-111) {
		tmp = a * -0.5;
	} else {
		tmp = b / 2.0;
	}
	return tmp;
}

Python

[a, b] = sort([a, b])
def code(a, b):
	tmp = 0
	if a <= -4.5e-111:
		tmp = a * -0.5
	else:
		tmp = b / 2.0
	return tmp

Julia

a, b = sort([a, b])
function code(a, b)
	tmp = 0.0
	if (a <= -4.5e-111)
		tmp = Float64(a * -0.5);
	else
		tmp = Float64(b / 2.0);
	end
	return tmp
end

MATLAB

a, b = num2cell(sort([a, b])){:}
function tmp_2 = code(a, b)
	tmp = 0.0;
	if (a <= -4.5e-111)
		tmp = a * -0.5;
	else
		tmp = b / 2.0;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: a and b should be sorted in increasing order before calling this function.
code[a_, b_] := If[LessEqual[a, -4.5e-111], N[(a * -0.5), $MachinePrecision], N[(b / 2.0), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if a < -4.49999999999999994e-111

   1. Initial program 100.0%

      \[\frac{\left|a - b\right|}{2} \]
   2. Step-by-step derivation

      1. fabs-sub 100.0%

         \[\leadsto \frac{\color{blue}{\left|b - a\right|}}{2} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{\left|b - a\right|}{2}} \]
   4. Add Preprocessing

   5. Taylor expanded in b around -inf 100.0%

      \[\leadsto \frac{\color{blue}{\left|-\left(a + -1 \cdot b\right)\right|}}{2} \]
   6. Step-by-step derivation

      1. fabs-neg 100.0%

         \[\leadsto \frac{\color{blue}{\left|a + -1 \cdot b\right|}}{2} \]

      2. mul-1-neg 100.0%

         \[\leadsto \frac{\left|a + \color{blue}{\left(-b\right)}\right|}{2} \]

      3. sub-neg 100.0%

         \[\leadsto \frac{\left|\color{blue}{a - b}\right|}{2} \]

      4. fabs-sub 100.0%

         \[\leadsto \frac{\color{blue}{\left|b - a\right|}}{2} \]

      5. rem-square-sqrt 71.7%

         \[\leadsto \frac{\left|\color{blue}{\sqrt{b - a} \cdot \sqrt{b - a}}\right|}{2} \]

      6. fabs-sqr 71.7%

         \[\leadsto \frac{\color{blue}{\sqrt{b - a} \cdot \sqrt{b - a}}}{2} \]

      7. rem-square-sqrt 72.5%

         \[\leadsto \frac{\color{blue}{b - a}}{2} \]

   7. Simplified 72.5%

      \[\leadsto \frac{\color{blue}{b - a}}{2} \]

   8. Taylor expanded in b around 0 57.3%

      \[\leadsto \color{blue}{-0.5 \cdot a} \]

   if -4.49999999999999994e-111 < a

   1. Initial program 100.0%

      \[\frac{\left|a - b\right|}{2} \]
   2. Step-by-step derivation

      1. fabs-sub 100.0%

         \[\leadsto \frac{\color{blue}{\left|b - a\right|}}{2} \]

   3. Simplified 100.0%

      \[\leadsto \color{blue}{\frac{\left|b - a\right|}{2}} \]
   4. Add Preprocessing

   5. Taylor expanded in b around -inf 100.0%

      \[\leadsto \frac{\color{blue}{\left|-\left(a + -1 \cdot b\right)\right|}}{2} \]
   6. Step-by-step derivation

      1. fabs-neg 100.0%

         \[\leadsto \frac{\color{blue}{\left|a + -1 \cdot b\right|}}{2} \]

      2. mul-1-neg 100.0%

         \[\leadsto \frac{\left|a + \color{blue}{\left(-b\right)}\right|}{2} \]

      3. sub-neg 100.0%

         \[\leadsto \frac{\left|\color{blue}{a - b}\right|}{2} \]

      4. fabs-sub 100.0%

         \[\leadsto \frac{\color{blue}{\left|b - a\right|}}{2} \]

      5. rem-square-sqrt 31.8%

         \[\leadsto \frac{\left|\color{blue}{\sqrt{b - a} \cdot \sqrt{b - a}}\right|}{2} \]

      6. fabs-sqr 31.8%

         \[\leadsto \frac{\color{blue}{\sqrt{b - a} \cdot \sqrt{b - a}}}{2} \]

      7. rem-square-sqrt 32.9%

         \[\leadsto \frac{\color{blue}{b - a}}{2} \]

   7. Simplified 32.9%

      \[\leadsto \frac{\color{blue}{b - a}}{2} \]

   8. Taylor expanded in b around inf 31.7%

      \[\leadsto \frac{\color{blue}{b}}{2} \]
3. Recombined 2 regimes into one program.

4. Final simplification 41.1%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -4.5 \cdot 10^{-111}:\\ \;\;\;\;a \cdot -0.5\\ \mathbf{else}:\\ \;\;\;\;\frac{b}{2}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 50.4% accurate, 35.0× speedup

Math

\[\begin{array}{l} [a, b] = \mathsf{sort}([a, b])\\ \\ a \cdot -0.5 \end{array} \]

FPCore

NOTE: a and b should be sorted in increasing order before calling this function.
(FPCore (a b) :precision binary64 (* a -0.5))

C

assert(a < b);
double code(double a, double b) {
	return a * -0.5;
}

Fortran

NOTE: a and b should be sorted in increasing order before calling this function.
real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = a * (-0.5d0)
end function

Java

assert a < b;
public static double code(double a, double b) {
	return a * -0.5;
}

Python

[a, b] = sort([a, b])
def code(a, b):
	return a * -0.5

Julia

a, b = sort([a, b])
function code(a, b)
	return Float64(a * -0.5)
end

MATLAB

a, b = num2cell(sort([a, b])){:}
function tmp = code(a, b)
	tmp = a * -0.5;
end

Wolfram

NOTE: a and b should be sorted in increasing order before calling this function.
code[a_, b_] := N[(a * -0.5), $MachinePrecision]

Derivation

1. Initial program 100.0%

   \[\frac{\left|a - b\right|}{2} \]
2. Step-by-step derivation

   1. fabs-sub 100.0%

      \[\leadsto \frac{\color{blue}{\left|b - a\right|}}{2} \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{\frac{\left|b - a\right|}{2}} \]
4. Add Preprocessing

5. Taylor expanded in b around -inf 100.0%

   \[\leadsto \frac{\color{blue}{\left|-\left(a + -1 \cdot b\right)\right|}}{2} \]
6. Step-by-step derivation

   1. fabs-neg 100.0%

      \[\leadsto \frac{\color{blue}{\left|a + -1 \cdot b\right|}}{2} \]

   2. mul-1-neg 100.0%

      \[\leadsto \frac{\left|a + \color{blue}{\left(-b\right)}\right|}{2} \]

   3. sub-neg 100.0%

      \[\leadsto \frac{\left|\color{blue}{a - b}\right|}{2} \]

   4. fabs-sub 100.0%

      \[\leadsto \frac{\color{blue}{\left|b - a\right|}}{2} \]

   5. rem-square-sqrt 46.5%

      \[\leadsto \frac{\left|\color{blue}{\sqrt{b - a} \cdot \sqrt{b - a}}\right|}{2} \]

   6. fabs-sqr 46.5%

      \[\leadsto \frac{\color{blue}{\sqrt{b - a} \cdot \sqrt{b - a}}}{2} \]

   7. rem-square-sqrt 47.4%

      \[\leadsto \frac{\color{blue}{b - a}}{2} \]

7. Simplified 47.4%

   \[\leadsto \frac{\color{blue}{b - a}}{2} \]

8. Taylor expanded in b around 0 23.6%

   \[\leadsto \color{blue}{-0.5 \cdot a} \]

9. Final simplification 23.6%

   \[\leadsto a \cdot -0.5 \]
10. Add Preprocessing

Reproduce

herbie shell --seed 2024154 
(FPCore (a b)
  :name "fabs fraction 2"
  :precision binary64
  (/ (fabs (- a b)) 2.0))