FastMath dist4

Percentage Accurate: 88.2% → 100.0%

Time: 9.7s

Alternatives: 15

Speedup: 1.7×

• 32.4% 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: 88.2% 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, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ d1 \cdot \left(\left(d2 - d3\right) + \left(d4 - d1\right)\right) \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4) :precision binary64 (* d1 (+ (- d2 d3) (- d4 d1))))

C

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

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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

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

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	return d1 * ((d2 - d3) + (d4 - d1))

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	return Float64(d1 * Float64(Float64(d2 - d3) + Float64(d4 - d1)))
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp = code(d1, d2, d3, d4)
	tmp = d1 * ((d2 - d3) + (d4 - d1));
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := N[(d1 * N[(N[(d2 - d3), $MachinePrecision] + N[(d4 - d1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 84.7%

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

   1. associate--l+ 84.7%

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

   2. distribute-lft-out-- 86.7%

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

   3. distribute-rgt-out-- 90.2%

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

   4. distribute-lft-out 100.0%

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

3. Simplified 100.0%

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

Alternative 2: 75.5% accurate, 0.5× speedup

Math

\[\begin{array}{l} [d1, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ \begin{array}{l} t_0 := d1 \cdot \left(d2 - d1\right)\\ t_1 := d1 \cdot \left(\left(-d3\right) - d1\right)\\ \mathbf{if}\;d4 \leq -2.8 \cdot 10^{-237}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;d4 \leq 1.35 \cdot 10^{-196}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;d4 \leq 1.35 \cdot 10^{-151}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;d4 \leq 1.3 \cdot 10^{+47}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;d4 \leq 8.8 \cdot 10^{+104}:\\ \;\;\;\;d1 \cdot \left(d4 - d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 - d3\right)\\ \end{array} \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4)
 :precision binary64
 (let* ((t_0 (* d1 (- d2 d1))) (t_1 (* d1 (- (- d3) d1))))
   (if (<= d4 -2.8e-237)
     t_0
     (if (<= d4 1.35e-196)
       t_1
       (if (<= d4 1.35e-151)
         t_0
         (if (<= d4 1.3e+47)
           t_1
           (if (<= d4 8.8e+104) (* d1 (- d4 d1)) (* d1 (- d4 d3)))))))))

C

assert(d1 < d2 && d2 < d3 && d3 < d4);
double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * (d2 - d1);
	double t_1 = d1 * (-d3 - d1);
	double tmp;
	if (d4 <= -2.8e-237) {
		tmp = t_0;
	} else if (d4 <= 1.35e-196) {
		tmp = t_1;
	} else if (d4 <= 1.35e-151) {
		tmp = t_0;
	} else if (d4 <= 1.3e+47) {
		tmp = t_1;
	} else if (d4 <= 8.8e+104) {
		tmp = d1 * (d4 - d1);
	} else {
		tmp = d1 * (d4 - d3);
	}
	return tmp;
}

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = d1 * (d2 - d1)
    t_1 = d1 * (-d3 - d1)
    if (d4 <= (-2.8d-237)) then
        tmp = t_0
    else if (d4 <= 1.35d-196) then
        tmp = t_1
    else if (d4 <= 1.35d-151) then
        tmp = t_0
    else if (d4 <= 1.3d+47) then
        tmp = t_1
    else if (d4 <= 8.8d+104) then
        tmp = d1 * (d4 - d1)
    else
        tmp = d1 * (d4 - d3)
    end if
    code = tmp
end function

Java

assert d1 < d2 && d2 < d3 && d3 < d4;
public static double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * (d2 - d1);
	double t_1 = d1 * (-d3 - d1);
	double tmp;
	if (d4 <= -2.8e-237) {
		tmp = t_0;
	} else if (d4 <= 1.35e-196) {
		tmp = t_1;
	} else if (d4 <= 1.35e-151) {
		tmp = t_0;
	} else if (d4 <= 1.3e+47) {
		tmp = t_1;
	} else if (d4 <= 8.8e+104) {
		tmp = d1 * (d4 - d1);
	} else {
		tmp = d1 * (d4 - d3);
	}
	return tmp;
}

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	t_0 = d1 * (d2 - d1)
	t_1 = d1 * (-d3 - d1)
	tmp = 0
	if d4 <= -2.8e-237:
		tmp = t_0
	elif d4 <= 1.35e-196:
		tmp = t_1
	elif d4 <= 1.35e-151:
		tmp = t_0
	elif d4 <= 1.3e+47:
		tmp = t_1
	elif d4 <= 8.8e+104:
		tmp = d1 * (d4 - d1)
	else:
		tmp = d1 * (d4 - d3)
	return tmp

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	t_0 = Float64(d1 * Float64(d2 - d1))
	t_1 = Float64(d1 * Float64(Float64(-d3) - d1))
	tmp = 0.0
	if (d4 <= -2.8e-237)
		tmp = t_0;
	elseif (d4 <= 1.35e-196)
		tmp = t_1;
	elseif (d4 <= 1.35e-151)
		tmp = t_0;
	elseif (d4 <= 1.3e+47)
		tmp = t_1;
	elseif (d4 <= 8.8e+104)
		tmp = Float64(d1 * Float64(d4 - d1));
	else
		tmp = Float64(d1 * Float64(d4 - d3));
	end
	return tmp
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp_2 = code(d1, d2, d3, d4)
	t_0 = d1 * (d2 - d1);
	t_1 = d1 * (-d3 - d1);
	tmp = 0.0;
	if (d4 <= -2.8e-237)
		tmp = t_0;
	elseif (d4 <= 1.35e-196)
		tmp = t_1;
	elseif (d4 <= 1.35e-151)
		tmp = t_0;
	elseif (d4 <= 1.3e+47)
		tmp = t_1;
	elseif (d4 <= 8.8e+104)
		tmp = d1 * (d4 - d1);
	else
		tmp = d1 * (d4 - d3);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := Block[{t$95$0 = N[(d1 * N[(d2 - d1), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(d1 * N[((-d3) - d1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d4, -2.8e-237], t$95$0, If[LessEqual[d4, 1.35e-196], t$95$1, If[LessEqual[d4, 1.35e-151], t$95$0, If[LessEqual[d4, 1.3e+47], t$95$1, If[LessEqual[d4, 8.8e+104], N[(d1 * N[(d4 - d1), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(d4 - d3), $MachinePrecision]), $MachinePrecision]]]]]]]]

Derivation

1. Split input into 4 regimes

2. if d4 < -2.79999999999999997e-237 or 1.34999999999999991e-196 < d4 < 1.35000000000000004e-151

   1. Initial program 83.8%

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

      1. associate--l+ 83.8%

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

      2. distribute-lft-out-- 86.3%

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

      3. distribute-rgt-out-- 88.7%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around 0 78.8%

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

   6. Taylor expanded in d4 around 0 57.2%

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

   if -2.79999999999999997e-237 < d4 < 1.34999999999999991e-196 or 1.35000000000000004e-151 < d4 < 1.30000000000000002e47

   1. Initial program 86.0%

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

      1. associate--l+ 86.0%

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

      2. distribute-lft-out-- 88.6%

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

      3. distribute-rgt-out-- 88.6%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around 0 77.0%

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

      1. associate--r+ 77.0%

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

   7. Simplified 77.0%

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

   8. Taylor expanded in d4 around 0 75.6%

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

      1. associate-*r* 75.6%

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

      2. mul-1-neg 75.6%

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

   10. Simplified 75.6%

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

   if 1.30000000000000002e47 < d4 < 8.80000000000000002e104

   1. Initial program 100.0%

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

      1. associate--l+ 100.0%

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

      2. distribute-lft-out-- 100.0%

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

      3. distribute-rgt-out-- 100.0%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around 0 94.0%

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

   6. Taylor expanded in d2 around 0 62.0%

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

   if 8.80000000000000002e104 < d4

   1. Initial program 80.4%

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

      1. associate--l+ 80.4%

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

      2. distribute-lft-out-- 80.4%

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

      3. distribute-rgt-out-- 95.0%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around 0 87.0%

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

      1. associate--r+ 87.0%

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

   7. Simplified 87.0%

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

   8. Taylor expanded in d1 around 0 87.0%

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

4. Final simplification 67.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;d4 \leq -2.8 \cdot 10^{-237}:\\ \;\;\;\;d1 \cdot \left(d2 - d1\right)\\ \mathbf{elif}\;d4 \leq 1.35 \cdot 10^{-196}:\\ \;\;\;\;d1 \cdot \left(\left(-d3\right) - d1\right)\\ \mathbf{elif}\;d4 \leq 1.35 \cdot 10^{-151}:\\ \;\;\;\;d1 \cdot \left(d2 - d1\right)\\ \mathbf{elif}\;d4 \leq 1.3 \cdot 10^{+47}:\\ \;\;\;\;d1 \cdot \left(\left(-d3\right) - d1\right)\\ \mathbf{elif}\;d4 \leq 8.8 \cdot 10^{+104}:\\ \;\;\;\;d1 \cdot \left(d4 - d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 - d3\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 68.2% accurate, 0.6× speedup

Math

\[\begin{array}{l} [d1, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ \begin{array}{l} t_0 := d1 \cdot \left(d2 - d3\right)\\ t_1 := d1 \cdot \left(d4 - d1\right)\\ \mathbf{if}\;d3 \leq -820000:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;d3 \leq 1.6 \cdot 10^{-272}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;d3 \leq 5.5 \cdot 10^{+78}:\\ \;\;\;\;d1 \cdot \left(d2 + d4\right)\\ \mathbf{elif}\;d3 \leq 1.1 \cdot 10^{+199}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4)
 :precision binary64
 (let* ((t_0 (* d1 (- d2 d3))) (t_1 (* d1 (- d4 d1))))
   (if (<= d3 -820000.0)
     t_0
     (if (<= d3 1.6e-272)
       t_1
       (if (<= d3 5.5e+78) (* d1 (+ d2 d4)) (if (<= d3 1.1e+199) t_1 t_0))))))

C

assert(d1 < d2 && d2 < d3 && d3 < d4);
double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * (d2 - d3);
	double t_1 = d1 * (d4 - d1);
	double tmp;
	if (d3 <= -820000.0) {
		tmp = t_0;
	} else if (d3 <= 1.6e-272) {
		tmp = t_1;
	} else if (d3 <= 5.5e+78) {
		tmp = d1 * (d2 + d4);
	} else if (d3 <= 1.1e+199) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = d1 * (d2 - d3)
    t_1 = d1 * (d4 - d1)
    if (d3 <= (-820000.0d0)) then
        tmp = t_0
    else if (d3 <= 1.6d-272) then
        tmp = t_1
    else if (d3 <= 5.5d+78) then
        tmp = d1 * (d2 + d4)
    else if (d3 <= 1.1d+199) then
        tmp = t_1
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

assert d1 < d2 && d2 < d3 && d3 < d4;
public static double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * (d2 - d3);
	double t_1 = d1 * (d4 - d1);
	double tmp;
	if (d3 <= -820000.0) {
		tmp = t_0;
	} else if (d3 <= 1.6e-272) {
		tmp = t_1;
	} else if (d3 <= 5.5e+78) {
		tmp = d1 * (d2 + d4);
	} else if (d3 <= 1.1e+199) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	t_0 = d1 * (d2 - d3)
	t_1 = d1 * (d4 - d1)
	tmp = 0
	if d3 <= -820000.0:
		tmp = t_0
	elif d3 <= 1.6e-272:
		tmp = t_1
	elif d3 <= 5.5e+78:
		tmp = d1 * (d2 + d4)
	elif d3 <= 1.1e+199:
		tmp = t_1
	else:
		tmp = t_0
	return tmp

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	t_0 = Float64(d1 * Float64(d2 - d3))
	t_1 = Float64(d1 * Float64(d4 - d1))
	tmp = 0.0
	if (d3 <= -820000.0)
		tmp = t_0;
	elseif (d3 <= 1.6e-272)
		tmp = t_1;
	elseif (d3 <= 5.5e+78)
		tmp = Float64(d1 * Float64(d2 + d4));
	elseif (d3 <= 1.1e+199)
		tmp = t_1;
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp_2 = code(d1, d2, d3, d4)
	t_0 = d1 * (d2 - d3);
	t_1 = d1 * (d4 - d1);
	tmp = 0.0;
	if (d3 <= -820000.0)
		tmp = t_0;
	elseif (d3 <= 1.6e-272)
		tmp = t_1;
	elseif (d3 <= 5.5e+78)
		tmp = d1 * (d2 + d4);
	elseif (d3 <= 1.1e+199)
		tmp = t_1;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := Block[{t$95$0 = N[(d1 * N[(d2 - d3), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(d1 * N[(d4 - d1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d3, -820000.0], t$95$0, If[LessEqual[d3, 1.6e-272], t$95$1, If[LessEqual[d3, 5.5e+78], N[(d1 * N[(d2 + d4), $MachinePrecision]), $MachinePrecision], If[LessEqual[d3, 1.1e+199], t$95$1, t$95$0]]]]]]

Derivation

1. Split input into 3 regimes

2. if d3 < -8.2e5 or 1.1000000000000001e199 < d3

   1. Initial program 83.1%

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

      1. associate--l+ 83.1%

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

      2. distribute-lft-out-- 86.7%

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

      3. distribute-rgt-out-- 87.9%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around 0 94.9%

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

   6. Taylor expanded in d4 around 0 81.9%

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

   if -8.2e5 < d3 < 1.6e-272 or 5.4999999999999997e78 < d3 < 1.1000000000000001e199

   1. Initial program 82.5%

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

      1. associate--l+ 82.5%

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

      2. distribute-lft-out-- 83.5%

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

      3. distribute-rgt-out-- 86.4%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around 0 90.9%

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

   6. Taylor expanded in d2 around 0 66.4%

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

   if 1.6e-272 < d3 < 5.4999999999999997e78

   1. Initial program 90.0%

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

      1. associate--l+ 90.0%

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

      2. distribute-lft-out-- 91.4%

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

      3. distribute-rgt-out-- 98.5%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around 0 91.9%

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

   6. Taylor expanded in d1 around 0 74.3%

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

Alternative 4: 53.4% accurate, 0.6× speedup

Math

\[\begin{array}{l} [d1, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ \begin{array}{l} t_0 := d1 \cdot \left(-d3\right)\\ \mathbf{if}\;d4 \leq -5.2 \cdot 10^{-264}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{elif}\;d4 \leq 4.5 \cdot 10^{-196}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;d4 \leq 1.12 \cdot 10^{-148}:\\ \;\;\;\;d1 \cdot \left(-d1\right)\\ \mathbf{elif}\;d4 \leq 1.85 \cdot 10^{+47}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot d4\\ \end{array} \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4)
 :precision binary64
 (let* ((t_0 (* d1 (- d3))))
   (if (<= d4 -5.2e-264)
     (* d1 d2)
     (if (<= d4 4.5e-196)
       t_0
       (if (<= d4 1.12e-148)
         (* d1 (- d1))
         (if (<= d4 1.85e+47) t_0 (* d1 d4)))))))

C

assert(d1 < d2 && d2 < d3 && d3 < d4);
double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * -d3;
	double tmp;
	if (d4 <= -5.2e-264) {
		tmp = d1 * d2;
	} else if (d4 <= 4.5e-196) {
		tmp = t_0;
	} else if (d4 <= 1.12e-148) {
		tmp = d1 * -d1;
	} else if (d4 <= 1.85e+47) {
		tmp = t_0;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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) :: t_0
    real(8) :: tmp
    t_0 = d1 * -d3
    if (d4 <= (-5.2d-264)) then
        tmp = d1 * d2
    else if (d4 <= 4.5d-196) then
        tmp = t_0
    else if (d4 <= 1.12d-148) then
        tmp = d1 * -d1
    else if (d4 <= 1.85d+47) then
        tmp = t_0
    else
        tmp = d1 * d4
    end if
    code = tmp
end function

Java

assert d1 < d2 && d2 < d3 && d3 < d4;
public static double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * -d3;
	double tmp;
	if (d4 <= -5.2e-264) {
		tmp = d1 * d2;
	} else if (d4 <= 4.5e-196) {
		tmp = t_0;
	} else if (d4 <= 1.12e-148) {
		tmp = d1 * -d1;
	} else if (d4 <= 1.85e+47) {
		tmp = t_0;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	t_0 = d1 * -d3
	tmp = 0
	if d4 <= -5.2e-264:
		tmp = d1 * d2
	elif d4 <= 4.5e-196:
		tmp = t_0
	elif d4 <= 1.12e-148:
		tmp = d1 * -d1
	elif d4 <= 1.85e+47:
		tmp = t_0
	else:
		tmp = d1 * d4
	return tmp

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	t_0 = Float64(d1 * Float64(-d3))
	tmp = 0.0
	if (d4 <= -5.2e-264)
		tmp = Float64(d1 * d2);
	elseif (d4 <= 4.5e-196)
		tmp = t_0;
	elseif (d4 <= 1.12e-148)
		tmp = Float64(d1 * Float64(-d1));
	elseif (d4 <= 1.85e+47)
		tmp = t_0;
	else
		tmp = Float64(d1 * d4);
	end
	return tmp
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp_2 = code(d1, d2, d3, d4)
	t_0 = d1 * -d3;
	tmp = 0.0;
	if (d4 <= -5.2e-264)
		tmp = d1 * d2;
	elseif (d4 <= 4.5e-196)
		tmp = t_0;
	elseif (d4 <= 1.12e-148)
		tmp = d1 * -d1;
	elseif (d4 <= 1.85e+47)
		tmp = t_0;
	else
		tmp = d1 * d4;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := Block[{t$95$0 = N[(d1 * (-d3)), $MachinePrecision]}, If[LessEqual[d4, -5.2e-264], N[(d1 * d2), $MachinePrecision], If[LessEqual[d4, 4.5e-196], t$95$0, If[LessEqual[d4, 1.12e-148], N[(d1 * (-d1)), $MachinePrecision], If[LessEqual[d4, 1.85e+47], t$95$0, N[(d1 * d4), $MachinePrecision]]]]]]

Derivation

1. Split input into 4 regimes

2. if d4 < -5.2000000000000004e-264

   1. Initial program 83.2%

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

      1. associate--l+ 83.2%

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

      2. distribute-lft-out-- 85.7%

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

      3. distribute-rgt-out-- 88.2%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around inf 37.7%

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

   if -5.2000000000000004e-264 < d4 < 4.5e-196 or 1.1199999999999999e-148 < d4 < 1.8500000000000002e47

   1. Initial program 85.1%

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

      1. associate--l+ 85.1%

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

      2. distribute-lft-out-- 87.8%

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

      3. distribute-rgt-out-- 87.8%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around inf 47.1%

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

      1. mul-1-neg 47.1%

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

      2. distribute-rgt-neg-out 47.1%

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

   7. Simplified 47.1%

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

   if 4.5e-196 < d4 < 1.1199999999999999e-148

   1. Initial program 100.0%

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

      1. associate--l+ 100.0%

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

      2. distribute-lft-out-- 100.0%

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

      3. distribute-rgt-out-- 100.0%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around inf 62.4%

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

      1. neg-mul-1 62.4%

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

   7. Simplified 62.4%

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

   if 1.8500000000000002e47 < d4

   1. Initial program 84.8%

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

      1. associate--l+ 84.8%

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

      2. distribute-lft-out-- 84.8%

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

      3. distribute-rgt-out-- 96.2%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d4 around inf 61.0%

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

Alternative 5: 70.2% accurate, 0.7× speedup

Math

\[\begin{array}{l} [d1, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ \begin{array}{l} t_0 := d1 \cdot \left(d2 - d1\right)\\ \mathbf{if}\;d4 \leq 6.8 \cdot 10^{-124}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;d4 \leq 1.75 \cdot 10^{-100}:\\ \;\;\;\;d1 \cdot \left(-d3\right)\\ \mathbf{elif}\;d4 \leq 4.9 \cdot 10^{+104}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d2 + d4\right)\\ \end{array} \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4)
 :precision binary64
 (let* ((t_0 (* d1 (- d2 d1))))
   (if (<= d4 6.8e-124)
     t_0
     (if (<= d4 1.75e-100)
       (* d1 (- d3))
       (if (<= d4 4.9e+104) t_0 (* d1 (+ d2 d4)))))))

C

assert(d1 < d2 && d2 < d3 && d3 < d4);
double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * (d2 - d1);
	double tmp;
	if (d4 <= 6.8e-124) {
		tmp = t_0;
	} else if (d4 <= 1.75e-100) {
		tmp = d1 * -d3;
	} else if (d4 <= 4.9e+104) {
		tmp = t_0;
	} else {
		tmp = d1 * (d2 + d4);
	}
	return tmp;
}

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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) :: t_0
    real(8) :: tmp
    t_0 = d1 * (d2 - d1)
    if (d4 <= 6.8d-124) then
        tmp = t_0
    else if (d4 <= 1.75d-100) then
        tmp = d1 * -d3
    else if (d4 <= 4.9d+104) then
        tmp = t_0
    else
        tmp = d1 * (d2 + d4)
    end if
    code = tmp
end function

Java

assert d1 < d2 && d2 < d3 && d3 < d4;
public static double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * (d2 - d1);
	double tmp;
	if (d4 <= 6.8e-124) {
		tmp = t_0;
	} else if (d4 <= 1.75e-100) {
		tmp = d1 * -d3;
	} else if (d4 <= 4.9e+104) {
		tmp = t_0;
	} else {
		tmp = d1 * (d2 + d4);
	}
	return tmp;
}

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	t_0 = d1 * (d2 - d1)
	tmp = 0
	if d4 <= 6.8e-124:
		tmp = t_0
	elif d4 <= 1.75e-100:
		tmp = d1 * -d3
	elif d4 <= 4.9e+104:
		tmp = t_0
	else:
		tmp = d1 * (d2 + d4)
	return tmp

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	t_0 = Float64(d1 * Float64(d2 - d1))
	tmp = 0.0
	if (d4 <= 6.8e-124)
		tmp = t_0;
	elseif (d4 <= 1.75e-100)
		tmp = Float64(d1 * Float64(-d3));
	elseif (d4 <= 4.9e+104)
		tmp = t_0;
	else
		tmp = Float64(d1 * Float64(d2 + d4));
	end
	return tmp
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp_2 = code(d1, d2, d3, d4)
	t_0 = d1 * (d2 - d1);
	tmp = 0.0;
	if (d4 <= 6.8e-124)
		tmp = t_0;
	elseif (d4 <= 1.75e-100)
		tmp = d1 * -d3;
	elseif (d4 <= 4.9e+104)
		tmp = t_0;
	else
		tmp = d1 * (d2 + d4);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := Block[{t$95$0 = N[(d1 * N[(d2 - d1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d4, 6.8e-124], t$95$0, If[LessEqual[d4, 1.75e-100], N[(d1 * (-d3)), $MachinePrecision], If[LessEqual[d4, 4.9e+104], t$95$0, N[(d1 * N[(d2 + d4), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

1. Split input into 3 regimes

2. if d4 < 6.8000000000000001e-124 or 1.75e-100 < d4 < 4.89999999999999985e104

   1. Initial program 85.0%

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

      1. associate--l+ 85.0%

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

      2. distribute-lft-out-- 87.4%

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

      3. distribute-rgt-out-- 88.9%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around 0 76.2%

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

   6. Taylor expanded in d4 around 0 60.4%

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

   if 6.8000000000000001e-124 < d4 < 1.75e-100

   1. Initial program 100.0%

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

      1. associate--l+ 100.0%

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

      2. distribute-lft-out-- 100.0%

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

      3. distribute-rgt-out-- 100.0%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around inf 63.7%

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

      1. mul-1-neg 63.7%

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

      2. distribute-rgt-neg-out 63.7%

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

   7. Simplified 63.7%

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

   if 4.89999999999999985e104 < d4

   1. Initial program 80.4%

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

      1. associate--l+ 80.4%

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

      2. distribute-lft-out-- 80.4%

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

      3. distribute-rgt-out-- 95.0%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around 0 78.3%

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

   6. Taylor expanded in d1 around 0 78.3%

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

Alternative 6: 93.2% accurate, 0.9× speedup

Math

\[\begin{array}{l} [d1, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ \begin{array}{l} \mathbf{if}\;d3 \leq -1500000000 \lor \neg \left(d3 \leq 10500\right):\\ \;\;\;\;d1 \cdot \left(\left(d2 + d4\right) - d3\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(\left(d2 + d4\right) - d1\right)\\ \end{array} \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (or (<= d3 -1500000000.0) (not (<= d3 10500.0)))
   (* d1 (- (+ d2 d4) d3))
   (* d1 (- (+ d2 d4) d1))))

C

assert(d1 < d2 && d2 < d3 && d3 < d4);
double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if ((d3 <= -1500000000.0) || !(d3 <= 10500.0)) {
		tmp = d1 * ((d2 + d4) - d3);
	} else {
		tmp = d1 * ((d2 + d4) - d1);
	}
	return tmp;
}

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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 ((d3 <= (-1500000000.0d0)) .or. (.not. (d3 <= 10500.0d0))) then
        tmp = d1 * ((d2 + d4) - d3)
    else
        tmp = d1 * ((d2 + d4) - d1)
    end if
    code = tmp
end function

Java

assert d1 < d2 && d2 < d3 && d3 < d4;
public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if ((d3 <= -1500000000.0) || !(d3 <= 10500.0)) {
		tmp = d1 * ((d2 + d4) - d3);
	} else {
		tmp = d1 * ((d2 + d4) - d1);
	}
	return tmp;
}

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	tmp = 0
	if (d3 <= -1500000000.0) or not (d3 <= 10500.0):
		tmp = d1 * ((d2 + d4) - d3)
	else:
		tmp = d1 * ((d2 + d4) - d1)
	return tmp

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	tmp = 0.0
	if ((d3 <= -1500000000.0) || !(d3 <= 10500.0))
		tmp = Float64(d1 * Float64(Float64(d2 + d4) - d3));
	else
		tmp = Float64(d1 * Float64(Float64(d2 + d4) - d1));
	end
	return tmp
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if ((d3 <= -1500000000.0) || ~((d3 <= 10500.0)))
		tmp = d1 * ((d2 + d4) - d3);
	else
		tmp = d1 * ((d2 + d4) - d1);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := If[Or[LessEqual[d3, -1500000000.0], N[Not[LessEqual[d3, 10500.0]], $MachinePrecision]], N[(d1 * N[(N[(d2 + d4), $MachinePrecision] - d3), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(N[(d2 + d4), $MachinePrecision] - d1), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d3 < -1.5e9 or 10500 < d3

   1. Initial program 80.3%

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

      1. associate--l+ 80.3%

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

      2. distribute-lft-out-- 84.0%

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

      3. distribute-rgt-out-- 87.1%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around 0 90.9%

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

   if -1.5e9 < d3 < 10500

   1. Initial program 89.5%

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

      1. associate--l+ 89.5%

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

      2. distribute-lft-out-- 89.5%

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

      3. distribute-rgt-out-- 93.5%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around 0 97.7%

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

4. Final simplification 94.2%

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

Alternative 7: 89.8% accurate, 0.9× speedup

Math

\[\begin{array}{l} [d1, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ \begin{array}{l} \mathbf{if}\;d3 \leq -1.9 \cdot 10^{+103}:\\ \;\;\;\;d1 \cdot \left(d2 - d3\right)\\ \mathbf{elif}\;d3 \leq 5 \cdot 10^{+161}:\\ \;\;\;\;d1 \cdot \left(\left(d2 + d4\right) - d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 - d3\right)\\ \end{array} \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d3 -1.9e+103)
   (* d1 (- d2 d3))
   (if (<= d3 5e+161) (* d1 (- (+ d2 d4) d1)) (* d1 (- d4 d3)))))

C

assert(d1 < d2 && d2 < d3 && d3 < d4);
double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d3 <= -1.9e+103) {
		tmp = d1 * (d2 - d3);
	} else if (d3 <= 5e+161) {
		tmp = d1 * ((d2 + d4) - d1);
	} else {
		tmp = d1 * (d4 - d3);
	}
	return tmp;
}

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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 (d3 <= (-1.9d+103)) then
        tmp = d1 * (d2 - d3)
    else if (d3 <= 5d+161) then
        tmp = d1 * ((d2 + d4) - d1)
    else
        tmp = d1 * (d4 - d3)
    end if
    code = tmp
end function

Java

assert d1 < d2 && d2 < d3 && d3 < d4;
public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d3 <= -1.9e+103) {
		tmp = d1 * (d2 - d3);
	} else if (d3 <= 5e+161) {
		tmp = d1 * ((d2 + d4) - d1);
	} else {
		tmp = d1 * (d4 - d3);
	}
	return tmp;
}

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	tmp = 0
	if d3 <= -1.9e+103:
		tmp = d1 * (d2 - d3)
	elif d3 <= 5e+161:
		tmp = d1 * ((d2 + d4) - d1)
	else:
		tmp = d1 * (d4 - d3)
	return tmp

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d3 <= -1.9e+103)
		tmp = Float64(d1 * Float64(d2 - d3));
	elseif (d3 <= 5e+161)
		tmp = Float64(d1 * Float64(Float64(d2 + d4) - d1));
	else
		tmp = Float64(d1 * Float64(d4 - d3));
	end
	return tmp
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d3 <= -1.9e+103)
		tmp = d1 * (d2 - d3);
	elseif (d3 <= 5e+161)
		tmp = d1 * ((d2 + d4) - d1);
	else
		tmp = d1 * (d4 - d3);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := If[LessEqual[d3, -1.9e+103], N[(d1 * N[(d2 - d3), $MachinePrecision]), $MachinePrecision], If[LessEqual[d3, 5e+161], N[(d1 * N[(N[(d2 + d4), $MachinePrecision] - d1), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(d4 - d3), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if d3 < -1.8999999999999998e103

   1. Initial program 81.4%

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

      1. associate--l+ 81.4%

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

      2. distribute-lft-out-- 86.0%

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

      3. distribute-rgt-out-- 88.3%

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

      4. distribute-lft-out 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in d1 around 0 93.0%

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

   6. Taylor expanded in d4 around 0 84.0%

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

   if -1.8999999999999998e103 < d3 < 4.9999999999999997e161

   1. Initial program 86.0%

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

      1. associate--l+ 86.0%

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

      2. distribute-lft-out-- 87.6%

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

      3. distribute-rgt-out-- 91.9%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around 0 90.4%

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

   if 4.9999999999999997e161 < d3

   1. Initial program 81.5%

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

      1. associate--l+ 81.5%

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

      2. distribute-lft-out-- 81.5%

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

      3. distribute-rgt-out-- 81.5%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around 0 89.4%

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

      1. associate--r+ 89.4%

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

   7. Simplified 89.4%

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

   8. Taylor expanded in d1 around 0 89.4%

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

Alternative 8: 67.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} [d1, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ \begin{array}{l} \mathbf{if}\;d3 \leq -1.18 \cdot 10^{+170} \lor \neg \left(d3 \leq 3.6 \cdot 10^{+126}\right):\\ \;\;\;\;d1 \cdot \left(-d3\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d2 + d4\right)\\ \end{array} \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (or (<= d3 -1.18e+170) (not (<= d3 3.6e+126)))
   (* d1 (- d3))
   (* d1 (+ d2 d4))))

C

assert(d1 < d2 && d2 < d3 && d3 < d4);
double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if ((d3 <= -1.18e+170) || !(d3 <= 3.6e+126)) {
		tmp = d1 * -d3;
	} else {
		tmp = d1 * (d2 + d4);
	}
	return tmp;
}

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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 ((d3 <= (-1.18d+170)) .or. (.not. (d3 <= 3.6d+126))) then
        tmp = d1 * -d3
    else
        tmp = d1 * (d2 + d4)
    end if
    code = tmp
end function

Java

assert d1 < d2 && d2 < d3 && d3 < d4;
public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if ((d3 <= -1.18e+170) || !(d3 <= 3.6e+126)) {
		tmp = d1 * -d3;
	} else {
		tmp = d1 * (d2 + d4);
	}
	return tmp;
}

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	tmp = 0
	if (d3 <= -1.18e+170) or not (d3 <= 3.6e+126):
		tmp = d1 * -d3
	else:
		tmp = d1 * (d2 + d4)
	return tmp

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	tmp = 0.0
	if ((d3 <= -1.18e+170) || !(d3 <= 3.6e+126))
		tmp = Float64(d1 * Float64(-d3));
	else
		tmp = Float64(d1 * Float64(d2 + d4));
	end
	return tmp
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if ((d3 <= -1.18e+170) || ~((d3 <= 3.6e+126)))
		tmp = d1 * -d3;
	else
		tmp = d1 * (d2 + d4);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := If[Or[LessEqual[d3, -1.18e+170], N[Not[LessEqual[d3, 3.6e+126]], $MachinePrecision]], N[(d1 * (-d3)), $MachinePrecision], N[(d1 * N[(d2 + d4), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d3 < -1.18e170 or 3.6e126 < d3

   1. Initial program 80.6%

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

      1. associate--l+ 80.6%

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

      2. distribute-lft-out-- 83.6%

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

      3. distribute-rgt-out-- 85.1%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around inf 76.6%

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

      1. mul-1-neg 76.6%

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

      2. distribute-rgt-neg-out 76.6%

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

   7. Simplified 76.6%

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

   if -1.18e170 < d3 < 3.6e126

   1. Initial program 86.2%

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

      1. associate--l+ 86.2%

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

      2. distribute-lft-out-- 87.8%

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

      3. distribute-rgt-out-- 92.0%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around 0 89.0%

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

   6. Taylor expanded in d1 around 0 66.0%

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

4. Final simplification 68.8%

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

Alternative 9: 74.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} [d1, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ \begin{array}{l} \mathbf{if}\;d4 \leq 1.45 \cdot 10^{+37}:\\ \;\;\;\;d1 \cdot \left(d2 - d3\right)\\ \mathbf{elif}\;d4 \leq 7.2 \cdot 10^{+106}:\\ \;\;\;\;d1 \cdot \left(d4 - d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 - d3\right)\\ \end{array} \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d4 1.45e+37)
   (* d1 (- d2 d3))
   (if (<= d4 7.2e+106) (* d1 (- d4 d1)) (* d1 (- d4 d3)))))

C

assert(d1 < d2 && d2 < d3 && d3 < d4);
double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 1.45e+37) {
		tmp = d1 * (d2 - d3);
	} else if (d4 <= 7.2e+106) {
		tmp = d1 * (d4 - d1);
	} else {
		tmp = d1 * (d4 - d3);
	}
	return tmp;
}

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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.45d+37) then
        tmp = d1 * (d2 - d3)
    else if (d4 <= 7.2d+106) then
        tmp = d1 * (d4 - d1)
    else
        tmp = d1 * (d4 - d3)
    end if
    code = tmp
end function

Java

assert d1 < d2 && d2 < d3 && d3 < d4;
public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 1.45e+37) {
		tmp = d1 * (d2 - d3);
	} else if (d4 <= 7.2e+106) {
		tmp = d1 * (d4 - d1);
	} else {
		tmp = d1 * (d4 - d3);
	}
	return tmp;
}

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	tmp = 0
	if d4 <= 1.45e+37:
		tmp = d1 * (d2 - d3)
	elif d4 <= 7.2e+106:
		tmp = d1 * (d4 - d1)
	else:
		tmp = d1 * (d4 - d3)
	return tmp

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= 1.45e+37)
		tmp = Float64(d1 * Float64(d2 - d3));
	elseif (d4 <= 7.2e+106)
		tmp = Float64(d1 * Float64(d4 - d1));
	else
		tmp = Float64(d1 * Float64(d4 - d3));
	end
	return tmp
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d4 <= 1.45e+37)
		tmp = d1 * (d2 - d3);
	elseif (d4 <= 7.2e+106)
		tmp = d1 * (d4 - d1);
	else
		tmp = d1 * (d4 - d3);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := If[LessEqual[d4, 1.45e+37], N[(d1 * N[(d2 - d3), $MachinePrecision]), $MachinePrecision], If[LessEqual[d4, 7.2e+106], N[(d1 * N[(d4 - d1), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(d4 - d3), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if d4 < 1.44999999999999989e37

   1. Initial program 84.8%

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

      1. associate--l+ 84.8%

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

      2. distribute-lft-out-- 87.3%

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

      3. distribute-rgt-out-- 88.9%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around 0 77.2%

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

   6. Taylor expanded in d4 around 0 63.2%

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

   if 1.44999999999999989e37 < d4 < 7.2000000000000002e106

   1. Initial program 94.0%

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

      1. associate--l+ 94.0%

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

      2. distribute-lft-out-- 94.0%

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

      3. distribute-rgt-out-- 94.1%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around 0 84.1%

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

   6. Taylor expanded in d2 around 0 61.5%

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

   if 7.2000000000000002e106 < d4

   1. Initial program 80.4%

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

      1. associate--l+ 80.4%

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

      2. distribute-lft-out-- 80.4%

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

      3. distribute-rgt-out-- 95.0%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around 0 87.0%

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

      1. associate--r+ 87.0%

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

   7. Simplified 87.0%

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

   8. Taylor expanded in d1 around 0 87.0%

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

Alternative 10: 53.4% accurate, 1.1× speedup

Math

\[\begin{array}{l} [d1, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ \begin{array}{l} \mathbf{if}\;d4 \leq -4.7 \cdot 10^{-256}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{elif}\;d4 \leq 3.5 \cdot 10^{+104}:\\ \;\;\;\;d1 \cdot \left(-d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot d4\\ \end{array} \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d4 -4.7e-256)
   (* d1 d2)
   (if (<= d4 3.5e+104) (* d1 (- d1)) (* d1 d4))))

C

assert(d1 < d2 && d2 < d3 && d3 < d4);
double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= -4.7e-256) {
		tmp = d1 * d2;
	} else if (d4 <= 3.5e+104) {
		tmp = d1 * -d1;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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.7d-256)) then
        tmp = d1 * d2
    else if (d4 <= 3.5d+104) then
        tmp = d1 * -d1
    else
        tmp = d1 * d4
    end if
    code = tmp
end function

Java

assert d1 < d2 && d2 < d3 && d3 < d4;
public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= -4.7e-256) {
		tmp = d1 * d2;
	} else if (d4 <= 3.5e+104) {
		tmp = d1 * -d1;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	tmp = 0
	if d4 <= -4.7e-256:
		tmp = d1 * d2
	elif d4 <= 3.5e+104:
		tmp = d1 * -d1
	else:
		tmp = d1 * d4
	return tmp

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= -4.7e-256)
		tmp = Float64(d1 * d2);
	elseif (d4 <= 3.5e+104)
		tmp = Float64(d1 * Float64(-d1));
	else
		tmp = Float64(d1 * d4);
	end
	return tmp
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d4 <= -4.7e-256)
		tmp = d1 * d2;
	elseif (d4 <= 3.5e+104)
		tmp = d1 * -d1;
	else
		tmp = d1 * d4;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := If[LessEqual[d4, -4.7e-256], N[(d1 * d2), $MachinePrecision], If[LessEqual[d4, 3.5e+104], N[(d1 * (-d1)), $MachinePrecision], N[(d1 * d4), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if d4 < -4.69999999999999982e-256

   1. Initial program 83.0%

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

      1. associate--l+ 83.0%

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

      2. distribute-lft-out-- 85.6%

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

      3. distribute-rgt-out-- 88.1%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around inf 37.2%

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

   if -4.69999999999999982e-256 < d4 < 3.5000000000000002e104

   1. Initial program 88.6%

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

      1. associate--l+ 88.6%

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

      2. distribute-lft-out-- 90.7%

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

      3. distribute-rgt-out-- 90.7%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around inf 40.6%

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

      1. neg-mul-1 40.6%

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

   7. Simplified 40.6%

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

   if 3.5000000000000002e104 < d4

   1. Initial program 80.4%

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

      1. associate--l+ 80.4%

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

      2. distribute-lft-out-- 80.4%

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

      3. distribute-rgt-out-- 95.0%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d4 around inf 66.4%

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

Alternative 11: 92.5% accurate, 1.2× speedup

Math

\[\begin{array}{l} [d1, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ \begin{array}{l} \mathbf{if}\;d2 \leq -3.1 \cdot 10^{+128}:\\ \;\;\;\;d1 \cdot \left(\left(d2 + d4\right) - d3\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(\left(d4 - d1\right) - d3\right)\\ \end{array} \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d2 -3.1e+128) (* d1 (- (+ d2 d4) d3)) (* d1 (- (- d4 d1) d3))))

C

assert(d1 < d2 && d2 < d3 && d3 < d4);
double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d2 <= -3.1e+128) {
		tmp = d1 * ((d2 + d4) - d3);
	} else {
		tmp = d1 * ((d4 - d1) - d3);
	}
	return tmp;
}

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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 (d2 <= (-3.1d+128)) then
        tmp = d1 * ((d2 + d4) - d3)
    else
        tmp = d1 * ((d4 - d1) - d3)
    end if
    code = tmp
end function

Java

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

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	tmp = 0
	if d2 <= -3.1e+128:
		tmp = d1 * ((d2 + d4) - d3)
	else:
		tmp = d1 * ((d4 - d1) - d3)
	return tmp

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d2 <= -3.1e+128)
		tmp = Float64(d1 * Float64(Float64(d2 + d4) - d3));
	else
		tmp = Float64(d1 * Float64(Float64(d4 - d1) - d3));
	end
	return tmp
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d2 <= -3.1e+128)
		tmp = d1 * ((d2 + d4) - d3);
	else
		tmp = d1 * ((d4 - d1) - d3);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := If[LessEqual[d2, -3.1e+128], N[(d1 * N[(N[(d2 + d4), $MachinePrecision] - d3), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(N[(d4 - d1), $MachinePrecision] - d3), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d2 < -3.10000000000000004e128

   1. Initial program 77.7%

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

      1. associate--l+ 77.7%

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

      2. distribute-lft-out-- 86.0%

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

      3. distribute-rgt-out-- 86.0%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around 0 94.4%

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

   if -3.10000000000000004e128 < d2

   1. Initial program 85.9%

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

      1. associate--l+ 85.9%

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

      2. distribute-lft-out-- 86.8%

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

      3. distribute-rgt-out-- 90.9%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around 0 82.3%

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

      1. associate--r+ 82.3%

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

   7. Simplified 82.3%

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

Alternative 12: 72.0% accurate, 1.5× speedup

Math

\[\begin{array}{l} [d1, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ \begin{array}{l} \mathbf{if}\;d4 \leq 1.06 \cdot 10^{+47}:\\ \;\;\;\;d1 \cdot \left(d2 - d3\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d2 + d4\right)\\ \end{array} \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d4 1.06e+47) (* d1 (- d2 d3)) (* d1 (+ d2 d4))))

C

assert(d1 < d2 && d2 < d3 && d3 < d4);
double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 1.06e+47) {
		tmp = d1 * (d2 - d3);
	} else {
		tmp = d1 * (d2 + d4);
	}
	return tmp;
}

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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.06d+47) then
        tmp = d1 * (d2 - d3)
    else
        tmp = d1 * (d2 + d4)
    end if
    code = tmp
end function

Java

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

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	tmp = 0
	if d4 <= 1.06e+47:
		tmp = d1 * (d2 - d3)
	else:
		tmp = d1 * (d2 + d4)
	return tmp

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= 1.06e+47)
		tmp = Float64(d1 * Float64(d2 - d3));
	else
		tmp = Float64(d1 * Float64(d2 + d4));
	end
	return tmp
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d4 <= 1.06e+47)
		tmp = d1 * (d2 - d3);
	else
		tmp = d1 * (d2 + d4);
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := If[LessEqual[d4, 1.06e+47], N[(d1 * N[(d2 - d3), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(d2 + d4), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d4 < 1.05999999999999996e47

   1. Initial program 84.7%

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

      1. associate--l+ 84.7%

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

      2. distribute-lft-out-- 87.2%

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

      3. distribute-rgt-out-- 88.6%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around 0 76.8%

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

   6. Taylor expanded in d4 around 0 62.7%

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

   if 1.05999999999999996e47 < d4

   1. Initial program 84.8%

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

      1. associate--l+ 84.8%

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

      2. distribute-lft-out-- 84.8%

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

      3. distribute-rgt-out-- 96.2%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around 0 81.9%

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

   6. Taylor expanded in d1 around 0 77.5%

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

Alternative 13: 49.8% accurate, 1.9× speedup

Math

\[\begin{array}{l} [d1, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ \begin{array}{l} \mathbf{if}\;d4 \leq 1.65 \cdot 10^{+32}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot d4\\ \end{array} \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d4 1.65e+32) (* d1 d2) (* d1 d4)))

C

assert(d1 < d2 && d2 < d3 && d3 < d4);
double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 1.65e+32) {
		tmp = d1 * d2;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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.65d+32) then
        tmp = d1 * d2
    else
        tmp = d1 * d4
    end if
    code = tmp
end function

Java

assert d1 < d2 && d2 < d3 && d3 < d4;
public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 1.65e+32) {
		tmp = d1 * d2;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	tmp = 0
	if d4 <= 1.65e+32:
		tmp = d1 * d2
	else:
		tmp = d1 * d4
	return tmp

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= 1.65e+32)
		tmp = Float64(d1 * d2);
	else
		tmp = Float64(d1 * d4);
	end
	return tmp
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d4 <= 1.65e+32)
		tmp = d1 * d2;
	else
		tmp = d1 * d4;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := If[LessEqual[d4, 1.65e+32], N[(d1 * d2), $MachinePrecision], N[(d1 * d4), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d4 < 1.6500000000000001e32

   1. Initial program 85.3%

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

      1. associate--l+ 85.3%

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

      2. distribute-lft-out-- 87.8%

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

      3. distribute-rgt-out-- 89.3%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around inf 35.9%

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

   if 1.6500000000000001e32 < d4

   1. Initial program 83.0%

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

      1. associate--l+ 83.0%

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

      2. distribute-lft-out-- 83.0%

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

      3. distribute-rgt-out-- 93.2%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d4 around inf 56.8%

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

Alternative 14: 30.8% accurate, 1.9× speedup

Math

\[\begin{array}{l} [d1, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ \begin{array}{l} \mathbf{if}\;d2 \leq -1.15 \cdot 10^{-263}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot d1\\ \end{array} \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d2 -1.15e-263) (* d1 d2) (* d1 d1)))

C

assert(d1 < d2 && d2 < d3 && d3 < d4);
double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d2 <= -1.15e-263) {
		tmp = d1 * d2;
	} else {
		tmp = d1 * d1;
	}
	return tmp;
}

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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 (d2 <= (-1.15d-263)) then
        tmp = d1 * d2
    else
        tmp = d1 * d1
    end if
    code = tmp
end function

Java

assert d1 < d2 && d2 < d3 && d3 < d4;
public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d2 <= -1.15e-263) {
		tmp = d1 * d2;
	} else {
		tmp = d1 * d1;
	}
	return tmp;
}

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	tmp = 0
	if d2 <= -1.15e-263:
		tmp = d1 * d2
	else:
		tmp = d1 * d1
	return tmp

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d2 <= -1.15e-263)
		tmp = Float64(d1 * d2);
	else
		tmp = Float64(d1 * d1);
	end
	return tmp
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d2 <= -1.15e-263)
		tmp = d1 * d2;
	else
		tmp = d1 * d1;
	end
	tmp_2 = tmp;
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := If[LessEqual[d2, -1.15e-263], N[(d1 * d2), $MachinePrecision], N[(d1 * d1), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d2 < -1.15000000000000001e-263

   1. Initial program 83.4%

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

      1. associate--l+ 83.4%

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

      2. distribute-lft-out-- 86.2%

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

      3. distribute-rgt-out-- 88.0%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around inf 36.3%

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

   if -1.15000000000000001e-263 < d2

   1. Initial program 85.7%

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

      1. associate--l+ 85.7%

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

      2. distribute-lft-out-- 87.1%

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

      3. distribute-rgt-out-- 91.8%

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

      4. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d1 around inf 28.1%

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

      1. neg-mul-1 28.1%

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

   7. Simplified 28.1%

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

      1. neg-sub0 28.1%

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

      2. sub-neg 28.1%

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

      3. add-sqr-sqrt 12.9%

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

      4. sqrt-unprod 21.0%

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

      5. sqr-neg 21.0%

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

      6. sqrt-unprod 8.0%

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

      7. add-sqr-sqrt 10.4%

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

   9. Applied egg-rr 10.4%

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

       1. +-lft-identity 10.4%

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

   11. Simplified 10.4%

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

Alternative 15: 7.9% accurate, 5.0× speedup

Math

\[\begin{array}{l} [d1, d2, d3, d4] = \mathsf{sort}([d1, d2, d3, d4])\\ \\ d1 \cdot d1 \end{array} \]

FPCore

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
(FPCore (d1 d2 d3 d4) :precision binary64 (* d1 d1))

C

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

Fortran

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
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

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

Python

[d1, d2, d3, d4] = sort([d1, d2, d3, d4])
def code(d1, d2, d3, d4):
	return d1 * d1

Julia

d1, d2, d3, d4 = sort([d1, d2, d3, d4])
function code(d1, d2, d3, d4)
	return Float64(d1 * d1)
end

MATLAB

d1, d2, d3, d4 = num2cell(sort([d1, d2, d3, d4])){:}
function tmp = code(d1, d2, d3, d4)
	tmp = d1 * d1;
end

Wolfram

NOTE: d1, d2, d3, and d4 should be sorted in increasing order before calling this function.
code[d1_, d2_, d3_, d4_] := N[(d1 * d1), $MachinePrecision]

Derivation

1. Initial program 84.7%

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

   1. associate--l+ 84.7%

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

   2. distribute-lft-out-- 86.7%

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

   3. distribute-rgt-out-- 90.2%

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

   4. distribute-lft-out 100.0%

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

3. Simplified 100.0%

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

5. Taylor expanded in d1 around inf 29.9%

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

   1. neg-mul-1 29.9%

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

7. Simplified 29.9%

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

   1. neg-sub0 29.9%

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

   2. sub-neg 29.9%

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

   3. add-sqr-sqrt 13.3%

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

   4. sqrt-unprod 19.1%

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

   5. sqr-neg 19.1%

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

   6. sqrt-unprod 5.8%

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

   7. add-sqr-sqrt 10.3%

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

9. Applied egg-rr 10.3%

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

    1. +-lft-identity 10.3%

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

11. Simplified 10.3%

    \[\leadsto d1 \cdot \color{blue}{d1} \]
12. 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 2024110 
(FPCore (d1 d2 d3 d4)
  :name "FastMath dist4"
  :precision binary64

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

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