fabs fraction 2

Percentage Accurate: 100.0% → 100.0%

Time: 2.9s

Alternatives: 3

Speedup: 1.9×

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, 1.9× speedup

Math

\[\begin{array}{l} [a, b] = \mathsf{sort}([a, b])\\ \\ \left(b - a\right) \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 (* (- b a) 0.5))

C

assert(a < b);
double code(double a, double b) {
	return (b - 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 = (b - a) * 0.5d0
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Taylor expanded in a around 0

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

   1. *-commutative N/A

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

   2. lower-*.f64 N/A

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

   3. *-lft-identity N/A

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

   4. metadata-eval N/A

      \[\leadsto \left|a - \color{blue}{\left(\mathsf{neg}\left(-1\right)\right)} \cdot b\right| \cdot \frac{1}{2} \]

   5. fp-cancel-sign-sub-inv N/A

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

   6. lower-fabs.f64 N/A

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

   7. fp-cancel-sign-sub-inv N/A

      \[\leadsto \left|\color{blue}{a - \left(\mathsf{neg}\left(-1\right)\right) \cdot b}\right| \cdot \frac{1}{2} \]

   8. metadata-eval N/A

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

   9. *-lft-identity N/A

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

   10. lower--.f64 100.0

       \[\leadsto \left|\color{blue}{a - b}\right| \cdot 0.5 \]

5. Applied rewrites 100.0%

   \[\leadsto \color{blue}{\left|a - b\right| \cdot 0.5} \]
6. Step-by-step derivation

7. Applied rewrites 51.4%

   \[\leadsto \left(b - a\right) \cdot \color{blue}{0.5} \]
8. Add Preprocessing

Alternative 2: 81.6% accurate, 1.4× speedup

Math

\[\begin{array}{l} [a, b] = \mathsf{sort}([a, b])\\ \\ \begin{array}{l} \mathbf{if}\;b \leq 2.1 \cdot 10^{-163}:\\ \;\;\;\;-0.5 \cdot a\\ \mathbf{else}:\\ \;\;\;\;0.5 \cdot b\\ \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 (<= b 2.1e-163) (* -0.5 a) (* 0.5 b)))

C

assert(a < b);
double code(double a, double b) {
	double tmp;
	if (b <= 2.1e-163) {
		tmp = -0.5 * a;
	} else {
		tmp = 0.5 * b;
	}
	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 (b <= 2.1d-163) then
        tmp = (-0.5d0) * a
    else
        tmp = 0.5d0 * b
    end if
    code = tmp
end function

Java

assert a < b;
public static double code(double a, double b) {
	double tmp;
	if (b <= 2.1e-163) {
		tmp = -0.5 * a;
	} else {
		tmp = 0.5 * b;
	}
	return tmp;
}

Python

[a, b] = sort([a, b])
def code(a, b):
	tmp = 0
	if b <= 2.1e-163:
		tmp = -0.5 * a
	else:
		tmp = 0.5 * b
	return tmp

Julia

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

MATLAB

a, b = num2cell(sort([a, b])){:}
function tmp_2 = code(a, b)
	tmp = 0.0;
	if (b <= 2.1e-163)
		tmp = -0.5 * a;
	else
		tmp = 0.5 * b;
	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[b, 2.1e-163], N[(-0.5 * a), $MachinePrecision], N[(0.5 * b), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if b < 2.09999999999999998e-163

   1. Initial program 100.0%

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

   3. Taylor expanded in a around 0

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

      1. *-commutative N/A

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

      2. lower-*.f64 N/A

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

      3. *-lft-identity N/A

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

      4. metadata-eval N/A

         \[\leadsto \left|a - \color{blue}{\left(\mathsf{neg}\left(-1\right)\right)} \cdot b\right| \cdot \frac{1}{2} \]

      5. fp-cancel-sign-sub-inv N/A

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

      6. lower-fabs.f64 N/A

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

      7. fp-cancel-sign-sub-inv N/A

         \[\leadsto \left|\color{blue}{a - \left(\mathsf{neg}\left(-1\right)\right) \cdot b}\right| \cdot \frac{1}{2} \]

      8. metadata-eval N/A

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

      9. *-lft-identity N/A

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

      10. lower--.f64 100.0

          \[\leadsto \left|\color{blue}{a - b}\right| \cdot 0.5 \]

   5. Applied rewrites 100.0%

      \[\leadsto \color{blue}{\left|a - b\right| \cdot 0.5} \]
   6. Step-by-step derivation

   7. Applied rewrites 30.8%

      \[\leadsto \left(b - a\right) \cdot \color{blue}{0.5} \]

   8. Taylor expanded in a around inf

      \[\leadsto \frac{-1}{2} \cdot \color{blue}{a} \]
   9. Step-by-step derivation

   10. Applied rewrites 28.0%

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

   if 2.09999999999999998e-163 < b

   1. Initial program 100.0%

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

   3. Taylor expanded in a around 0

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

      1. *-commutative N/A

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

      2. lower-*.f64 N/A

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

      3. *-lft-identity N/A

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

      4. metadata-eval N/A

         \[\leadsto \left|a - \color{blue}{\left(\mathsf{neg}\left(-1\right)\right)} \cdot b\right| \cdot \frac{1}{2} \]

      5. fp-cancel-sign-sub-inv N/A

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

      6. lower-fabs.f64 N/A

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

      7. fp-cancel-sign-sub-inv N/A

         \[\leadsto \left|\color{blue}{a - \left(\mathsf{neg}\left(-1\right)\right) \cdot b}\right| \cdot \frac{1}{2} \]

      8. metadata-eval N/A

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

      9. *-lft-identity N/A

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

      10. lower--.f64 100.0

          \[\leadsto \left|\color{blue}{a - b}\right| \cdot 0.5 \]

   5. Applied rewrites 100.0%

      \[\leadsto \color{blue}{\left|a - b\right| \cdot 0.5} \]
   6. Step-by-step derivation

   7. Applied rewrites 86.4%

      \[\leadsto \left(b - a\right) \cdot \color{blue}{0.5} \]

   8. Taylor expanded in a around 0

      \[\leadsto \frac{1}{2} \cdot \color{blue}{b} \]
   9. Step-by-step derivation

   10. Applied rewrites 72.9%

       \[\leadsto 0.5 \cdot \color{blue}{b} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 50.3% accurate, 2.8× speedup

Math

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

FPCore

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

C

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

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 = (-0.5d0) * a
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

3. Taylor expanded in a around 0

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

   1. *-commutative N/A

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

   2. lower-*.f64 N/A

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

   3. *-lft-identity N/A

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

   4. metadata-eval N/A

      \[\leadsto \left|a - \color{blue}{\left(\mathsf{neg}\left(-1\right)\right)} \cdot b\right| \cdot \frac{1}{2} \]

   5. fp-cancel-sign-sub-inv N/A

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

   6. lower-fabs.f64 N/A

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

   7. fp-cancel-sign-sub-inv N/A

      \[\leadsto \left|\color{blue}{a - \left(\mathsf{neg}\left(-1\right)\right) \cdot b}\right| \cdot \frac{1}{2} \]

   8. metadata-eval N/A

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

   9. *-lft-identity N/A

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

   10. lower--.f64 100.0

       \[\leadsto \left|\color{blue}{a - b}\right| \cdot 0.5 \]

5. Applied rewrites 100.0%

   \[\leadsto \color{blue}{\left|a - b\right| \cdot 0.5} \]
6. Step-by-step derivation

7. Applied rewrites 51.4%

   \[\leadsto \left(b - a\right) \cdot \color{blue}{0.5} \]

8. Taylor expanded in a around inf

   \[\leadsto \frac{-1}{2} \cdot \color{blue}{a} \]
9. Step-by-step derivation

10. Applied rewrites 23.5%

    \[\leadsto -0.5 \cdot \color{blue}{a} \]
11. Add Preprocessing

Reproduce

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