FastMath dist4

Percentage Accurate: 87.5% → 100.0%

Time: 5.2s

Alternatives: 6

Speedup: 1.7×

• 33.0% of points produce a very large (infinite) output. You may want to add a precondition.

Specification

Math

\[\begin{array}{l} \\ \left(\left(d1 \cdot d2 - d1 \cdot d3\right) + d4 \cdot d1\right) - d1 \cdot d1 \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (- (+ (- (* d1 d2) (* d1 d3)) (* d4 d1)) (* d1 d1)))

C

double code(double d1, double d2, double d3, double d4) {
	return (((d1 * d2) - (d1 * d3)) + (d4 * d1)) - (d1 * d1);
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    code = (((d1 * d2) - (d1 * d3)) + (d4 * d1)) - (d1 * d1)
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	return (((d1 * d2) - (d1 * d3)) + (d4 * d1)) - (d1 * d1);
}

Python

def code(d1, d2, d3, d4):
	return (((d1 * d2) - (d1 * d3)) + (d4 * d1)) - (d1 * d1)

Julia

function code(d1, d2, d3, d4)
	return Float64(Float64(Float64(Float64(d1 * d2) - Float64(d1 * d3)) + Float64(d4 * d1)) - Float64(d1 * d1))
end

MATLAB

function tmp = code(d1, d2, d3, d4)
	tmp = (((d1 * d2) - (d1 * d3)) + (d4 * d1)) - (d1 * d1);
end

Wolfram

code[d1_, d2_, d3_, d4_] := N[(N[(N[(N[(d1 * d2), $MachinePrecision] - N[(d1 * d3), $MachinePrecision]), $MachinePrecision] + N[(d4 * d1), $MachinePrecision]), $MachinePrecision] - N[(d1 * d1), $MachinePrecision]), $MachinePrecision]

Initial Program: 87.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(\left(d1 \cdot d2 - d1 \cdot d3\right) + d4 \cdot d1\right) - d1 \cdot d1 \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (- (+ (- (* d1 d2) (* d1 d3)) (* d4 d1)) (* d1 d1)))

C

double code(double d1, double d2, double d3, double d4) {
	return (((d1 * d2) - (d1 * d3)) + (d4 * d1)) - (d1 * d1);
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    code = (((d1 * d2) - (d1 * d3)) + (d4 * d1)) - (d1 * d1)
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	return (((d1 * d2) - (d1 * d3)) + (d4 * d1)) - (d1 * d1);
}

Python

def code(d1, d2, d3, d4):
	return (((d1 * d2) - (d1 * d3)) + (d4 * d1)) - (d1 * d1)

Julia

function code(d1, d2, d3, d4)
	return Float64(Float64(Float64(Float64(d1 * d2) - Float64(d1 * d3)) + Float64(d4 * d1)) - Float64(d1 * d1))
end

MATLAB

function tmp = code(d1, d2, d3, d4)
	tmp = (((d1 * d2) - (d1 * d3)) + (d4 * d1)) - (d1 * d1);
end

Wolfram

code[d1_, d2_, d3_, d4_] := N[(N[(N[(N[(d1 * d2), $MachinePrecision] - N[(d1 * d3), $MachinePrecision]), $MachinePrecision] + N[(d4 * d1), $MachinePrecision]), $MachinePrecision] - N[(d1 * d1), $MachinePrecision]), $MachinePrecision]

Alternative 1: 100.0% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ d1 \cdot \left(\left(d2 - d1\right) + \left(d4 - d3\right)\right) \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4) :precision binary64 (* d1 (+ (- d2 d1) (- d4 d3))))

C

double code(double d1, double d2, double d3, double d4) {
	return d1 * ((d2 - d1) + (d4 - d3));
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    code = d1 * ((d2 - d1) + (d4 - d3))
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	return d1 * ((d2 - d1) + (d4 - d3));
}

Python

def code(d1, d2, d3, d4):
	return d1 * ((d2 - d1) + (d4 - d3))

Julia

function code(d1, d2, d3, d4)
	return Float64(d1 * Float64(Float64(d2 - d1) + Float64(d4 - d3)))
end

MATLAB

function tmp = code(d1, d2, d3, d4)
	tmp = d1 * ((d2 - d1) + (d4 - d3));
end

Wolfram

code[d1_, d2_, d3_, d4_] := N[(d1 * N[(N[(d2 - d1), $MachinePrecision] + N[(d4 - d3), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 87.9%

   \[\left(\left(d1 \cdot d2 - d1 \cdot d3\right) + d4 \cdot d1\right) - d1 \cdot d1 \]
2. Step-by-step derivation

   1. sub-neg 87.9%

      \[\leadsto \left(\color{blue}{\left(d1 \cdot d2 + \left(-d1 \cdot d3\right)\right)} + d4 \cdot d1\right) - d1 \cdot d1 \]

   2. associate-+l+ 87.9%

      \[\leadsto \color{blue}{\left(d1 \cdot d2 + \left(\left(-d1 \cdot d3\right) + d4 \cdot d1\right)\right)} - d1 \cdot d1 \]

   3. *-commutative 87.9%

      \[\leadsto \left(\color{blue}{d2 \cdot d1} + \left(\left(-d1 \cdot d3\right) + d4 \cdot d1\right)\right) - d1 \cdot d1 \]

   4. +-commutative 87.9%

      \[\leadsto \left(d2 \cdot d1 + \color{blue}{\left(d4 \cdot d1 + \left(-d1 \cdot d3\right)\right)}\right) - d1 \cdot d1 \]

   5. *-commutative 87.9%

      \[\leadsto \left(d2 \cdot d1 + \left(\color{blue}{d1 \cdot d4} + \left(-d1 \cdot d3\right)\right)\right) - d1 \cdot d1 \]

   6. sub-neg 87.9%

      \[\leadsto \left(d2 \cdot d1 + \color{blue}{\left(d1 \cdot d4 - d1 \cdot d3\right)}\right) - d1 \cdot d1 \]

   7. +-commutative 87.9%

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d4 - d1 \cdot d3\right) + d2 \cdot d1\right)} - d1 \cdot d1 \]

   8. associate--l+ 87.9%

      \[\leadsto \color{blue}{\left(d1 \cdot d4 - d1 \cdot d3\right) + \left(d2 \cdot d1 - d1 \cdot d1\right)} \]

   9. distribute-lft-out-- 89.8%

      \[\leadsto \color{blue}{d1 \cdot \left(d4 - d3\right)} + \left(d2 \cdot d1 - d1 \cdot d1\right) \]

   10. distribute-rgt-out-- 93.7%

       \[\leadsto d1 \cdot \left(d4 - d3\right) + \color{blue}{d1 \cdot \left(d2 - d1\right)} \]

   11. distribute-lft-out 100.0%

       \[\leadsto \color{blue}{d1 \cdot \left(\left(d4 - d3\right) + \left(d2 - d1\right)\right)} \]

   12. +-commutative 100.0%

       \[\leadsto d1 \cdot \color{blue}{\left(\left(d2 - d1\right) + \left(d4 - d3\right)\right)} \]

   13. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(d4 + \left(-d3\right)\right)}\right) \]

   14. +-commutative 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) + d4\right)}\right) \]

   15. remove-double-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \left(\left(-d3\right) + \color{blue}{\left(-\left(-d4\right)\right)}\right)\right) \]

   16. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) - \left(-d4\right)\right)}\right) \]

   17. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) + \left(-\left(-d4\right)\right)\right)}\right) \]

   18. distribute-neg-in 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(-\left(d3 + \left(-d4\right)\right)\right)}\right) \]

   19. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \left(-\color{blue}{\left(d3 - d4\right)}\right)\right) \]

   20. sub-neg 100.0%

       \[\leadsto d1 \cdot \color{blue}{\left(\left(d2 - d1\right) - \left(d3 - d4\right)\right)} \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{d1 \cdot \left(\left(d2 - d1\right) - \left(d3 - d4\right)\right)} \]
4. Add Preprocessing

5. Final simplification 100.0%

   \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \left(d4 - d3\right)\right) \]
6. Add Preprocessing

Alternative 2: 80.1% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ d1 \cdot \left(\left(d2 + d4\right) - d3\right) \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4) :precision binary64 (* d1 (- (+ d2 d4) d3)))

C

double code(double d1, double d2, double d3, double d4) {
	return d1 * ((d2 + d4) - d3);
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    code = d1 * ((d2 + d4) - d3)
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	return d1 * ((d2 + d4) - d3);
}

Python

def code(d1, d2, d3, d4):
	return d1 * ((d2 + d4) - d3)

Julia

function code(d1, d2, d3, d4)
	return Float64(d1 * Float64(Float64(d2 + d4) - d3))
end

MATLAB

function tmp = code(d1, d2, d3, d4)
	tmp = d1 * ((d2 + d4) - d3);
end

Wolfram

code[d1_, d2_, d3_, d4_] := N[(d1 * N[(N[(d2 + d4), $MachinePrecision] - d3), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 87.9%

   \[\left(\left(d1 \cdot d2 - d1 \cdot d3\right) + d4 \cdot d1\right) - d1 \cdot d1 \]
2. Step-by-step derivation

   1. sub-neg 87.9%

      \[\leadsto \left(\color{blue}{\left(d1 \cdot d2 + \left(-d1 \cdot d3\right)\right)} + d4 \cdot d1\right) - d1 \cdot d1 \]

   2. associate-+l+ 87.9%

      \[\leadsto \color{blue}{\left(d1 \cdot d2 + \left(\left(-d1 \cdot d3\right) + d4 \cdot d1\right)\right)} - d1 \cdot d1 \]

   3. *-commutative 87.9%

      \[\leadsto \left(\color{blue}{d2 \cdot d1} + \left(\left(-d1 \cdot d3\right) + d4 \cdot d1\right)\right) - d1 \cdot d1 \]

   4. +-commutative 87.9%

      \[\leadsto \left(d2 \cdot d1 + \color{blue}{\left(d4 \cdot d1 + \left(-d1 \cdot d3\right)\right)}\right) - d1 \cdot d1 \]

   5. *-commutative 87.9%

      \[\leadsto \left(d2 \cdot d1 + \left(\color{blue}{d1 \cdot d4} + \left(-d1 \cdot d3\right)\right)\right) - d1 \cdot d1 \]

   6. sub-neg 87.9%

      \[\leadsto \left(d2 \cdot d1 + \color{blue}{\left(d1 \cdot d4 - d1 \cdot d3\right)}\right) - d1 \cdot d1 \]

   7. +-commutative 87.9%

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d4 - d1 \cdot d3\right) + d2 \cdot d1\right)} - d1 \cdot d1 \]

   8. associate--l+ 87.9%

      \[\leadsto \color{blue}{\left(d1 \cdot d4 - d1 \cdot d3\right) + \left(d2 \cdot d1 - d1 \cdot d1\right)} \]

   9. distribute-lft-out-- 89.8%

      \[\leadsto \color{blue}{d1 \cdot \left(d4 - d3\right)} + \left(d2 \cdot d1 - d1 \cdot d1\right) \]

   10. distribute-rgt-out-- 93.7%

       \[\leadsto d1 \cdot \left(d4 - d3\right) + \color{blue}{d1 \cdot \left(d2 - d1\right)} \]

   11. distribute-lft-out 100.0%

       \[\leadsto \color{blue}{d1 \cdot \left(\left(d4 - d3\right) + \left(d2 - d1\right)\right)} \]

   12. +-commutative 100.0%

       \[\leadsto d1 \cdot \color{blue}{\left(\left(d2 - d1\right) + \left(d4 - d3\right)\right)} \]

   13. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(d4 + \left(-d3\right)\right)}\right) \]

   14. +-commutative 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) + d4\right)}\right) \]

   15. remove-double-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \left(\left(-d3\right) + \color{blue}{\left(-\left(-d4\right)\right)}\right)\right) \]

   16. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) - \left(-d4\right)\right)}\right) \]

   17. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) + \left(-\left(-d4\right)\right)\right)}\right) \]

   18. distribute-neg-in 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(-\left(d3 + \left(-d4\right)\right)\right)}\right) \]

   19. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \left(-\color{blue}{\left(d3 - d4\right)}\right)\right) \]

   20. sub-neg 100.0%

       \[\leadsto d1 \cdot \color{blue}{\left(\left(d2 - d1\right) - \left(d3 - d4\right)\right)} \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{d1 \cdot \left(\left(d2 - d1\right) - \left(d3 - d4\right)\right)} \]
4. Add Preprocessing

5. Taylor expanded in d1 around 0 80.2%

   \[\leadsto \color{blue}{d1 \cdot \left(\left(d2 + d4\right) - d3\right)} \]

6. Final simplification 80.2%

   \[\leadsto d1 \cdot \left(\left(d2 + d4\right) - d3\right) \]
7. Add Preprocessing

Alternative 3: 55.0% accurate, 3.0× speedup

Math

\[\begin{array}{l} \\ d1 \cdot \left(d2 + d4\right) \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4) :precision binary64 (* d1 (+ d2 d4)))

C

double code(double d1, double d2, double d3, double d4) {
	return d1 * (d2 + d4);
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    code = d1 * (d2 + d4)
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	return d1 * (d2 + d4);
}

Python

def code(d1, d2, d3, d4):
	return d1 * (d2 + d4)

Julia

function code(d1, d2, d3, d4)
	return Float64(d1 * Float64(d2 + d4))
end

MATLAB

function tmp = code(d1, d2, d3, d4)
	tmp = d1 * (d2 + d4);
end

Wolfram

code[d1_, d2_, d3_, d4_] := N[(d1 * N[(d2 + d4), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 87.9%

   \[\left(\left(d1 \cdot d2 - d1 \cdot d3\right) + d4 \cdot d1\right) - d1 \cdot d1 \]
2. Step-by-step derivation

   1. sub-neg 87.9%

      \[\leadsto \left(\color{blue}{\left(d1 \cdot d2 + \left(-d1 \cdot d3\right)\right)} + d4 \cdot d1\right) - d1 \cdot d1 \]

   2. associate-+l+ 87.9%

      \[\leadsto \color{blue}{\left(d1 \cdot d2 + \left(\left(-d1 \cdot d3\right) + d4 \cdot d1\right)\right)} - d1 \cdot d1 \]

   3. *-commutative 87.9%

      \[\leadsto \left(\color{blue}{d2 \cdot d1} + \left(\left(-d1 \cdot d3\right) + d4 \cdot d1\right)\right) - d1 \cdot d1 \]

   4. +-commutative 87.9%

      \[\leadsto \left(d2 \cdot d1 + \color{blue}{\left(d4 \cdot d1 + \left(-d1 \cdot d3\right)\right)}\right) - d1 \cdot d1 \]

   5. *-commutative 87.9%

      \[\leadsto \left(d2 \cdot d1 + \left(\color{blue}{d1 \cdot d4} + \left(-d1 \cdot d3\right)\right)\right) - d1 \cdot d1 \]

   6. sub-neg 87.9%

      \[\leadsto \left(d2 \cdot d1 + \color{blue}{\left(d1 \cdot d4 - d1 \cdot d3\right)}\right) - d1 \cdot d1 \]

   7. +-commutative 87.9%

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d4 - d1 \cdot d3\right) + d2 \cdot d1\right)} - d1 \cdot d1 \]

   8. associate--l+ 87.9%

      \[\leadsto \color{blue}{\left(d1 \cdot d4 - d1 \cdot d3\right) + \left(d2 \cdot d1 - d1 \cdot d1\right)} \]

   9. distribute-lft-out-- 89.8%

      \[\leadsto \color{blue}{d1 \cdot \left(d4 - d3\right)} + \left(d2 \cdot d1 - d1 \cdot d1\right) \]

   10. distribute-rgt-out-- 93.7%

       \[\leadsto d1 \cdot \left(d4 - d3\right) + \color{blue}{d1 \cdot \left(d2 - d1\right)} \]

   11. distribute-lft-out 100.0%

       \[\leadsto \color{blue}{d1 \cdot \left(\left(d4 - d3\right) + \left(d2 - d1\right)\right)} \]

   12. +-commutative 100.0%

       \[\leadsto d1 \cdot \color{blue}{\left(\left(d2 - d1\right) + \left(d4 - d3\right)\right)} \]

   13. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(d4 + \left(-d3\right)\right)}\right) \]

   14. +-commutative 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) + d4\right)}\right) \]

   15. remove-double-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \left(\left(-d3\right) + \color{blue}{\left(-\left(-d4\right)\right)}\right)\right) \]

   16. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) - \left(-d4\right)\right)}\right) \]

   17. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) + \left(-\left(-d4\right)\right)\right)}\right) \]

   18. distribute-neg-in 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(-\left(d3 + \left(-d4\right)\right)\right)}\right) \]

   19. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \left(-\color{blue}{\left(d3 - d4\right)}\right)\right) \]

   20. sub-neg 100.0%

       \[\leadsto d1 \cdot \color{blue}{\left(\left(d2 - d1\right) - \left(d3 - d4\right)\right)} \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{d1 \cdot \left(\left(d2 - d1\right) - \left(d3 - d4\right)\right)} \]
4. Add Preprocessing

5. Taylor expanded in d1 around 0 80.2%

   \[\leadsto \color{blue}{d1 \cdot \left(\left(d2 + d4\right) - d3\right)} \]

6. Taylor expanded in d3 around 0 58.6%

   \[\leadsto \color{blue}{d1 \cdot \left(d2 + d4\right)} \]

7. Final simplification 58.6%

   \[\leadsto d1 \cdot \left(d2 + d4\right) \]
8. Add Preprocessing

Alternative 4: 56.2% accurate, 3.0× speedup

Math

\[\begin{array}{l} \\ d1 \cdot \left(d4 - d3\right) \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4) :precision binary64 (* d1 (- d4 d3)))

C

double code(double d1, double d2, double d3, double d4) {
	return d1 * (d4 - d3);
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    code = d1 * (d4 - d3)
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	return d1 * (d4 - d3);
}

Python

def code(d1, d2, d3, d4):
	return d1 * (d4 - d3)

Julia

function code(d1, d2, d3, d4)
	return Float64(d1 * Float64(d4 - d3))
end

MATLAB

function tmp = code(d1, d2, d3, d4)
	tmp = d1 * (d4 - d3);
end

Wolfram

code[d1_, d2_, d3_, d4_] := N[(d1 * N[(d4 - d3), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 87.9%

   \[\left(\left(d1 \cdot d2 - d1 \cdot d3\right) + d4 \cdot d1\right) - d1 \cdot d1 \]
2. Step-by-step derivation

   1. sub-neg 87.9%

      \[\leadsto \left(\color{blue}{\left(d1 \cdot d2 + \left(-d1 \cdot d3\right)\right)} + d4 \cdot d1\right) - d1 \cdot d1 \]

   2. associate-+l+ 87.9%

      \[\leadsto \color{blue}{\left(d1 \cdot d2 + \left(\left(-d1 \cdot d3\right) + d4 \cdot d1\right)\right)} - d1 \cdot d1 \]

   3. *-commutative 87.9%

      \[\leadsto \left(\color{blue}{d2 \cdot d1} + \left(\left(-d1 \cdot d3\right) + d4 \cdot d1\right)\right) - d1 \cdot d1 \]

   4. +-commutative 87.9%

      \[\leadsto \left(d2 \cdot d1 + \color{blue}{\left(d4 \cdot d1 + \left(-d1 \cdot d3\right)\right)}\right) - d1 \cdot d1 \]

   5. *-commutative 87.9%

      \[\leadsto \left(d2 \cdot d1 + \left(\color{blue}{d1 \cdot d4} + \left(-d1 \cdot d3\right)\right)\right) - d1 \cdot d1 \]

   6. sub-neg 87.9%

      \[\leadsto \left(d2 \cdot d1 + \color{blue}{\left(d1 \cdot d4 - d1 \cdot d3\right)}\right) - d1 \cdot d1 \]

   7. +-commutative 87.9%

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d4 - d1 \cdot d3\right) + d2 \cdot d1\right)} - d1 \cdot d1 \]

   8. associate--l+ 87.9%

      \[\leadsto \color{blue}{\left(d1 \cdot d4 - d1 \cdot d3\right) + \left(d2 \cdot d1 - d1 \cdot d1\right)} \]

   9. distribute-lft-out-- 89.8%

      \[\leadsto \color{blue}{d1 \cdot \left(d4 - d3\right)} + \left(d2 \cdot d1 - d1 \cdot d1\right) \]

   10. distribute-rgt-out-- 93.7%

       \[\leadsto d1 \cdot \left(d4 - d3\right) + \color{blue}{d1 \cdot \left(d2 - d1\right)} \]

   11. distribute-lft-out 100.0%

       \[\leadsto \color{blue}{d1 \cdot \left(\left(d4 - d3\right) + \left(d2 - d1\right)\right)} \]

   12. +-commutative 100.0%

       \[\leadsto d1 \cdot \color{blue}{\left(\left(d2 - d1\right) + \left(d4 - d3\right)\right)} \]

   13. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(d4 + \left(-d3\right)\right)}\right) \]

   14. +-commutative 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) + d4\right)}\right) \]

   15. remove-double-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \left(\left(-d3\right) + \color{blue}{\left(-\left(-d4\right)\right)}\right)\right) \]

   16. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) - \left(-d4\right)\right)}\right) \]

   17. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) + \left(-\left(-d4\right)\right)\right)}\right) \]

   18. distribute-neg-in 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(-\left(d3 + \left(-d4\right)\right)\right)}\right) \]

   19. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \left(-\color{blue}{\left(d3 - d4\right)}\right)\right) \]

   20. sub-neg 100.0%

       \[\leadsto d1 \cdot \color{blue}{\left(\left(d2 - d1\right) - \left(d3 - d4\right)\right)} \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{d1 \cdot \left(\left(d2 - d1\right) - \left(d3 - d4\right)\right)} \]
4. Add Preprocessing

5. Taylor expanded in d1 around 0 80.2%

   \[\leadsto \color{blue}{d1 \cdot \left(\left(d2 + d4\right) - d3\right)} \]

6. Taylor expanded in d2 around 0 52.1%

   \[\leadsto \color{blue}{d1 \cdot \left(d4 - d3\right)} \]

7. Final simplification 52.1%

   \[\leadsto d1 \cdot \left(d4 - d3\right) \]
8. Add Preprocessing

Alternative 5: 30.7% accurate, 5.0× speedup

Math

\[\begin{array}{l} \\ d1 \cdot d2 \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4) :precision binary64 (* d1 d2))

C

double code(double d1, double d2, double d3, double d4) {
	return d1 * d2;
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    code = d1 * d2
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	return d1 * d2;
}

Python

def code(d1, d2, d3, d4):
	return d1 * d2

Julia

function code(d1, d2, d3, d4)
	return Float64(d1 * d2)
end

MATLAB

function tmp = code(d1, d2, d3, d4)
	tmp = d1 * d2;
end

Wolfram

code[d1_, d2_, d3_, d4_] := N[(d1 * d2), $MachinePrecision]

Derivation

1. Initial program 87.9%

   \[\left(\left(d1 \cdot d2 - d1 \cdot d3\right) + d4 \cdot d1\right) - d1 \cdot d1 \]
2. Step-by-step derivation

   1. sub-neg 87.9%

      \[\leadsto \left(\color{blue}{\left(d1 \cdot d2 + \left(-d1 \cdot d3\right)\right)} + d4 \cdot d1\right) - d1 \cdot d1 \]

   2. associate-+l+ 87.9%

      \[\leadsto \color{blue}{\left(d1 \cdot d2 + \left(\left(-d1 \cdot d3\right) + d4 \cdot d1\right)\right)} - d1 \cdot d1 \]

   3. *-commutative 87.9%

      \[\leadsto \left(\color{blue}{d2 \cdot d1} + \left(\left(-d1 \cdot d3\right) + d4 \cdot d1\right)\right) - d1 \cdot d1 \]

   4. +-commutative 87.9%

      \[\leadsto \left(d2 \cdot d1 + \color{blue}{\left(d4 \cdot d1 + \left(-d1 \cdot d3\right)\right)}\right) - d1 \cdot d1 \]

   5. *-commutative 87.9%

      \[\leadsto \left(d2 \cdot d1 + \left(\color{blue}{d1 \cdot d4} + \left(-d1 \cdot d3\right)\right)\right) - d1 \cdot d1 \]

   6. sub-neg 87.9%

      \[\leadsto \left(d2 \cdot d1 + \color{blue}{\left(d1 \cdot d4 - d1 \cdot d3\right)}\right) - d1 \cdot d1 \]

   7. +-commutative 87.9%

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d4 - d1 \cdot d3\right) + d2 \cdot d1\right)} - d1 \cdot d1 \]

   8. associate--l+ 87.9%

      \[\leadsto \color{blue}{\left(d1 \cdot d4 - d1 \cdot d3\right) + \left(d2 \cdot d1 - d1 \cdot d1\right)} \]

   9. distribute-lft-out-- 89.8%

      \[\leadsto \color{blue}{d1 \cdot \left(d4 - d3\right)} + \left(d2 \cdot d1 - d1 \cdot d1\right) \]

   10. distribute-rgt-out-- 93.7%

       \[\leadsto d1 \cdot \left(d4 - d3\right) + \color{blue}{d1 \cdot \left(d2 - d1\right)} \]

   11. distribute-lft-out 100.0%

       \[\leadsto \color{blue}{d1 \cdot \left(\left(d4 - d3\right) + \left(d2 - d1\right)\right)} \]

   12. +-commutative 100.0%

       \[\leadsto d1 \cdot \color{blue}{\left(\left(d2 - d1\right) + \left(d4 - d3\right)\right)} \]

   13. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(d4 + \left(-d3\right)\right)}\right) \]

   14. +-commutative 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) + d4\right)}\right) \]

   15. remove-double-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \left(\left(-d3\right) + \color{blue}{\left(-\left(-d4\right)\right)}\right)\right) \]

   16. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) - \left(-d4\right)\right)}\right) \]

   17. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) + \left(-\left(-d4\right)\right)\right)}\right) \]

   18. distribute-neg-in 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(-\left(d3 + \left(-d4\right)\right)\right)}\right) \]

   19. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \left(-\color{blue}{\left(d3 - d4\right)}\right)\right) \]

   20. sub-neg 100.0%

       \[\leadsto d1 \cdot \color{blue}{\left(\left(d2 - d1\right) - \left(d3 - d4\right)\right)} \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{d1 \cdot \left(\left(d2 - d1\right) - \left(d3 - d4\right)\right)} \]
4. Add Preprocessing

5. Taylor expanded in d2 around inf 33.8%

   \[\leadsto \color{blue}{d1 \cdot d2} \]

6. Final simplification 33.8%

   \[\leadsto d1 \cdot d2 \]
7. Add Preprocessing

Alternative 6: 30.2% accurate, 5.0× speedup

Math

\[\begin{array}{l} \\ d1 \cdot d4 \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4) :precision binary64 (* d1 d4))

C

double code(double d1, double d2, double d3, double d4) {
	return d1 * d4;
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    code = d1 * d4
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	return d1 * d4;
}

Python

def code(d1, d2, d3, d4):
	return d1 * d4

Julia

function code(d1, d2, d3, d4)
	return Float64(d1 * d4)
end

MATLAB

function tmp = code(d1, d2, d3, d4)
	tmp = d1 * d4;
end

Wolfram

code[d1_, d2_, d3_, d4_] := N[(d1 * d4), $MachinePrecision]

Derivation

1. Initial program 87.9%

   \[\left(\left(d1 \cdot d2 - d1 \cdot d3\right) + d4 \cdot d1\right) - d1 \cdot d1 \]
2. Step-by-step derivation

   1. sub-neg 87.9%

      \[\leadsto \left(\color{blue}{\left(d1 \cdot d2 + \left(-d1 \cdot d3\right)\right)} + d4 \cdot d1\right) - d1 \cdot d1 \]

   2. associate-+l+ 87.9%

      \[\leadsto \color{blue}{\left(d1 \cdot d2 + \left(\left(-d1 \cdot d3\right) + d4 \cdot d1\right)\right)} - d1 \cdot d1 \]

   3. *-commutative 87.9%

      \[\leadsto \left(\color{blue}{d2 \cdot d1} + \left(\left(-d1 \cdot d3\right) + d4 \cdot d1\right)\right) - d1 \cdot d1 \]

   4. +-commutative 87.9%

      \[\leadsto \left(d2 \cdot d1 + \color{blue}{\left(d4 \cdot d1 + \left(-d1 \cdot d3\right)\right)}\right) - d1 \cdot d1 \]

   5. *-commutative 87.9%

      \[\leadsto \left(d2 \cdot d1 + \left(\color{blue}{d1 \cdot d4} + \left(-d1 \cdot d3\right)\right)\right) - d1 \cdot d1 \]

   6. sub-neg 87.9%

      \[\leadsto \left(d2 \cdot d1 + \color{blue}{\left(d1 \cdot d4 - d1 \cdot d3\right)}\right) - d1 \cdot d1 \]

   7. +-commutative 87.9%

      \[\leadsto \color{blue}{\left(\left(d1 \cdot d4 - d1 \cdot d3\right) + d2 \cdot d1\right)} - d1 \cdot d1 \]

   8. associate--l+ 87.9%

      \[\leadsto \color{blue}{\left(d1 \cdot d4 - d1 \cdot d3\right) + \left(d2 \cdot d1 - d1 \cdot d1\right)} \]

   9. distribute-lft-out-- 89.8%

      \[\leadsto \color{blue}{d1 \cdot \left(d4 - d3\right)} + \left(d2 \cdot d1 - d1 \cdot d1\right) \]

   10. distribute-rgt-out-- 93.7%

       \[\leadsto d1 \cdot \left(d4 - d3\right) + \color{blue}{d1 \cdot \left(d2 - d1\right)} \]

   11. distribute-lft-out 100.0%

       \[\leadsto \color{blue}{d1 \cdot \left(\left(d4 - d3\right) + \left(d2 - d1\right)\right)} \]

   12. +-commutative 100.0%

       \[\leadsto d1 \cdot \color{blue}{\left(\left(d2 - d1\right) + \left(d4 - d3\right)\right)} \]

   13. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(d4 + \left(-d3\right)\right)}\right) \]

   14. +-commutative 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) + d4\right)}\right) \]

   15. remove-double-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \left(\left(-d3\right) + \color{blue}{\left(-\left(-d4\right)\right)}\right)\right) \]

   16. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) - \left(-d4\right)\right)}\right) \]

   17. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(\left(-d3\right) + \left(-\left(-d4\right)\right)\right)}\right) \]

   18. distribute-neg-in 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \color{blue}{\left(-\left(d3 + \left(-d4\right)\right)\right)}\right) \]

   19. sub-neg 100.0%

       \[\leadsto d1 \cdot \left(\left(d2 - d1\right) + \left(-\color{blue}{\left(d3 - d4\right)}\right)\right) \]

   20. sub-neg 100.0%

       \[\leadsto d1 \cdot \color{blue}{\left(\left(d2 - d1\right) - \left(d3 - d4\right)\right)} \]

3. Simplified 100.0%

   \[\leadsto \color{blue}{d1 \cdot \left(\left(d2 - d1\right) - \left(d3 - d4\right)\right)} \]
4. Add Preprocessing

5. Taylor expanded in d4 around inf 30.2%

   \[\leadsto \color{blue}{d1 \cdot d4} \]

6. Final simplification 30.2%

   \[\leadsto d1 \cdot d4 \]
7. Add Preprocessing

Developer target: 100.0% accurate, 1.7× speedup

Math

\[\begin{array}{l} \\ d1 \cdot \left(\left(\left(d2 - d3\right) + d4\right) - d1\right) \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4) :precision binary64 (* d1 (- (+ (- d2 d3) d4) d1)))

C

double code(double d1, double d2, double d3, double d4) {
	return d1 * (((d2 - d3) + d4) - d1);
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    code = d1 * (((d2 - d3) + d4) - d1)
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	return d1 * (((d2 - d3) + d4) - d1);
}

Python

def code(d1, d2, d3, d4):
	return d1 * (((d2 - d3) + d4) - d1)

Julia

function code(d1, d2, d3, d4)
	return Float64(d1 * Float64(Float64(Float64(d2 - d3) + d4) - d1))
end

MATLAB

function tmp = code(d1, d2, d3, d4)
	tmp = d1 * (((d2 - d3) + d4) - d1);
end

Wolfram

code[d1_, d2_, d3_, d4_] := N[(d1 * N[(N[(N[(d2 - d3), $MachinePrecision] + d4), $MachinePrecision] - d1), $MachinePrecision]), $MachinePrecision]

Reproduce

herbie shell --seed 2024033 
(FPCore (d1 d2 d3 d4)
  :name "FastMath dist4"
  :precision binary64

  :herbie-target
  (* d1 (- (+ (- d2 d3) d4) d1))

  (- (+ (- (* d1 d2) (* d1 d3)) (* d4 d1)) (* d1 d1)))