FastMath dist4

Percentage Accurate: 89.0% → 100.0%

Time: 8.4s

Alternatives: 14

Speedup: 1.7×

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 2: 62.7% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := d1 \cdot \left(\left(-d1\right) - d3\right)\\ t_1 := d1 \cdot \left(d4 - d1\right)\\ \mathbf{if}\;d2 \leq -1.8 \cdot 10^{+71}:\\ \;\;\;\;d1 \cdot \left(d2 - d3\right)\\ \mathbf{elif}\;d2 \leq -5.5 \cdot 10^{+60}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;d2 \leq -5.5 \cdot 10^{+21}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d2 \leq -5000:\\ \;\;\;\;d1 \cdot \left(d4 - d3\right)\\ \mathbf{elif}\;d2 \leq -5.4 \cdot 10^{-15}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d2 \leq -4.2 \cdot 10^{-21}:\\ \;\;\;\;d1 \cdot \left(d4 + d2\right)\\ \mathbf{elif}\;d2 \leq 8.2 \cdot 10^{-307}:\\ \;\;\;\;t_0\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (let* ((t_0 (* d1 (- (- d1) d3))) (t_1 (* d1 (- d4 d1))))
   (if (<= d2 -1.8e+71)
     (* d1 (- d2 d3))
     (if (<= d2 -5.5e+60)
       t_1
       (if (<= d2 -5.5e+21)
         t_0
         (if (<= d2 -5000.0)
           (* d1 (- d4 d3))
           (if (<= d2 -5.4e-15)
             t_0
             (if (<= d2 -4.2e-21)
               (* d1 (+ d4 d2))
               (if (<= d2 8.2e-307) t_0 t_1)))))))))

C

double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * (-d1 - d3);
	double t_1 = d1 * (d4 - d1);
	double tmp;
	if (d2 <= -1.8e+71) {
		tmp = d1 * (d2 - d3);
	} else if (d2 <= -5.5e+60) {
		tmp = t_1;
	} else if (d2 <= -5.5e+21) {
		tmp = t_0;
	} else if (d2 <= -5000.0) {
		tmp = d1 * (d4 - d3);
	} else if (d2 <= -5.4e-15) {
		tmp = t_0;
	} else if (d2 <= -4.2e-21) {
		tmp = d1 * (d4 + d2);
	} else if (d2 <= 8.2e-307) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	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) :: t_1
    real(8) :: tmp
    t_0 = d1 * (-d1 - d3)
    t_1 = d1 * (d4 - d1)
    if (d2 <= (-1.8d+71)) then
        tmp = d1 * (d2 - d3)
    else if (d2 <= (-5.5d+60)) then
        tmp = t_1
    else if (d2 <= (-5.5d+21)) then
        tmp = t_0
    else if (d2 <= (-5000.0d0)) then
        tmp = d1 * (d4 - d3)
    else if (d2 <= (-5.4d-15)) then
        tmp = t_0
    else if (d2 <= (-4.2d-21)) then
        tmp = d1 * (d4 + d2)
    else if (d2 <= 8.2d-307) then
        tmp = t_0
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * (-d1 - d3);
	double t_1 = d1 * (d4 - d1);
	double tmp;
	if (d2 <= -1.8e+71) {
		tmp = d1 * (d2 - d3);
	} else if (d2 <= -5.5e+60) {
		tmp = t_1;
	} else if (d2 <= -5.5e+21) {
		tmp = t_0;
	} else if (d2 <= -5000.0) {
		tmp = d1 * (d4 - d3);
	} else if (d2 <= -5.4e-15) {
		tmp = t_0;
	} else if (d2 <= -4.2e-21) {
		tmp = d1 * (d4 + d2);
	} else if (d2 <= 8.2e-307) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	t_0 = d1 * (-d1 - d3)
	t_1 = d1 * (d4 - d1)
	tmp = 0
	if d2 <= -1.8e+71:
		tmp = d1 * (d2 - d3)
	elif d2 <= -5.5e+60:
		tmp = t_1
	elif d2 <= -5.5e+21:
		tmp = t_0
	elif d2 <= -5000.0:
		tmp = d1 * (d4 - d3)
	elif d2 <= -5.4e-15:
		tmp = t_0
	elif d2 <= -4.2e-21:
		tmp = d1 * (d4 + d2)
	elif d2 <= 8.2e-307:
		tmp = t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(d1, d2, d3, d4)
	t_0 = Float64(d1 * Float64(Float64(-d1) - d3))
	t_1 = Float64(d1 * Float64(d4 - d1))
	tmp = 0.0
	if (d2 <= -1.8e+71)
		tmp = Float64(d1 * Float64(d2 - d3));
	elseif (d2 <= -5.5e+60)
		tmp = t_1;
	elseif (d2 <= -5.5e+21)
		tmp = t_0;
	elseif (d2 <= -5000.0)
		tmp = Float64(d1 * Float64(d4 - d3));
	elseif (d2 <= -5.4e-15)
		tmp = t_0;
	elseif (d2 <= -4.2e-21)
		tmp = Float64(d1 * Float64(d4 + d2));
	elseif (d2 <= 8.2e-307)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	t_0 = d1 * (-d1 - d3);
	t_1 = d1 * (d4 - d1);
	tmp = 0.0;
	if (d2 <= -1.8e+71)
		tmp = d1 * (d2 - d3);
	elseif (d2 <= -5.5e+60)
		tmp = t_1;
	elseif (d2 <= -5.5e+21)
		tmp = t_0;
	elseif (d2 <= -5000.0)
		tmp = d1 * (d4 - d3);
	elseif (d2 <= -5.4e-15)
		tmp = t_0;
	elseif (d2 <= -4.2e-21)
		tmp = d1 * (d4 + d2);
	elseif (d2 <= 8.2e-307)
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := Block[{t$95$0 = N[(d1 * N[((-d1) - d3), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(d1 * N[(d4 - d1), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d2, -1.8e+71], N[(d1 * N[(d2 - d3), $MachinePrecision]), $MachinePrecision], If[LessEqual[d2, -5.5e+60], t$95$1, If[LessEqual[d2, -5.5e+21], t$95$0, If[LessEqual[d2, -5000.0], N[(d1 * N[(d4 - d3), $MachinePrecision]), $MachinePrecision], If[LessEqual[d2, -5.4e-15], t$95$0, If[LessEqual[d2, -4.2e-21], N[(d1 * N[(d4 + d2), $MachinePrecision]), $MachinePrecision], If[LessEqual[d2, 8.2e-307], t$95$0, t$95$1]]]]]]]]]

Derivation

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

Alternative 3: 64.8% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := d1 \cdot \left(-d3\right)\\ t_1 := d1 \cdot \left(-d1\right)\\ t_2 := d1 \cdot \left(d4 + d2\right)\\ \mathbf{if}\;d1 \leq -5.6 \cdot 10^{+181}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;d1 \leq 2.2 \cdot 10^{-232}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;d1 \leq 8.5 \cdot 10^{-196}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d1 \leq 1.85 \cdot 10^{-138}:\\ \;\;\;\;t_2\\ \mathbf{elif}\;d1 \leq 9.2 \cdot 10^{-132}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d1 \leq 1.6 \cdot 10^{+154}:\\ \;\;\;\;t_2\\ \mathbf{else}:\\ \;\;\;\;t_1\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (let* ((t_0 (* d1 (- d3))) (t_1 (* d1 (- d1))) (t_2 (* d1 (+ d4 d2))))
   (if (<= d1 -5.6e+181)
     t_1
     (if (<= d1 2.2e-232)
       t_2
       (if (<= d1 8.5e-196)
         t_0
         (if (<= d1 1.85e-138)
           t_2
           (if (<= d1 9.2e-132) t_0 (if (<= d1 1.6e+154) t_2 t_1))))))))

C

double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * -d3;
	double t_1 = d1 * -d1;
	double t_2 = d1 * (d4 + d2);
	double tmp;
	if (d1 <= -5.6e+181) {
		tmp = t_1;
	} else if (d1 <= 2.2e-232) {
		tmp = t_2;
	} else if (d1 <= 8.5e-196) {
		tmp = t_0;
	} else if (d1 <= 1.85e-138) {
		tmp = t_2;
	} else if (d1 <= 9.2e-132) {
		tmp = t_0;
	} else if (d1 <= 1.6e+154) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	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) :: t_1
    real(8) :: t_2
    real(8) :: tmp
    t_0 = d1 * -d3
    t_1 = d1 * -d1
    t_2 = d1 * (d4 + d2)
    if (d1 <= (-5.6d+181)) then
        tmp = t_1
    else if (d1 <= 2.2d-232) then
        tmp = t_2
    else if (d1 <= 8.5d-196) then
        tmp = t_0
    else if (d1 <= 1.85d-138) then
        tmp = t_2
    else if (d1 <= 9.2d-132) then
        tmp = t_0
    else if (d1 <= 1.6d+154) then
        tmp = t_2
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * -d3;
	double t_1 = d1 * -d1;
	double t_2 = d1 * (d4 + d2);
	double tmp;
	if (d1 <= -5.6e+181) {
		tmp = t_1;
	} else if (d1 <= 2.2e-232) {
		tmp = t_2;
	} else if (d1 <= 8.5e-196) {
		tmp = t_0;
	} else if (d1 <= 1.85e-138) {
		tmp = t_2;
	} else if (d1 <= 9.2e-132) {
		tmp = t_0;
	} else if (d1 <= 1.6e+154) {
		tmp = t_2;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	t_0 = d1 * -d3
	t_1 = d1 * -d1
	t_2 = d1 * (d4 + d2)
	tmp = 0
	if d1 <= -5.6e+181:
		tmp = t_1
	elif d1 <= 2.2e-232:
		tmp = t_2
	elif d1 <= 8.5e-196:
		tmp = t_0
	elif d1 <= 1.85e-138:
		tmp = t_2
	elif d1 <= 9.2e-132:
		tmp = t_0
	elif d1 <= 1.6e+154:
		tmp = t_2
	else:
		tmp = t_1
	return tmp

Julia

function code(d1, d2, d3, d4)
	t_0 = Float64(d1 * Float64(-d3))
	t_1 = Float64(d1 * Float64(-d1))
	t_2 = Float64(d1 * Float64(d4 + d2))
	tmp = 0.0
	if (d1 <= -5.6e+181)
		tmp = t_1;
	elseif (d1 <= 2.2e-232)
		tmp = t_2;
	elseif (d1 <= 8.5e-196)
		tmp = t_0;
	elseif (d1 <= 1.85e-138)
		tmp = t_2;
	elseif (d1 <= 9.2e-132)
		tmp = t_0;
	elseif (d1 <= 1.6e+154)
		tmp = t_2;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	t_0 = d1 * -d3;
	t_1 = d1 * -d1;
	t_2 = d1 * (d4 + d2);
	tmp = 0.0;
	if (d1 <= -5.6e+181)
		tmp = t_1;
	elseif (d1 <= 2.2e-232)
		tmp = t_2;
	elseif (d1 <= 8.5e-196)
		tmp = t_0;
	elseif (d1 <= 1.85e-138)
		tmp = t_2;
	elseif (d1 <= 9.2e-132)
		tmp = t_0;
	elseif (d1 <= 1.6e+154)
		tmp = t_2;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := Block[{t$95$0 = N[(d1 * (-d3)), $MachinePrecision]}, Block[{t$95$1 = N[(d1 * (-d1)), $MachinePrecision]}, Block[{t$95$2 = N[(d1 * N[(d4 + d2), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[d1, -5.6e+181], t$95$1, If[LessEqual[d1, 2.2e-232], t$95$2, If[LessEqual[d1, 8.5e-196], t$95$0, If[LessEqual[d1, 1.85e-138], t$95$2, If[LessEqual[d1, 9.2e-132], t$95$0, If[LessEqual[d1, 1.6e+154], t$95$2, t$95$1]]]]]]]]]

Derivation

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

Alternative 4: 39.1% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := d1 \cdot \left(-d3\right)\\ \mathbf{if}\;d4 \leq -9 \cdot 10^{-174}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{elif}\;d4 \leq 4 \cdot 10^{-180}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d4 \leq 1.72 \cdot 10^{-127}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{elif}\;d4 \leq 4.8 \cdot 10^{-106}:\\ \;\;\;\;t_0\\ \mathbf{elif}\;d4 \leq 4.6 \cdot 10^{+132}:\\ \;\;\;\;d1 \cdot \left(-d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot d4\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (let* ((t_0 (* d1 (- d3))))
   (if (<= d4 -9e-174)
     (* d1 d2)
     (if (<= d4 4e-180)
       t_0
       (if (<= d4 1.72e-127)
         (* d1 d2)
         (if (<= d4 4.8e-106)
           t_0
           (if (<= d4 4.6e+132) (* d1 (- d1)) (* d1 d4))))))))

C

double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * -d3;
	double tmp;
	if (d4 <= -9e-174) {
		tmp = d1 * d2;
	} else if (d4 <= 4e-180) {
		tmp = t_0;
	} else if (d4 <= 1.72e-127) {
		tmp = d1 * d2;
	} else if (d4 <= 4.8e-106) {
		tmp = t_0;
	} else if (d4 <= 4.6e+132) {
		tmp = d1 * -d1;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    real(8) :: t_0
    real(8) :: tmp
    t_0 = d1 * -d3
    if (d4 <= (-9d-174)) then
        tmp = d1 * d2
    else if (d4 <= 4d-180) then
        tmp = t_0
    else if (d4 <= 1.72d-127) then
        tmp = d1 * d2
    else if (d4 <= 4.8d-106) then
        tmp = t_0
    else if (d4 <= 4.6d+132) then
        tmp = d1 * -d1
    else
        tmp = d1 * d4
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double t_0 = d1 * -d3;
	double tmp;
	if (d4 <= -9e-174) {
		tmp = d1 * d2;
	} else if (d4 <= 4e-180) {
		tmp = t_0;
	} else if (d4 <= 1.72e-127) {
		tmp = d1 * d2;
	} else if (d4 <= 4.8e-106) {
		tmp = t_0;
	} else if (d4 <= 4.6e+132) {
		tmp = d1 * -d1;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	t_0 = d1 * -d3
	tmp = 0
	if d4 <= -9e-174:
		tmp = d1 * d2
	elif d4 <= 4e-180:
		tmp = t_0
	elif d4 <= 1.72e-127:
		tmp = d1 * d2
	elif d4 <= 4.8e-106:
		tmp = t_0
	elif d4 <= 4.6e+132:
		tmp = d1 * -d1
	else:
		tmp = d1 * d4
	return tmp

Julia

function code(d1, d2, d3, d4)
	t_0 = Float64(d1 * Float64(-d3))
	tmp = 0.0
	if (d4 <= -9e-174)
		tmp = Float64(d1 * d2);
	elseif (d4 <= 4e-180)
		tmp = t_0;
	elseif (d4 <= 1.72e-127)
		tmp = Float64(d1 * d2);
	elseif (d4 <= 4.8e-106)
		tmp = t_0;
	elseif (d4 <= 4.6e+132)
		tmp = Float64(d1 * Float64(-d1));
	else
		tmp = Float64(d1 * d4);
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	t_0 = d1 * -d3;
	tmp = 0.0;
	if (d4 <= -9e-174)
		tmp = d1 * d2;
	elseif (d4 <= 4e-180)
		tmp = t_0;
	elseif (d4 <= 1.72e-127)
		tmp = d1 * d2;
	elseif (d4 <= 4.8e-106)
		tmp = t_0;
	elseif (d4 <= 4.6e+132)
		tmp = d1 * -d1;
	else
		tmp = d1 * d4;
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := Block[{t$95$0 = N[(d1 * (-d3)), $MachinePrecision]}, If[LessEqual[d4, -9e-174], N[(d1 * d2), $MachinePrecision], If[LessEqual[d4, 4e-180], t$95$0, If[LessEqual[d4, 1.72e-127], N[(d1 * d2), $MachinePrecision], If[LessEqual[d4, 4.8e-106], t$95$0, If[LessEqual[d4, 4.6e+132], N[(d1 * (-d1)), $MachinePrecision], N[(d1 * d4), $MachinePrecision]]]]]]]

Derivation

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

Alternative 5: 40.5% accurate, 0.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d2 \leq -1.45 \cdot 10^{+72}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{elif}\;d2 \leq -1.35 \cdot 10^{+38}:\\ \;\;\;\;d1 \cdot d4\\ \mathbf{elif}\;d2 \leq -3.1 \cdot 10^{+28}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{elif}\;d2 \leq 3.2 \cdot 10^{-187}:\\ \;\;\;\;d1 \cdot \left(-d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot d4\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d2 -1.45e+72)
   (* d1 d2)
   (if (<= d2 -1.35e+38)
     (* d1 d4)
     (if (<= d2 -3.1e+28)
       (* d1 d2)
       (if (<= d2 3.2e-187) (* d1 (- d1)) (* d1 d4))))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d2 <= -1.45e+72) {
		tmp = d1 * d2;
	} else if (d2 <= -1.35e+38) {
		tmp = d1 * d4;
	} else if (d2 <= -3.1e+28) {
		tmp = d1 * d2;
	} else if (d2 <= 3.2e-187) {
		tmp = d1 * -d1;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3, d4)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8), intent (in) :: d4
    real(8) :: tmp
    if (d2 <= (-1.45d+72)) then
        tmp = d1 * d2
    else if (d2 <= (-1.35d+38)) then
        tmp = d1 * d4
    else if (d2 <= (-3.1d+28)) then
        tmp = d1 * d2
    else if (d2 <= 3.2d-187) then
        tmp = d1 * -d1
    else
        tmp = d1 * d4
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d2 <= -1.45e+72) {
		tmp = d1 * d2;
	} else if (d2 <= -1.35e+38) {
		tmp = d1 * d4;
	} else if (d2 <= -3.1e+28) {
		tmp = d1 * d2;
	} else if (d2 <= 3.2e-187) {
		tmp = d1 * -d1;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d2 <= -1.45e+72:
		tmp = d1 * d2
	elif d2 <= -1.35e+38:
		tmp = d1 * d4
	elif d2 <= -3.1e+28:
		tmp = d1 * d2
	elif d2 <= 3.2e-187:
		tmp = d1 * -d1
	else:
		tmp = d1 * d4
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d2 <= -1.45e+72)
		tmp = Float64(d1 * d2);
	elseif (d2 <= -1.35e+38)
		tmp = Float64(d1 * d4);
	elseif (d2 <= -3.1e+28)
		tmp = Float64(d1 * d2);
	elseif (d2 <= 3.2e-187)
		tmp = Float64(d1 * Float64(-d1));
	else
		tmp = Float64(d1 * d4);
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d2 <= -1.45e+72)
		tmp = d1 * d2;
	elseif (d2 <= -1.35e+38)
		tmp = d1 * d4;
	elseif (d2 <= -3.1e+28)
		tmp = d1 * d2;
	elseif (d2 <= 3.2e-187)
		tmp = d1 * -d1;
	else
		tmp = d1 * d4;
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := If[LessEqual[d2, -1.45e+72], N[(d1 * d2), $MachinePrecision], If[LessEqual[d2, -1.35e+38], N[(d1 * d4), $MachinePrecision], If[LessEqual[d2, -3.1e+28], N[(d1 * d2), $MachinePrecision], If[LessEqual[d2, 3.2e-187], N[(d1 * (-d1)), $MachinePrecision], N[(d1 * d4), $MachinePrecision]]]]]

Derivation

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

Alternative 6: 61.7% accurate, 0.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d2 \leq -5.2 \cdot 10^{+72}:\\ \;\;\;\;d1 \cdot \left(d2 - d3\right)\\ \mathbf{elif}\;d2 \leq -2.5 \cdot 10^{-14}:\\ \;\;\;\;d1 \cdot \left(d4 - d3\right)\\ \mathbf{elif}\;d2 \leq -4.8 \cdot 10^{-81}:\\ \;\;\;\;d1 \cdot \left(d2 - d1\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d4 - d1\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d2 -5.2e+72)
   (* d1 (- d2 d3))
   (if (<= d2 -2.5e-14)
     (* d1 (- d4 d3))
     (if (<= d2 -4.8e-81) (* d1 (- d2 d1)) (* d1 (- d4 d1))))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d2 <= -5.2e+72) {
		tmp = d1 * (d2 - d3);
	} else if (d2 <= -2.5e-14) {
		tmp = d1 * (d4 - d3);
	} else if (d2 <= -4.8e-81) {
		tmp = d1 * (d2 - d1);
	} else {
		tmp = d1 * (d4 - 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 <= (-5.2d+72)) then
        tmp = d1 * (d2 - d3)
    else if (d2 <= (-2.5d-14)) then
        tmp = d1 * (d4 - d3)
    else if (d2 <= (-4.8d-81)) then
        tmp = d1 * (d2 - d1)
    else
        tmp = d1 * (d4 - d1)
    end if
    code = tmp
end function

Java

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

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d2 <= -5.2e+72:
		tmp = d1 * (d2 - d3)
	elif d2 <= -2.5e-14:
		tmp = d1 * (d4 - d3)
	elif d2 <= -4.8e-81:
		tmp = d1 * (d2 - d1)
	else:
		tmp = d1 * (d4 - d1)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d2 <= -5.2e+72)
		tmp = Float64(d1 * Float64(d2 - d3));
	elseif (d2 <= -2.5e-14)
		tmp = Float64(d1 * Float64(d4 - d3));
	elseif (d2 <= -4.8e-81)
		tmp = Float64(d1 * Float64(d2 - d1));
	else
		tmp = Float64(d1 * Float64(d4 - d1));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d2 <= -5.2e+72)
		tmp = d1 * (d2 - d3);
	elseif (d2 <= -2.5e-14)
		tmp = d1 * (d4 - d3);
	elseif (d2 <= -4.8e-81)
		tmp = d1 * (d2 - d1);
	else
		tmp = d1 * (d4 - d1);
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_, d4_] := If[LessEqual[d2, -5.2e+72], N[(d1 * N[(d2 - d3), $MachinePrecision]), $MachinePrecision], If[LessEqual[d2, -2.5e-14], N[(d1 * N[(d4 - d3), $MachinePrecision]), $MachinePrecision], If[LessEqual[d2, -4.8e-81], N[(d1 * N[(d2 - d1), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(d4 - d1), $MachinePrecision]), $MachinePrecision]]]]

Derivation

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

Alternative 7: 87.1% accurate, 0.9× speedup

Math

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

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d1 -1.7e+240)
   (* d1 (- d1))
   (if (<= d1 3e+138) (* d1 (- (+ d4 d2) d3)) (* d1 (- d4 d1)))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d1 <= -1.7e+240) {
		tmp = d1 * -d1;
	} else if (d1 <= 3e+138) {
		tmp = d1 * ((d4 + d2) - d3);
	} else {
		tmp = d1 * (d4 - 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 (d1 <= (-1.7d+240)) then
        tmp = d1 * -d1
    else if (d1 <= 3d+138) then
        tmp = d1 * ((d4 + d2) - d3)
    else
        tmp = d1 * (d4 - d1)
    end if
    code = tmp
end function

Java

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

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d1 <= -1.7e+240:
		tmp = d1 * -d1
	elif d1 <= 3e+138:
		tmp = d1 * ((d4 + d2) - d3)
	else:
		tmp = d1 * (d4 - d1)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d1 <= -1.7e+240)
		tmp = Float64(d1 * Float64(-d1));
	elseif (d1 <= 3e+138)
		tmp = Float64(d1 * Float64(Float64(d4 + d2) - d3));
	else
		tmp = Float64(d1 * Float64(d4 - d1));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d1 <= -1.7e+240)
		tmp = d1 * -d1;
	elseif (d1 <= 3e+138)
		tmp = d1 * ((d4 + d2) - d3);
	else
		tmp = d1 * (d4 - d1);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 8: 63.4% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d4 1.38e-105)
   (* d1 (- d2 d3))
   (if (<= d4 2e+50) (* d1 (- d2 d1)) (* d1 (+ d4 d2)))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 1.38e-105) {
		tmp = d1 * (d2 - d3);
	} else if (d4 <= 2e+50) {
		tmp = d1 * (d2 - d1);
	} else {
		tmp = d1 * (d4 + d2);
	}
	return tmp;
}

Fortran

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

Java

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

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d4 <= 1.38e-105:
		tmp = d1 * (d2 - d3)
	elif d4 <= 2e+50:
		tmp = d1 * (d2 - d1)
	else:
		tmp = d1 * (d4 + d2)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= 1.38e-105)
		tmp = Float64(d1 * Float64(d2 - d3));
	elseif (d4 <= 2e+50)
		tmp = Float64(d1 * Float64(d2 - d1));
	else
		tmp = Float64(d1 * Float64(d4 + d2));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d4 <= 1.38e-105)
		tmp = d1 * (d2 - d3);
	elseif (d4 <= 2e+50)
		tmp = d1 * (d2 - d1);
	else
		tmp = d1 * (d4 + d2);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 9: 62.3% accurate, 1.0× speedup

Math

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

FPCore

(FPCore (d1 d2 d3 d4)
 :precision binary64
 (if (<= d4 1.25e-101)
   (* d1 (- d2 d3))
   (if (<= d4 0.00088) (* d1 (- d2 d1)) (* d1 (- d4 d1)))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 1.25e-101) {
		tmp = d1 * (d2 - d3);
	} else if (d4 <= 0.00088) {
		tmp = d1 * (d2 - d1);
	} else {
		tmp = d1 * (d4 - 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 (d4 <= 1.25d-101) then
        tmp = d1 * (d2 - d3)
    else if (d4 <= 0.00088d0) then
        tmp = d1 * (d2 - d1)
    else
        tmp = d1 * (d4 - d1)
    end if
    code = tmp
end function

Java

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

Python

def code(d1, d2, d3, d4):
	tmp = 0
	if d4 <= 1.25e-101:
		tmp = d1 * (d2 - d3)
	elif d4 <= 0.00088:
		tmp = d1 * (d2 - d1)
	else:
		tmp = d1 * (d4 - d1)
	return tmp

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= 1.25e-101)
		tmp = Float64(d1 * Float64(d2 - d3));
	elseif (d4 <= 0.00088)
		tmp = Float64(d1 * Float64(d2 - d1));
	else
		tmp = Float64(d1 * Float64(d4 - d1));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3, d4)
	tmp = 0.0;
	if (d4 <= 1.25e-101)
		tmp = d1 * (d2 - d3);
	elseif (d4 <= 0.00088)
		tmp = d1 * (d2 - d1);
	else
		tmp = d1 * (d4 - d1);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 10: 85.3% accurate, 1.2× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 11: 84.0% accurate, 1.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d4 \leq 0.000125:\\ \;\;\;\;d1 \cdot \left(\left(d2 - d3\right) - d1\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 (<= d4 0.000125) (* d1 (- (- d2 d3) d1)) (* d1 (- (- d4 d3) d1))))

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d4 <= 0.000125) {
		tmp = d1 * ((d2 - d3) - d1);
	} 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 (d4 <= 0.000125d0) then
        tmp = d1 * ((d2 - d3) - d1)
    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 (d4 <= 0.000125) {
		tmp = d1 * ((d2 - d3) - d1);
	} else {
		tmp = d1 * ((d4 - d3) - d1);
	}
	return tmp;
}

Python

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

Julia

function code(d1, d2, d3, d4)
	tmp = 0.0
	if (d4 <= 0.000125)
		tmp = Float64(d1 * Float64(Float64(d2 - d3) - d1));
	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 (d4 <= 0.000125)
		tmp = d1 * ((d2 - d3) - d1);
	else
		tmp = d1 * ((d4 - d3) - d1);
	end
	tmp_2 = tmp;
end

Wolfram

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

Derivation

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

Alternative 12: 62.3% accurate, 1.5× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

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

Alternative 13: 39.9% accurate, 1.9× speedup

Math

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

FPCore

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

C

double code(double d1, double d2, double d3, double d4) {
	double tmp;
	if (d2 <= -2.2e+71) {
		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 <= (-2.2d+71)) 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 <= -2.2e+71) {
		tmp = d1 * d2;
	} else {
		tmp = d1 * d4;
	}
	return tmp;
}

Python

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

Julia

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

Wolfram

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

Derivation

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

Alternative 14: 30.6% 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 2024006 
(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)))