FastMath dist4

Percentage Accurate: 87.7% → 100.0%

Time: 6.2s

Alternatives: 12

Speedup: 1.7×

• 32.5% 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.7% 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(d4 + \left(d2 - d3\right)\right) - d1\right) \end{array} \]

FPCore

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

C

double code(double d1, double d2, double d3, double d4) {
	return d1 * ((d4 + (d2 - d3)) - 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 * ((d4 + (d2 - d3)) - d1)
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 89.8%

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

   1. +-commutative 89.8%

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

   2. *-commutative 89.8%

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

   3. distribute-lft-out-- 90.6%

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

   4. distribute-lft-out 91.4%

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

   5. distribute-lft-out-- 100.0%

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

3. Simplified 100.0%

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

Alternative 2: 38.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d4 \leq 2.4 \cdot 10^{-123}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{elif}\;d4 \leq 5.6 \cdot 10^{+39}:\\ \;\;\;\;d1 \cdot \left(-d1\right)\\ \mathbf{elif}\;d4 \leq 9.2 \cdot 10^{+83}:\\ \;\;\;\;d1 \cdot \left(-d3\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot d4\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d4 2.4e-123)
   (* d1 d2)
   (if (<= d4 5.6e+39)
     (* d1 (- d1))
     (if (<= d4 9.2e+83) (* d1 (- d3)) (* d1 d4)))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 2.4e-123) {
		tmp = d1 * d2;
	} else if (d4 <= 5.6e+39) {
		tmp = d1 * -d1;
	} else if (d4 <= 9.2e+83) {
		tmp = d1 * -d3;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

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
    real(8) :: tmp
    if (d4 <= 2.4d-123) then
        tmp = d1 * d2
    else if (d4 <= 5.6d+39) then
        tmp = d1 * -d1
    else if (d4 <= 9.2d+83) then
        tmp = d1 * -d3
    else
        tmp = d1 * d4
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 2.4e-123) {
		tmp = d1 * d2;
	} else if (d4 <= 5.6e+39) {
		tmp = d1 * -d1;
	} else if (d4 <= 9.2e+83) {
		tmp = d1 * -d3;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d4 <= 2.4e-123:
		tmp = d1 * d2
	elif d4 <= 5.6e+39:
		tmp = d1 * -d1
	elif d4 <= 9.2e+83:
		tmp = d1 * -d3
	else:
		tmp = d1 * d4
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= 2.4e-123)
		tmp = Float64(d1 * d2);
	elseif (d4 <= 5.6e+39)
		tmp = Float64(d1 * Float64(-d1));
	elseif (d4 <= 9.2e+83)
		tmp = Float64(d1 * Float64(-d3));
	else
		tmp = Float64(d1 * d4);
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d4 <= 2.4e-123)
		tmp = d1 * d2;
	elseif (d4 <= 5.6e+39)
		tmp = d1 * -d1;
	elseif (d4 <= 9.2e+83)
		tmp = d1 * -d3;
	else
		tmp = d1 * d4;
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := If[LessEqual[d4, 2.4e-123], N[(d1 * d2), $MachinePrecision], If[LessEqual[d4, 5.6e+39], N[(d1 * (-d1)), $MachinePrecision], If[LessEqual[d4, 9.2e+83], N[(d1 * (-d3)), $MachinePrecision], N[(d1 * d4), $MachinePrecision]]]]

Derivation

1. Split input into 4 regimes

2. if d4 < 2.4e-123

   1. Initial program 90.3%

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

      1. +-commutative 90.3%

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

      2. *-commutative 90.3%

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

      3. distribute-lft-out-- 90.9%

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

      4. distribute-lft-out 90.9%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around inf 39.9%

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

   if 2.4e-123 < d4 < 5.60000000000000003e39

   1. Initial program 90.6%

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

      1. +-commutative 90.6%

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

      2. *-commutative 90.6%

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

      3. distribute-lft-out-- 90.6%

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

      4. distribute-lft-out 90.6%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around inf 50.6%

      \[\leadsto d1 \cdot \color{blue}{\left(-1 \cdot d1\right)} \]
   6. Step-by-step derivation

      1. neg-mul-1 50.6%

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

   7. Simplified 50.6%

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

   if 5.60000000000000003e39 < d4 < 9.1999999999999998e83

   1. Initial program 89.8%

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

      1. +-commutative 89.8%

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

      2. *-commutative 89.8%

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

      3. distribute-lft-out-- 100.0%

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

      4. distribute-lft-out 100.0%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around inf 34.3%

      \[\leadsto \color{blue}{-1 \cdot \left(d1 \cdot d3\right)} \]
   6. Step-by-step derivation

      1. mul-1-neg 34.3%

         \[\leadsto \color{blue}{-d1 \cdot d3} \]

      2. distribute-rgt-neg-out 34.3%

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

   7. Simplified 34.3%

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

   if 9.1999999999999998e83 < d4

   1. Initial program 88.3%

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

      1. +-commutative 88.3%

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

      2. *-commutative 88.3%

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

      3. distribute-lft-out-- 88.3%

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

      4. distribute-lft-out 91.7%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d4 around inf 78.1%

      \[\leadsto \color{blue}{d1 \cdot d4} \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 3: 89.3% accurate, 0.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d1 \leq -1.25 \cdot 10^{+159} \lor \neg \left(d1 \leq 2.1 \cdot 10^{+155}\right):\\ \;\;\;\;d1 \cdot \left(\left(-d1\right) - d3\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(\left(d4 + d2\right) - d3\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (or (<= d1 -1.25e+159) (not (<= d1 2.1e+155)))
   (* d1 (- (- d1) d3))
   (* d1 (- (+ d4 d2) d3))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if ((d1 <= -1.25e+159) || !(d1 <= 2.1e+155)) {
		tmp = d1 * (-d1 - d3);
	} else {
		tmp = d1 * ((d4 + d2) - d3);
	}
	return tmp;
}

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
    real(8) :: tmp
    if ((d1 <= (-1.25d+159)) .or. (.not. (d1 <= 2.1d+155))) then
        tmp = d1 * (-d1 - d3)
    else
        tmp = d1 * ((d4 + d2) - d3)
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if ((d1 <= -1.25e+159) || !(d1 <= 2.1e+155)) {
		tmp = d1 * (-d1 - d3);
	} else {
		tmp = d1 * ((d4 + d2) - d3);
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if (d1 <= -1.25e+159) or not (d1 <= 2.1e+155):
		tmp = d1 * (-d1 - d3)
	else:
		tmp = d1 * ((d4 + d2) - d3)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if ((d1 <= -1.25e+159) || !(d1 <= 2.1e+155))
		tmp = Float64(d1 * Float64(Float64(-d1) - d3));
	else
		tmp = Float64(d1 * Float64(Float64(d4 + d2) - d3));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if ((d1 <= -1.25e+159) || ~((d1 <= 2.1e+155)))
		tmp = d1 * (-d1 - d3);
	else
		tmp = d1 * ((d4 + d2) - d3);
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := If[Or[LessEqual[d1, -1.25e+159], N[Not[LessEqual[d1, 2.1e+155]], $MachinePrecision]], N[(d1 * N[((-d1) - d3), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(N[(d4 + d2), $MachinePrecision] - d3), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d1 < -1.25000000000000001e159 or 2.1e155 < d1

   1. Initial program 62.5%

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

      1. +-commutative 62.5%

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

      2. *-commutative 62.5%

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

      3. distribute-lft-out-- 66.1%

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

      4. distribute-lft-out 67.9%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d4 around 0 100.0%

      \[\leadsto \color{blue}{d1 \cdot \left(d2 - \left(d1 + d3\right)\right)} \]
   6. Step-by-step derivation

      1. +-commutative 100.0%

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

      2. associate--r+ 100.0%

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

   7. Simplified 100.0%

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

   8. Taylor expanded in d2 around 0 100.0%

      \[\leadsto \color{blue}{-1 \cdot \left(d1 \cdot \left(d1 + d3\right)\right)} \]
   9. Step-by-step derivation

      1. associate-*r* 100.0%

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

      2. mul-1-neg 100.0%

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

   10. Simplified 100.0%

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

   if -1.25000000000000001e159 < d1 < 2.1e155

   1. Initial program 97.5%

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

      1. +-commutative 97.5%

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

      2. *-commutative 97.5%

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

      3. distribute-lft-out-- 97.5%

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

      4. distribute-lft-out 98.0%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around 0 87.8%

      \[\leadsto \color{blue}{d1 \cdot \left(\left(d2 + d4\right) - d3\right)} \]
3. Recombined 2 regimes into one program.

4. Final simplification 90.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;d1 \leq -1.25 \cdot 10^{+159} \lor \neg \left(d1 \leq 2.1 \cdot 10^{+155}\right):\\ \;\;\;\;d1 \cdot \left(\left(-d1\right) - d3\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(\left(d4 + d2\right) - d3\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 64.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d1 \leq -2.16 \cdot 10^{+207} \lor \neg \left(d1 \leq 3.1 \cdot 10^{+159}\right):\\ \;\;\;\;d1 \cdot \left(-d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 + d2\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (or (<= d1 -2.16e+207) (not (<= d1 3.1e+159)))
   (* d1 (- d1))
   (* d1 (+ d4 d2))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if ((d1 <= -2.16e+207) || !(d1 <= 3.1e+159)) {
		tmp = d1 * -d1;
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

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
    real(8) :: tmp
    if ((d1 <= (-2.16d+207)) .or. (.not. (d1 <= 3.1d+159))) then
        tmp = d1 * -d1
    else
        tmp = d1 * (d4 + d2)
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if ((d1 <= -2.16e+207) || !(d1 <= 3.1e+159)) {
		tmp = d1 * -d1;
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if (d1 <= -2.16e+207) or not (d1 <= 3.1e+159):
		tmp = d1 * -d1
	else:
		tmp = d1 * (d4 + d2)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if ((d1 <= -2.16e+207) || !(d1 <= 3.1e+159))
		tmp = Float64(d1 * Float64(-d1));
	else
		tmp = Float64(d1 * Float64(d4 + d2));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if ((d1 <= -2.16e+207) || ~((d1 <= 3.1e+159)))
		tmp = d1 * -d1;
	else
		tmp = d1 * (d4 + d2);
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := If[Or[LessEqual[d1, -2.16e+207], N[Not[LessEqual[d1, 3.1e+159]], $MachinePrecision]], N[(d1 * (-d1)), $MachinePrecision], N[(d1 * N[(d4 + d2), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d1 < -2.16000000000000003e207 or 3.0999999999999998e159 < d1

   1. Initial program 62.0%

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

      1. +-commutative 62.0%

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

      2. *-commutative 62.0%

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

      3. distribute-lft-out-- 66.0%

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

      4. distribute-lft-out 68.0%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around inf 94.0%

      \[\leadsto d1 \cdot \color{blue}{\left(-1 \cdot d1\right)} \]
   6. Step-by-step derivation

      1. neg-mul-1 94.0%

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

   7. Simplified 94.0%

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

   if -2.16000000000000003e207 < d1 < 3.0999999999999998e159

   1. Initial program 96.6%

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

      1. +-commutative 96.6%

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

      2. *-commutative 96.6%

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

      3. distribute-lft-out-- 96.6%

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

      4. distribute-lft-out 97.1%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around 0 87.2%

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

   6. Taylor expanded in d3 around 0 69.1%

      \[\leadsto \color{blue}{d1 \cdot \left(d2 + d4\right)} \]
   7. Step-by-step derivation

      1. +-commutative 69.1%

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

   8. Simplified 69.1%

      \[\leadsto \color{blue}{d1 \cdot \left(d4 + d2\right)} \]
3. Recombined 2 regimes into one program.

4. Final simplification 74.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;d1 \leq -2.16 \cdot 10^{+207} \lor \neg \left(d1 \leq 3.1 \cdot 10^{+159}\right):\\ \;\;\;\;d1 \cdot \left(-d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 + d2\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 61.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d4 \leq 4.8 \cdot 10^{+39}:\\ \;\;\;\;d1 \cdot \left(d2 - d1\right)\\ \mathbf{elif}\;d4 \leq 7.8 \cdot 10^{+83}:\\ \;\;\;\;d1 \cdot \left(d2 - d3\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 + d2\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d4 4.8e+39)
   (* d1 (- d2 d1))
   (if (<= d4 7.8e+83) (* d1 (- d2 d3)) (* d1 (+ d4 d2)))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 4.8e+39) {
		tmp = d1 * (d2 - d1);
	} else if (d4 <= 7.8e+83) {
		tmp = d1 * (d2 - d3);
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

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
    real(8) :: tmp
    if (d4 <= 4.8d+39) then
        tmp = d1 * (d2 - d1)
    else if (d4 <= 7.8d+83) then
        tmp = d1 * (d2 - d3)
    else
        tmp = d1 * (d4 + d2)
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 4.8e+39) {
		tmp = d1 * (d2 - d1);
	} else if (d4 <= 7.8e+83) {
		tmp = d1 * (d2 - d3);
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d4 <= 4.8e+39:
		tmp = d1 * (d2 - d1)
	elif d4 <= 7.8e+83:
		tmp = d1 * (d2 - d3)
	else:
		tmp = d1 * (d4 + d2)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= 4.8e+39)
		tmp = Float64(d1 * Float64(d2 - d1));
	elseif (d4 <= 7.8e+83)
		tmp = Float64(d1 * Float64(d2 - d3));
	else
		tmp = Float64(d1 * Float64(d4 + d2));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d4 <= 4.8e+39)
		tmp = d1 * (d2 - d1);
	elseif (d4 <= 7.8e+83)
		tmp = d1 * (d2 - d3);
	else
		tmp = d1 * (d4 + d2);
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := If[LessEqual[d4, 4.8e+39], N[(d1 * N[(d2 - d1), $MachinePrecision]), $MachinePrecision], If[LessEqual[d4, 7.8e+83], N[(d1 * N[(d2 - d3), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(d4 + d2), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if d4 < 4.8000000000000002e39

   1. Initial program 90.3%

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

      1. +-commutative 90.3%

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

      2. *-commutative 90.3%

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

      3. distribute-lft-out-- 90.9%

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

      4. distribute-lft-out 90.9%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d4 around 0 83.4%

      \[\leadsto \color{blue}{d1 \cdot \left(d2 - \left(d1 + d3\right)\right)} \]
   6. Step-by-step derivation

      1. +-commutative 83.4%

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

      2. associate--r+ 83.4%

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

   7. Simplified 83.4%

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

   8. Taylor expanded in d3 around 0 66.1%

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

   if 4.8000000000000002e39 < d4 < 7.8000000000000003e83

   1. Initial program 89.8%

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

      1. +-commutative 89.8%

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

      2. *-commutative 89.8%

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

      3. distribute-lft-out-- 100.0%

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

      4. distribute-lft-out 100.0%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around 0 80.8%

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

   6. Taylor expanded in d4 around 0 80.9%

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

   if 7.8000000000000003e83 < d4

   1. Initial program 88.3%

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

      1. +-commutative 88.3%

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

      2. *-commutative 88.3%

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

      3. distribute-lft-out-- 88.3%

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

      4. distribute-lft-out 91.7%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around 0 95.0%

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

   6. Taylor expanded in d3 around 0 83.8%

      \[\leadsto \color{blue}{d1 \cdot \left(d2 + d4\right)} \]
   7. Step-by-step derivation

      1. +-commutative 83.8%

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

   8. Simplified 83.8%

      \[\leadsto \color{blue}{d1 \cdot \left(d4 + d2\right)} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 6: 38.9% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d4 \leq 1.52 \cdot 10^{-124}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{elif}\;d4 \leq 1.8 \cdot 10^{+75}:\\ \;\;\;\;d1 \cdot \left(-d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot d4\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d4 1.52e-124) (* d1 d2) (if (<= d4 1.8e+75) (* d1 (- d1)) (* d1 d4))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 1.52e-124) {
		tmp = d1 * d2;
	} else if (d4 <= 1.8e+75) {
		tmp = d1 * -d1;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

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
    real(8) :: tmp
    if (d4 <= 1.52d-124) then
        tmp = d1 * d2
    else if (d4 <= 1.8d+75) then
        tmp = d1 * -d1
    else
        tmp = d1 * d4
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 1.52e-124) {
		tmp = d1 * d2;
	} else if (d4 <= 1.8e+75) {
		tmp = d1 * -d1;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d4 <= 1.52e-124:
		tmp = d1 * d2
	elif d4 <= 1.8e+75:
		tmp = d1 * -d1
	else:
		tmp = d1 * d4
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= 1.52e-124)
		tmp = Float64(d1 * d2);
	elseif (d4 <= 1.8e+75)
		tmp = Float64(d1 * Float64(-d1));
	else
		tmp = Float64(d1 * d4);
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d4 <= 1.52e-124)
		tmp = d1 * d2;
	elseif (d4 <= 1.8e+75)
		tmp = d1 * -d1;
	else
		tmp = d1 * d4;
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := If[LessEqual[d4, 1.52e-124], N[(d1 * d2), $MachinePrecision], If[LessEqual[d4, 1.8e+75], N[(d1 * (-d1)), $MachinePrecision], N[(d1 * d4), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if d4 < 1.52e-124

   1. Initial program 90.3%

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

      1. +-commutative 90.3%

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

      2. *-commutative 90.3%

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

      3. distribute-lft-out-- 90.9%

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

      4. distribute-lft-out 90.9%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around inf 39.9%

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

   if 1.52e-124 < d4 < 1.8e75

   1. Initial program 90.2%

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

      1. +-commutative 90.2%

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

      2. *-commutative 90.2%

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

      3. distribute-lft-out-- 92.7%

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

      4. distribute-lft-out 92.7%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around inf 49.7%

      \[\leadsto d1 \cdot \color{blue}{\left(-1 \cdot d1\right)} \]
   6. Step-by-step derivation

      1. neg-mul-1 49.7%

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

   7. Simplified 49.7%

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

   if 1.8e75 < d4

   1. Initial program 88.5%

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

      1. +-commutative 88.5%

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

      2. *-commutative 88.5%

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

      3. distribute-lft-out-- 88.5%

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

      4. distribute-lft-out 91.8%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d4 around inf 76.9%

      \[\leadsto \color{blue}{d1 \cdot d4} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 7: 85.4% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d4 \leq 7 \cdot 10^{+71}:\\ \;\;\;\;d1 \cdot \left(\left(d2 - d3\right) - d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(\left(d4 + d2\right) - d3\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d4 7e+71) (* d1 (- (- d2 d3) d1)) (* d1 (- (+ d4 d2) d3))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 7e+71) {
		tmp = d1 * ((d2 - d3) - d1);
	} else {
		tmp = d1 * ((d4 + d2) - d3);
	}
	return tmp;
}

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
    real(8) :: tmp
    if (d4 <= 7d+71) then
        tmp = d1 * ((d2 - d3) - d1)
    else
        tmp = d1 * ((d4 + d2) - d3)
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 7e+71) {
		tmp = d1 * ((d2 - d3) - d1);
	} else {
		tmp = d1 * ((d4 + d2) - d3);
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d4 <= 7e+71:
		tmp = d1 * ((d2 - d3) - d1)
	else:
		tmp = d1 * ((d4 + d2) - d3)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= 7e+71)
		tmp = Float64(d1 * Float64(Float64(d2 - d3) - d1));
	else
		tmp = Float64(d1 * Float64(Float64(d4 + d2) - d3));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d4 <= 7e+71)
		tmp = d1 * ((d2 - d3) - d1);
	else
		tmp = d1 * ((d4 + d2) - d3);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if d4 < 6.9999999999999998e71

   1. Initial program 90.2%

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

      1. +-commutative 90.2%

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

      2. *-commutative 90.2%

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

      3. distribute-lft-out-- 91.2%

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

      4. distribute-lft-out 91.2%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d4 around 0 84.1%

      \[\leadsto \color{blue}{d1 \cdot \left(d2 - \left(d1 + d3\right)\right)} \]
   6. Step-by-step derivation

      1. +-commutative 84.1%

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

      2. associate--r+ 84.1%

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

   7. Simplified 84.1%

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

   if 6.9999999999999998e71 < d4

   1. Initial program 88.7%

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

      1. +-commutative 88.7%

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

      2. *-commutative 88.7%

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

      3. distribute-lft-out-- 88.7%

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

      4. distribute-lft-out 91.9%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around 0 95.2%

      \[\leadsto \color{blue}{d1 \cdot \left(\left(d2 + d4\right) - d3\right)} \]
3. Recombined 2 regimes into one program.

4. Final simplification 86.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;d4 \leq 7 \cdot 10^{+71}:\\ \;\;\;\;d1 \cdot \left(\left(d2 - d3\right) - d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(\left(d4 + d2\right) - d3\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 62.0% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d4 \leq 4.2 \cdot 10^{+75}:\\ \;\;\;\;d1 \cdot \left(d2 - d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 - d3\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d4 4.2e+75) (* d1 (- d2 d1)) (* d1 (- d4 d3))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 4.2e+75) {
		tmp = d1 * (d2 - d1);
	} else {
		tmp = d1 * (d4 - d3);
	}
	return tmp;
}

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
    real(8) :: tmp
    if (d4 <= 4.2d+75) then
        tmp = d1 * (d2 - d1)
    else
        tmp = d1 * (d4 - d3)
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 4.2e+75) {
		tmp = d1 * (d2 - d1);
	} else {
		tmp = d1 * (d4 - d3);
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d4 <= 4.2e+75:
		tmp = d1 * (d2 - d1)
	else:
		tmp = d1 * (d4 - d3)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= 4.2e+75)
		tmp = Float64(d1 * Float64(d2 - d1));
	else
		tmp = Float64(d1 * Float64(d4 - d3));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d4 <= 4.2e+75)
		tmp = d1 * (d2 - d1);
	else
		tmp = d1 * (d4 - d3);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if d4 < 4.19999999999999997e75

   1. Initial program 90.2%

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

      1. +-commutative 90.2%

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

      2. *-commutative 90.2%

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

      3. distribute-lft-out-- 91.3%

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

      4. distribute-lft-out 91.3%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d4 around 0 84.1%

      \[\leadsto \color{blue}{d1 \cdot \left(d2 - \left(d1 + d3\right)\right)} \]
   6. Step-by-step derivation

      1. +-commutative 84.1%

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

      2. associate--r+ 84.1%

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

   7. Simplified 84.1%

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

   8. Taylor expanded in d3 around 0 66.4%

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

   if 4.19999999999999997e75 < d4

   1. Initial program 88.5%

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

      1. +-commutative 88.5%

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

      2. *-commutative 88.5%

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

      3. distribute-lft-out-- 88.5%

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

      4. distribute-lft-out 91.8%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around 0 95.1%

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

   6. Taylor expanded in d2 around 0 87.8%

      \[\leadsto \color{blue}{d1 \cdot \left(d4 - d3\right)} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 9: 61.7% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d4 \leq 1.1 \cdot 10^{+72}:\\ \;\;\;\;d1 \cdot \left(d2 - d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 + d2\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d4 1.1e+72) (* d1 (- d2 d1)) (* d1 (+ d4 d2))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 1.1e+72) {
		tmp = d1 * (d2 - d1);
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

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
    real(8) :: tmp
    if (d4 <= 1.1d+72) then
        tmp = d1 * (d2 - d1)
    else
        tmp = d1 * (d4 + d2)
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 1.1e+72) {
		tmp = d1 * (d2 - d1);
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d4 <= 1.1e+72:
		tmp = d1 * (d2 - d1)
	else:
		tmp = d1 * (d4 + d2)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= 1.1e+72)
		tmp = Float64(d1 * Float64(d2 - d1));
	else
		tmp = Float64(d1 * Float64(d4 + d2));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d4 <= 1.1e+72)
		tmp = d1 * (d2 - d1);
	else
		tmp = d1 * (d4 + d2);
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := If[LessEqual[d4, 1.1e+72], N[(d1 * N[(d2 - d1), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(d4 + d2), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d4 < 1.1e72

   1. Initial program 90.2%

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

      1. +-commutative 90.2%

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

      2. *-commutative 90.2%

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

      3. distribute-lft-out-- 91.2%

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

      4. distribute-lft-out 91.2%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d4 around 0 84.1%

      \[\leadsto \color{blue}{d1 \cdot \left(d2 - \left(d1 + d3\right)\right)} \]
   6. Step-by-step derivation

      1. +-commutative 84.1%

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

      2. associate--r+ 84.1%

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

   7. Simplified 84.1%

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

   8. Taylor expanded in d3 around 0 66.2%

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

   if 1.1e72 < d4

   1. Initial program 88.7%

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

      1. +-commutative 88.7%

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

      2. *-commutative 88.7%

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

      3. distribute-lft-out-- 88.7%

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

      4. distribute-lft-out 91.9%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around 0 95.2%

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

   6. Taylor expanded in d3 around 0 84.3%

      \[\leadsto \color{blue}{d1 \cdot \left(d2 + d4\right)} \]
   7. Step-by-step derivation

      1. +-commutative 84.3%

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

   8. Simplified 84.3%

      \[\leadsto \color{blue}{d1 \cdot \left(d4 + d2\right)} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 10: 39.0% accurate, 1.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d4 \leq 1.32 \cdot 10^{+82}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot d4\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d4 1.32e+82) (* d1 d2) (* d1 d4)))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 1.32e+82) {
		tmp = d1 * d2;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

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
    real(8) :: tmp
    if (d4 <= 1.32d+82) then
        tmp = d1 * d2
    else
        tmp = d1 * d4
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 1.32e+82) {
		tmp = d1 * d2;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d4 <= 1.32e+82:
		tmp = d1 * d2
	else:
		tmp = d1 * d4
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= 1.32e+82)
		tmp = Float64(d1 * d2);
	else
		tmp = Float64(d1 * d4);
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d4 <= 1.32e+82)
		tmp = d1 * d2;
	else
		tmp = d1 * d4;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if d4 < 1.32e82

   1. Initial program 90.3%

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

      1. +-commutative 90.3%

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

      2. *-commutative 90.3%

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

      3. distribute-lft-out-- 91.3%

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

      4. distribute-lft-out 91.3%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around inf 38.0%

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

   if 1.32e82 < d4

   1. Initial program 88.3%

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

      1. +-commutative 88.3%

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

      2. *-commutative 88.3%

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

      3. distribute-lft-out-- 88.3%

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

      4. distribute-lft-out 91.7%

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

      5. distribute-lft-out-- 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d4 around inf 78.1%

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

Alternative 11: 31.0% 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 89.8%

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

   1. +-commutative 89.8%

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

   2. *-commutative 89.8%

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

   3. distribute-lft-out-- 90.6%

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

   4. distribute-lft-out 91.4%

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

   5. distribute-lft-out-- 100.0%

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

3. Simplified 100.0%

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

5. Taylor expanded in d2 around inf 32.0%

   \[\leadsto \color{blue}{d1 \cdot d2} \]
6. Add Preprocessing

Alternative 12: 8.4% accurate, 5.0× speedup

Math

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

FPCore

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

C

double code(double d1, double d2, double d3, double d4) {
	return 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 * d1
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 89.8%

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

   1. +-commutative 89.8%

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

   2. *-commutative 89.8%

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

   3. distribute-lft-out-- 90.6%

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

   4. distribute-lft-out 91.4%

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

   5. distribute-lft-out-- 100.0%

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

3. Simplified 100.0%

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

5. Taylor expanded in d1 around inf 33.4%

   \[\leadsto d1 \cdot \color{blue}{\left(-1 \cdot d1\right)} \]
6. Step-by-step derivation

   1. neg-mul-1 33.4%

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

7. Simplified 33.4%

   \[\leadsto d1 \cdot \color{blue}{\left(-d1\right)} \]
8. Step-by-step derivation

   1. neg-sub0 33.4%

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

   2. sub-neg 33.4%

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

   3. add-sqr-sqrt 13.7%

      \[\leadsto d1 \cdot \left(0 + \color{blue}{\sqrt{-d1} \cdot \sqrt{-d1}}\right) \]

   4. sqrt-unprod 17.0%

      \[\leadsto d1 \cdot \left(0 + \color{blue}{\sqrt{\left(-d1\right) \cdot \left(-d1\right)}}\right) \]

   5. sqr-neg 17.0%

      \[\leadsto d1 \cdot \left(0 + \sqrt{\color{blue}{d1 \cdot d1}}\right) \]

   6. sqrt-unprod 3.3%

      \[\leadsto d1 \cdot \left(0 + \color{blue}{\sqrt{d1} \cdot \sqrt{d1}}\right) \]

   7. add-sqr-sqrt 7.6%

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

9. Applied egg-rr 7.6%

   \[\leadsto d1 \cdot \color{blue}{\left(0 + d1\right)} \]
10. Step-by-step derivation

    1. +-lft-identity 7.6%

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

11. Simplified 7.6%

    \[\leadsto d1 \cdot \color{blue}{d1} \]
12. Add Preprocessing

Developer Target 1: 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 2024177 
(FPCore (d1 d2 d3 d4)
  :name "FastMath dist4"
  :precision binary64

  :alt
  (! :herbie-platform default (* d1 (- (+ (- d2 d3) d4) d1)))

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