FastMath dist4

Percentage Accurate: 88.0% → 100.0%

Time: 6.5s

Alternatives: 13

Speedup: 1.7×

• 32.9% 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.0% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 1.7× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 2: 62.7% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := d1 \cdot \left(d2 - d3\right)\\ \mathbf{if}\;d4 \leq 2.85 \cdot 10^{-213}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d4 \leq 2.5 \cdot 10^{+84}:\\ \;\;\;\;d1 \cdot \left(d2 - d1\right)\\ \mathbf{elif}\;d4 \leq 3.8 \cdot 10^{+117}:\\ \;\;\;\;d1 \cdot d4\\ \mathbf{elif}\;d4 \leq 1.15 \cdot 10^{+139}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 + d2\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (let* ((t_0 (* d1 (- d2 d3))))
   (if (<= d4 2.85e-213)
     t_0
     (if (<= d4 2.5e+84)
       (* d1 (- d2 d1))
       (if (<= d4 3.8e+117)
         (* d1 d4)
         (if (<= d4 1.15e+139) t_0 (* d1 (+ d4 d2))))))))

C

double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * (d2 - d3);
	double tmp;
	if (d4 <= 2.85e-213) {
		tmp = t_0;
	} else if (d4 <= 2.5e+84) {
		tmp = d1 * (d2 - d1);
	} else if (d4 <= 3.8e+117) {
		tmp = d1 * d4;
	} else if (d4 <= 1.15e+139) {
		tmp = t_0;
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    real(8) :: t_0
    real(8) :: tmp
    t_0 = d1 * (d2 - d3)
    if (d4 <= 2.85d-213) then
        tmp = t_0
    else if (d4 <= 2.5d+84) then
        tmp = d1 * (d2 - d1)
    else if (d4 <= 3.8d+117) then
        tmp = d1 * d4
    else if (d4 <= 1.15d+139) then
        tmp = t_0
    else
        tmp = d1 * (d4 + d2)
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * (d2 - d3);
	double tmp;
	if (d4 <= 2.85e-213) {
		tmp = t_0;
	} else if (d4 <= 2.5e+84) {
		tmp = d1 * (d2 - d1);
	} else if (d4 <= 3.8e+117) {
		tmp = d1 * d4;
	} else if (d4 <= 1.15e+139) {
		tmp = t_0;
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	t_0 = d1 * (d2 - d3)
	tmp = 0
	if d4 <= 2.85e-213:
		tmp = t_0
	elif d4 <= 2.5e+84:
		tmp = d1 * (d2 - d1)
	elif d4 <= 3.8e+117:
		tmp = d1 * d4
	elif d4 <= 1.15e+139:
		tmp = t_0
	else:
		tmp = d1 * (d4 + d2)
	return tmp

Julia

function code(d1, d2, d3, d4)
	t_0 = Float64(d1 * Float64(d2 - d3))
	tmp = 0.0
	if (d4 <= 2.85e-213)
		tmp = t_0;
	elseif (d4 <= 2.5e+84)
		tmp = Float64(d1 * Float64(d2 - d1));
	elseif (d4 <= 3.8e+117)
		tmp = Float64(d1 * d4);
	elseif (d4 <= 1.15e+139)
		tmp = t_0;
	else
		tmp = Float64(d1 * Float64(d4 + d2));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	t_0 = d1 * (d2 - d3);
	tmp = 0.0;
	if (d4 <= 2.85e-213)
		tmp = t_0;
	elseif (d4 <= 2.5e+84)
		tmp = d1 * (d2 - d1);
	elseif (d4 <= 3.8e+117)
		tmp = d1 * d4;
	elseif (d4 <= 1.15e+139)
		tmp = t_0;
	else
		tmp = d1 * (d4 + d2);
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := Block[{t$95$0 = N[(d1 * N[(d2 - d3), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d4, 2.85e-213], t$95$0, If[LessEqual[d4, 2.5e+84], N[(d1 * N[(d2 - d1), $MachinePrecision]), $MachinePrecision], If[LessEqual[d4, 3.8e+117], N[(d1 * d4), $MachinePrecision], If[LessEqual[d4, 1.15e+139], t$95$0, N[(d1 * N[(d4 + d2), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 3: 63.1% accurate, 1.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := d1 \cdot \left(d2 - d3\right)\\ \mathbf{if}\;d4 \leq 1.22 \cdot 10^{-214}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d4 \leq 7000:\\ \;\;\;\;d1 \cdot \left(d2 - d1\right)\\ \mathbf{elif}\;d4 \leq 2.4 \cdot 10^{+131}:\\ \;\;\;\;d1 \cdot \left(d4 - d1\right)\\ \mathbf{elif}\;d4 \leq 1.1 \cdot 10^{+139}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 + d2\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (let* ((t_0 (* d1 (- d2 d3))))
   (if (<= d4 1.22e-214)
     t_0
     (if (<= d4 7000.0)
       (* d1 (- d2 d1))
       (if (<= d4 2.4e+131)
         (* d1 (- d4 d1))
         (if (<= d4 1.1e+139) t_0 (* d1 (+ d4 d2))))))))

C

double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * (d2 - d3);
	double tmp;
	if (d4 <= 1.22e-214) {
		tmp = t_0;
	} else if (d4 <= 7000.0) {
		tmp = d1 * (d2 - d1);
	} else if (d4 <= 2.4e+131) {
		tmp = d1 * (d4 - d1);
	} else if (d4 <= 1.1e+139) {
		tmp = t_0;
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    real(8) :: t_0
    real(8) :: tmp
    t_0 = d1 * (d2 - d3)
    if (d4 <= 1.22d-214) then
        tmp = t_0
    else if (d4 <= 7000.0d0) then
        tmp = d1 * (d2 - d1)
    else if (d4 <= 2.4d+131) then
        tmp = d1 * (d4 - d1)
    else if (d4 <= 1.1d+139) then
        tmp = t_0
    else
        tmp = d1 * (d4 + d2)
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * (d2 - d3);
	double tmp;
	if (d4 <= 1.22e-214) {
		tmp = t_0;
	} else if (d4 <= 7000.0) {
		tmp = d1 * (d2 - d1);
	} else if (d4 <= 2.4e+131) {
		tmp = d1 * (d4 - d1);
	} else if (d4 <= 1.1e+139) {
		tmp = t_0;
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	t_0 = d1 * (d2 - d3)
	tmp = 0
	if d4 <= 1.22e-214:
		tmp = t_0
	elif d4 <= 7000.0:
		tmp = d1 * (d2 - d1)
	elif d4 <= 2.4e+131:
		tmp = d1 * (d4 - d1)
	elif d4 <= 1.1e+139:
		tmp = t_0
	else:
		tmp = d1 * (d4 + d2)
	return tmp

Julia

function code(d1, d2, d3, d4)
	t_0 = Float64(d1 * Float64(d2 - d3))
	tmp = 0.0
	if (d4 <= 1.22e-214)
		tmp = t_0;
	elseif (d4 <= 7000.0)
		tmp = Float64(d1 * Float64(d2 - d1));
	elseif (d4 <= 2.4e+131)
		tmp = Float64(d1 * Float64(d4 - d1));
	elseif (d4 <= 1.1e+139)
		tmp = t_0;
	else
		tmp = Float64(d1 * Float64(d4 + d2));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	t_0 = d1 * (d2 - d3);
	tmp = 0.0;
	if (d4 <= 1.22e-214)
		tmp = t_0;
	elseif (d4 <= 7000.0)
		tmp = d1 * (d2 - d1);
	elseif (d4 <= 2.4e+131)
		tmp = d1 * (d4 - d1);
	elseif (d4 <= 1.1e+139)
		tmp = t_0;
	else
		tmp = d1 * (d4 + d2);
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := Block[{t$95$0 = N[(d1 * N[(d2 - d3), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d4, 1.22e-214], t$95$0, If[LessEqual[d4, 7000.0], N[(d1 * N[(d2 - d1), $MachinePrecision]), $MachinePrecision], If[LessEqual[d4, 2.4e+131], N[(d1 * N[(d4 - d1), $MachinePrecision]), $MachinePrecision], If[LessEqual[d4, 1.1e+139], t$95$0, N[(d1 * N[(d4 + d2), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 60.5% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := d1 \cdot \left(d2 - d1\right)\\ \mathbf{if}\;d4 \leq -4 \cdot 10^{-153}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d4 \leq -1.05 \cdot 10^{-277}:\\ \;\;\;\;d3 \cdot \left(-d1\right)\\ \mathbf{elif}\;d4 \leq 1.3 \cdot 10^{+86}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 + d2\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (let* ((t_0 (* d1 (- d2 d1))))
   (if (<= d4 -4e-153)
     t_0
     (if (<= d4 -1.05e-277)
       (* d3 (- d1))
       (if (<= d4 1.3e+86) t_0 (* d1 (+ d4 d2)))))))

C

double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * (d2 - d1);
	double tmp;
	if (d4 <= -4e-153) {
		tmp = t_0;
	} else if (d4 <= -1.05e-277) {
		tmp = d3 * -d1;
	} else if (d4 <= 1.3e+86) {
		tmp = t_0;
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    real(8) :: t_0
    real(8) :: tmp
    t_0 = d1 * (d2 - d1)
    if (d4 <= (-4d-153)) then
        tmp = t_0
    else if (d4 <= (-1.05d-277)) then
        tmp = d3 * -d1
    else if (d4 <= 1.3d+86) then
        tmp = t_0
    else
        tmp = d1 * (d4 + d2)
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * (d2 - d1);
	double tmp;
	if (d4 <= -4e-153) {
		tmp = t_0;
	} else if (d4 <= -1.05e-277) {
		tmp = d3 * -d1;
	} else if (d4 <= 1.3e+86) {
		tmp = t_0;
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	t_0 = d1 * (d2 - d1)
	tmp = 0
	if d4 <= -4e-153:
		tmp = t_0
	elif d4 <= -1.05e-277:
		tmp = d3 * -d1
	elif d4 <= 1.3e+86:
		tmp = t_0
	else:
		tmp = d1 * (d4 + d2)
	return tmp

Julia

function code(d1, d2, d3, d4)
	t_0 = Float64(d1 * Float64(d2 - d1))
	tmp = 0.0
	if (d4 <= -4e-153)
		tmp = t_0;
	elseif (d4 <= -1.05e-277)
		tmp = Float64(d3 * Float64(-d1));
	elseif (d4 <= 1.3e+86)
		tmp = t_0;
	else
		tmp = Float64(d1 * Float64(d4 + d2));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	t_0 = d1 * (d2 - d1);
	tmp = 0.0;
	if (d4 <= -4e-153)
		tmp = t_0;
	elseif (d4 <= -1.05e-277)
		tmp = d3 * -d1;
	elseif (d4 <= 1.3e+86)
		tmp = t_0;
	else
		tmp = d1 * (d4 + d2);
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := Block[{t$95$0 = N[(d1 * N[(d2 - d1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d4, -4e-153], t$95$0, If[LessEqual[d4, -1.05e-277], N[(d3 * (-d1)), $MachinePrecision], If[LessEqual[d4, 1.3e+86], t$95$0, N[(d1 * N[(d4 + d2), $MachinePrecision]), $MachinePrecision]]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 63.7% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d2 \leq -7.5 \cdot 10^{+49}:\\ \;\;\;\;d1 \cdot \left(d2 - d3\right)\\ \mathbf{elif}\;d2 \leq -2.2 \cdot 10^{-126}:\\ \;\;\;\;d1 \cdot \left(\left(-d1\right) - d3\right)\\ \mathbf{elif}\;d2 \leq -1.65 \cdot 10^{-257}:\\ \;\;\;\;d1 \cdot \left(d4 - d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 - d3\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d2 -7.5e+49)
   (* d1 (- d2 d3))
   (if (<= d2 -2.2e-126)
     (* d1 (- (- d1) d3))
     (if (<= d2 -1.65e-257) (* d1 (- d4 d1)) (* d1 (- d4 d3))))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d2 <= -7.5e+49) {
		tmp = d1 * (d2 - d3);
	} else if (d2 <= -2.2e-126) {
		tmp = d1 * (-d1 - d3);
	} else if (d2 <= -1.65e-257) {
		tmp = d1 * (d4 - d1);
	} else {
		tmp = d1 * (d4 - d3);
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    real(8) :: tmp
    if (d2 <= (-7.5d+49)) then
        tmp = d1 * (d2 - d3)
    else if (d2 <= (-2.2d-126)) then
        tmp = d1 * (-d1 - d3)
    else if (d2 <= (-1.65d-257)) then
        tmp = d1 * (d4 - d1)
    else
        tmp = d1 * (d4 - d3)
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d2 <= -7.5e+49) {
		tmp = d1 * (d2 - d3);
	} else if (d2 <= -2.2e-126) {
		tmp = d1 * (-d1 - d3);
	} else if (d2 <= -1.65e-257) {
		tmp = d1 * (d4 - d1);
	} else {
		tmp = d1 * (d4 - d3);
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d2 <= -7.5e+49:
		tmp = d1 * (d2 - d3)
	elif d2 <= -2.2e-126:
		tmp = d1 * (-d1 - d3)
	elif d2 <= -1.65e-257:
		tmp = d1 * (d4 - d1)
	else:
		tmp = d1 * (d4 - d3)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d2 <= -7.5e+49)
		tmp = Float64(d1 * Float64(d2 - d3));
	elseif (d2 <= -2.2e-126)
		tmp = Float64(d1 * Float64(Float64(-d1) - d3));
	elseif (d2 <= -1.65e-257)
		tmp = Float64(d1 * Float64(d4 - d1));
	else
		tmp = Float64(d1 * Float64(d4 - d3));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d2 <= -7.5e+49)
		tmp = d1 * (d2 - d3);
	elseif (d2 <= -2.2e-126)
		tmp = d1 * (-d1 - d3);
	elseif (d2 <= -1.65e-257)
		tmp = d1 * (d4 - d1);
	else
		tmp = d1 * (d4 - d3);
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := If[LessEqual[d2, -7.5e+49], N[(d1 * N[(d2 - d3), $MachinePrecision]), $MachinePrecision], If[LessEqual[d2, -2.2e-126], N[(d1 * N[((-d1) - d3), $MachinePrecision]), $MachinePrecision], If[LessEqual[d2, -1.65e-257], N[(d1 * N[(d4 - d1), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(d4 - d3), $MachinePrecision]), $MachinePrecision]]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 93.4% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d3 \leq -3.4 \cdot 10^{+78} \lor \neg \left(d3 \leq 5.3 \cdot 10^{+85}\right):\\ \;\;\;\;d1 \cdot \left(\left(d4 + d2\right) - d3\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(\left(d4 + d2\right) - d1\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (or (<= d3 -3.4e+78) (not (<= d3 5.3e+85)))
   (* d1 (- (+ d4 d2) d3))
   (* d1 (- (+ d4 d2) d1))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if ((d3 <= -3.4e+78) || !(d3 <= 5.3e+85)) {
		tmp = d1 * ((d4 + d2) - d3);
	} else {
		tmp = d1 * ((d4 + d2) - d1);
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    real(8) :: tmp
    if ((d3 <= (-3.4d+78)) .or. (.not. (d3 <= 5.3d+85))) then
        tmp = d1 * ((d4 + d2) - d3)
    else
        tmp = d1 * ((d4 + d2) - d1)
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if ((d3 <= -3.4e+78) || !(d3 <= 5.3e+85)) {
		tmp = d1 * ((d4 + d2) - d3);
	} else {
		tmp = d1 * ((d4 + d2) - d1);
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if (d3 <= -3.4e+78) or not (d3 <= 5.3e+85):
		tmp = d1 * ((d4 + d2) - d3)
	else:
		tmp = d1 * ((d4 + d2) - d1)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if ((d3 <= -3.4e+78) || !(d3 <= 5.3e+85))
		tmp = Float64(d1 * Float64(Float64(d4 + d2) - d3));
	else
		tmp = Float64(d1 * Float64(Float64(d4 + d2) - d1));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if ((d3 <= -3.4e+78) || ~((d3 <= 5.3e+85)))
		tmp = d1 * ((d4 + d2) - d3);
	else
		tmp = d1 * ((d4 + d2) - d1);
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := If[Or[LessEqual[d3, -3.4e+78], N[Not[LessEqual[d3, 5.3e+85]], $MachinePrecision]], N[(d1 * N[(N[(d4 + d2), $MachinePrecision] - d3), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(N[(d4 + d2), $MachinePrecision] - d1), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 88.7% accurate, 1.3× speedup

Math

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

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d3 -5.5e+79)
   (* d1 (- d2 d3))
   (if (<= d3 2.45e+97) (* d1 (- (+ d4 d2) d1)) (* d1 (- d4 d3)))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d3 <= -5.5e+79) {
		tmp = d1 * (d2 - d3);
	} else if (d3 <= 2.45e+97) {
		tmp = d1 * ((d4 + d2) - d1);
	} else {
		tmp = d1 * (d4 - d3);
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    real(8) :: tmp
    if (d3 <= (-5.5d+79)) then
        tmp = d1 * (d2 - d3)
    else if (d3 <= 2.45d+97) then
        tmp = d1 * ((d4 + d2) - d1)
    else
        tmp = d1 * (d4 - d3)
    end if
    code = tmp
end function

Java

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

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d3 <= -5.5e+79:
		tmp = d1 * (d2 - d3)
	elif d3 <= 2.45e+97:
		tmp = d1 * ((d4 + d2) - d1)
	else:
		tmp = d1 * (d4 - d3)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d3 <= -5.5e+79)
		tmp = Float64(d1 * Float64(d2 - d3));
	elseif (d3 <= 2.45e+97)
		tmp = Float64(d1 * Float64(Float64(d4 + d2) - d1));
	else
		tmp = Float64(d1 * Float64(d4 - d3));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d3 <= -5.5e+79)
		tmp = d1 * (d2 - d3);
	elseif (d3 <= 2.45e+97)
		tmp = d1 * ((d4 + d2) - d1);
	else
		tmp = d1 * (d4 - d3);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 66.9% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d3 \leq -1 \cdot 10^{+186} \lor \neg \left(d3 \leq 9.2 \cdot 10^{+190}\right):\\ \;\;\;\;d3 \cdot \left(-d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 + d2\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (or (<= d3 -1e+186) (not (<= d3 9.2e+190)))
   (* d3 (- d1))
   (* d1 (+ d4 d2))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if ((d3 <= -1e+186) || !(d3 <= 9.2e+190)) {
		tmp = d3 * -d1;
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    real(8) :: tmp
    if ((d3 <= (-1d+186)) .or. (.not. (d3 <= 9.2d+190))) then
        tmp = d3 * -d1
    else
        tmp = d1 * (d4 + d2)
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if ((d3 <= -1e+186) || !(d3 <= 9.2e+190)) {
		tmp = d3 * -d1;
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if (d3 <= -1e+186) or not (d3 <= 9.2e+190):
		tmp = d3 * -d1
	else:
		tmp = d1 * (d4 + d2)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if ((d3 <= -1e+186) || !(d3 <= 9.2e+190))
		tmp = Float64(d3 * Float64(-d1));
	else
		tmp = Float64(d1 * Float64(d4 + d2));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if ((d3 <= -1e+186) || ~((d3 <= 9.2e+190)))
		tmp = d3 * -d1;
	else
		tmp = d1 * (d4 + d2);
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := If[Or[LessEqual[d3, -1e+186], N[Not[LessEqual[d3, 9.2e+190]], $MachinePrecision]], N[(d3 * (-d1)), $MachinePrecision], N[(d1 * N[(d4 + d2), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 63.4% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d4 \leq 7.5 \cdot 10^{-213}:\\ \;\;\;\;d1 \cdot \left(d2 - d3\right)\\ \mathbf{elif}\;d4 \leq 120000000000:\\ \;\;\;\;d1 \cdot \left(d2 - d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 - d3\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d4 7.5e-213)
   (* d1 (- d2 d3))
   (if (<= d4 120000000000.0) (* d1 (- d2 d1)) (* d1 (- d4 d3)))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 7.5e-213) {
		tmp = d1 * (d2 - d3);
	} else if (d4 <= 120000000000.0) {
		tmp = d1 * (d2 - d1);
	} else {
		tmp = d1 * (d4 - d3);
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    real(8) :: tmp
    if (d4 <= 7.5d-213) then
        tmp = d1 * (d2 - d3)
    else if (d4 <= 120000000000.0d0) then
        tmp = d1 * (d2 - d1)
    else
        tmp = d1 * (d4 - d3)
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 7.5e-213) {
		tmp = d1 * (d2 - d3);
	} else if (d4 <= 120000000000.0) {
		tmp = d1 * (d2 - d1);
	} else {
		tmp = d1 * (d4 - d3);
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d4 <= 7.5e-213:
		tmp = d1 * (d2 - d3)
	elif d4 <= 120000000000.0:
		tmp = d1 * (d2 - d1)
	else:
		tmp = d1 * (d4 - d3)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= 7.5e-213)
		tmp = Float64(d1 * Float64(d2 - d3));
	elseif (d4 <= 120000000000.0)
		tmp = Float64(d1 * Float64(d2 - d1));
	else
		tmp = Float64(d1 * Float64(d4 - d3));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d4 <= 7.5e-213)
		tmp = d1 * (d2 - d3);
	elseif (d4 <= 120000000000.0)
		tmp = d1 * (d2 - d1);
	else
		tmp = d1 * (d4 - d3);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 10: 85.4% accurate, 1.7× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    real(8) :: tmp
    if (d2 <= (-2.05d+49)) then
        tmp = d1 * ((d4 + d2) - d3)
    else
        tmp = d1 * ((d4 - d3) - d1)
    end if
    code = tmp
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 11: 38.5% accurate, 1.8× speedup

Math

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

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d2 -1.05e+89)
   (* d1 d2)
   (if (<= d2 -1.4e-127) (* d3 (- d1)) (* d1 d4))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d2 <= -1.05e+89) {
		tmp = d1 * d2;
	} else if (d2 <= -1.4e-127) {
		tmp = d3 * -d1;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    real(8) :: tmp
    if (d2 <= (-1.05d+89)) then
        tmp = d1 * d2
    else if (d2 <= (-1.4d-127)) then
        tmp = d3 * -d1
    else
        tmp = d1 * d4
    end if
    code = tmp
end function

Java

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

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d2 <= -1.05e+89:
		tmp = d1 * d2
	elif d2 <= -1.4e-127:
		tmp = d3 * -d1
	else:
		tmp = d1 * d4
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d2 <= -1.05e+89)
		tmp = Float64(d1 * d2);
	elseif (d2 <= -1.4e-127)
		tmp = Float64(d3 * Float64(-d1));
	else
		tmp = Float64(d1 * d4);
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d2 <= -1.05e+89)
		tmp = d1 * d2;
	elseif (d2 <= -1.4e-127)
		tmp = d3 * -d1;
	else
		tmp = d1 * d4;
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 12: 38.9% accurate, 3.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d2 \leq -850000000000:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot d4\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d2 -850000000000.0) (* d1 d2) (* d1 d4)))

C

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

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    real(8) :: tmp
    if (d2 <= (-850000000000.0d0)) then
        tmp = d1 * d2
    else
        tmp = d1 * d4
    end if
    code = tmp
end function

Java

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

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d2 <= -850000000000.0:
		tmp = d1 * d2
	else:
		tmp = d1 * d4
	return tmp

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 13: 30.9% accurate, 5.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. 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 2023350 
(FPCore (d1 d2 d3 d4)
  :name "FastMath dist4"
  :precision binary64

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

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