fabs fraction 2

Percentage Accurate: 100.0% → 100.0%

Time: 3.3s

Alternatives: 2

Speedup: 1.5×

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.5× speedup

Math

\[\begin{array}{l} \\ 0.5 \cdot \left|a - b\right| \end{array} \]

FPCore

(FPCore (a b) :precision binary64 (* 0.5 (fabs (- a b))))

C

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

Fortran

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

Java

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

Python

def code(a, b):
	return 0.5 * math.fabs((a - b))

Julia

function code(a, b)
	return Float64(0.5 * abs(Float64(a - b)))
end

MATLAB

function tmp = code(a, b)
	tmp = 0.5 * abs((a - b));
end

Wolfram

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

Derivation

1. Initial program 100.0%

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

   1. lift-/.f64 N/A

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

   2. div-inv N/A

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

   3. lower-*.f64 N/A

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

   4. lift-fabs.f64 N/A

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

   5. neg-fabs N/A

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

   6. lower-fabs.f64 N/A

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

   7. lift--.f64 N/A

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

   8. sub-neg N/A

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

   9. +-commutative N/A

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

   10. distribute-neg-in N/A

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

   11. remove-double-neg N/A

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

   12. sub-neg N/A

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

   13. lower--.f64 N/A

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

   14. metadata-eval 100.0

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

4. Applied rewrites 100.0%

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

5. Final simplification 100.0%

   \[\leadsto 0.5 \cdot \left|a - b\right| \]
6. Add Preprocessing

Alternative 2: 51.3% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \left|a\right| \cdot 0.5 \end{array} \]

FPCore

(FPCore (a b) :precision binary64 (* (fabs a) 0.5))

C

double code(double a, double b) {
	return fabs(a) * 0.5;
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    code = abs(a) * 0.5d0
end function

Java

public static double code(double a, double b) {
	return Math.abs(a) * 0.5;
}

Python

def code(a, b):
	return math.fabs(a) * 0.5

Julia

function code(a, b)
	return Float64(abs(a) * 0.5)
end

MATLAB

function tmp = code(a, b)
	tmp = abs(a) * 0.5;
end

Wolfram

code[a_, b_] := N[(N[Abs[a], $MachinePrecision] * 0.5), $MachinePrecision]

Derivation

1. Initial program 100.0%

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

   1. lift-/.f64 N/A

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

   2. div-inv N/A

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

   3. lower-*.f64 N/A

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

   4. lift-fabs.f64 N/A

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

   5. neg-fabs N/A

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

   6. lower-fabs.f64 N/A

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

   7. lift--.f64 N/A

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

   8. sub-neg N/A

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

   9. +-commutative N/A

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

   10. distribute-neg-in N/A

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

   11. remove-double-neg N/A

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

   12. sub-neg N/A

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

   13. lower--.f64 N/A

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

   14. metadata-eval 100.0

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

4. Applied rewrites 100.0%

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

5. Taylor expanded in b around 0

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

   1. mul-1-neg N/A

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

   2. lower-neg.f64 49.4

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

7. Applied rewrites 49.4%

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

9. Applied rewrites 49.4%

   \[\leadsto \color{blue}{\left|a\right| \cdot 0.5} \]
10. Add Preprocessing

Reproduce

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