fabs fraction 2

Percentage Accurate: 100.0% → 100.0%

Time: 2.7s

Alternatives: 3

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} \\ \left|a - b\right| \cdot 0.5 \end{array} \]

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

   1. *-rgt-identity N/A

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

   2. metadata-eval N/A

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

   3. lift-/.f64 N/A

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

   4. associate-*l/ N/A

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

   5. associate-/l* N/A

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

   6. *-commutative N/A

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

   7. lower-*.f64 N/A

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

   8. metadata-eval N/A

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

   9. metadata-eval 100.0

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

   10. lift-fabs.f64 N/A

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

   11. lift--.f64 N/A

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

   12. fabs-sub N/A

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

   13. lower-fabs.f64 N/A

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

   14. lower--.f64 100.0

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

3. Applied rewrites 100.0%

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

5. Final simplification 100.0%

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

Alternative 2: 62.2% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;a \leq -1.3 \cdot 10^{-57}:\\ \;\;\;\;\left|a\right| \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\left|b\right| \cdot 0.5\\ \end{array} \end{array} \]

FPCore

(FPCore (a b)
 :precision binary64
 (if (<= a -1.3e-57) (* (fabs a) 0.5) (* (fabs b) 0.5)))

C

double code(double a, double b) {
	double tmp;
	if (a <= -1.3e-57) {
		tmp = fabs(a) * 0.5;
	} else {
		tmp = fabs(b) * 0.5;
	}
	return tmp;
}

Fortran

real(8) function code(a, b)
    real(8), intent (in) :: a
    real(8), intent (in) :: b
    real(8) :: tmp
    if (a <= (-1.3d-57)) then
        tmp = abs(a) * 0.5d0
    else
        tmp = abs(b) * 0.5d0
    end if
    code = tmp
end function

Java

public static double code(double a, double b) {
	double tmp;
	if (a <= -1.3e-57) {
		tmp = Math.abs(a) * 0.5;
	} else {
		tmp = Math.abs(b) * 0.5;
	}
	return tmp;
}

Python

def code(a, b):
	tmp = 0
	if a <= -1.3e-57:
		tmp = math.fabs(a) * 0.5
	else:
		tmp = math.fabs(b) * 0.5
	return tmp

Julia

function code(a, b)
	tmp = 0.0
	if (a <= -1.3e-57)
		tmp = Float64(abs(a) * 0.5);
	else
		tmp = Float64(abs(b) * 0.5);
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, b)
	tmp = 0.0;
	if (a <= -1.3e-57)
		tmp = abs(a) * 0.5;
	else
		tmp = abs(b) * 0.5;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, b_] := If[LessEqual[a, -1.3e-57], N[(N[Abs[a], $MachinePrecision] * 0.5), $MachinePrecision], N[(N[Abs[b], $MachinePrecision] * 0.5), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if a < -1.29999999999999993e-57

   1. Initial program 100.0%

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

      1. *-rgt-identity N/A

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

      2. metadata-eval N/A

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

      3. lift-/.f64 N/A

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

      4. associate-*l/ N/A

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

      5. associate-/l* N/A

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

      6. *-commutative N/A

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

      7. lower-*.f64 N/A

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

      8. metadata-eval N/A

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

      9. metadata-eval 100.0

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

      10. lift-fabs.f64 N/A

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

      11. lift--.f64 N/A

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

      12. fabs-sub N/A

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

      13. lower-fabs.f64 N/A

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

      14. lower--.f64 100.0

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

   3. Applied rewrites 100.0%

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

   5. Taylor expanded in b around 0

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

      1. mul-1-neg N/A

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

      2. lower-neg.f64 76.8

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

   7. Applied rewrites 76.8%

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

      1. lift-*.f64 N/A

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

      2. *-commutative N/A

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

      3. lower-*.f64 76.8

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

   9. Applied rewrites 76.8%

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

   if -1.29999999999999993e-57 < a

   1. Initial program 100.0%

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

      1. *-rgt-identity N/A

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

      2. metadata-eval N/A

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

      3. lift-/.f64 N/A

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

      4. associate-*l/ N/A

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

      5. associate-/l* N/A

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

      6. *-commutative N/A

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

      7. lower-*.f64 N/A

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

      8. metadata-eval N/A

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

      9. metadata-eval 100.0

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

      10. lift-fabs.f64 N/A

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

      11. lift--.f64 N/A

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

      12. fabs-sub N/A

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

      13. lower-fabs.f64 N/A

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

      14. lower--.f64 100.0

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

   3. Applied rewrites 100.0%

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

   5. Taylor expanded in b around inf

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

   7. Applied rewrites 60.7%

      \[\leadsto 0.5 \cdot \left|\color{blue}{b}\right| \]
3. Recombined 2 regimes into one program.

4. Final simplification 65.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;a \leq -1.3 \cdot 10^{-57}:\\ \;\;\;\;\left|a\right| \cdot 0.5\\ \mathbf{else}:\\ \;\;\;\;\left|b\right| \cdot 0.5\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 51.3% accurate, 2.1× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 100.0%

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

   1. *-rgt-identity N/A

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

   2. metadata-eval N/A

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

   3. lift-/.f64 N/A

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

   4. associate-*l/ N/A

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

   5. associate-/l* N/A

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

   6. *-commutative N/A

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

   7. lower-*.f64 N/A

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

   8. metadata-eval N/A

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

   9. metadata-eval 100.0

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

   10. lift-fabs.f64 N/A

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

   11. lift--.f64 N/A

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

   12. fabs-sub N/A

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

   13. lower-fabs.f64 N/A

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

   14. lower--.f64 100.0

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

3. Applied rewrites 100.0%

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

5. Taylor expanded in b around inf

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

7. Applied rewrites 50.3%

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

8. Final simplification 50.3%

   \[\leadsto \left|b\right| \cdot 0.5 \]
9. Add Preprocessing

Reproduce

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