FastMath test3

Percentage Accurate: 97.7% → 100.0%

Time: 7.3s

Alternatives: 8

Speedup: 1.6×

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

Specification

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Initial Program: 97.7% accurate, 1.0× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Alternative 1: 100.0% accurate, 0.1× speedup

Math

\[\begin{array}{l} \\ \mathsf{fma}\left(d1, 3, d1 \cdot \left(d2 + d3\right)\right) \end{array} \]

FPCore

(FPCore (d1 d2 d3) :precision binary64 (fma d1 3.0 (* d1 (+ d2 d3))))

C

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

Julia

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

Wolfram

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

Derivation

1. Initial program 97.9%

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

   1. distribute-lft-out 98.0%

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

   2. distribute-lft-out 99.9%

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

3. Simplified 99.9%

   \[\leadsto \color{blue}{d1 \cdot \left(\left(3 + d2\right) + d3\right)} \]
4. Add Preprocessing
5. Step-by-step derivation

   1. associate-+l+ 99.9%

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

   2. distribute-lft-in 99.9%

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

   3. fma-define 100.0%

      \[\leadsto \color{blue}{\mathsf{fma}\left(d1, 3, d1 \cdot \left(d2 + d3\right)\right)} \]

6. Applied egg-rr 100.0%

   \[\leadsto \color{blue}{\mathsf{fma}\left(d1, 3, d1 \cdot \left(d2 + d3\right)\right)} \]
7. Add Preprocessing

Alternative 2: 51.9% accurate, 0.2× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d3 \leq -5 \cdot 10^{-258}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{elif}\;d3 \leq -1.85 \cdot 10^{-292}:\\ \;\;\;\;d1 \cdot 3\\ \mathbf{elif}\;d3 \leq 2.2 \cdot 10^{-298}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{elif}\;d3 \leq 3.3 \cdot 10^{-282}:\\ \;\;\;\;d1 \cdot 3\\ \mathbf{elif}\;d3 \leq 9.5 \cdot 10^{-280}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{elif}\;d3 \leq 6.2 \cdot 10^{-161}:\\ \;\;\;\;d1 \cdot 3\\ \mathbf{elif}\;d3 \leq 1.12 \cdot 10^{-157}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{elif}\;d3 \leq 6.8 \cdot 10^{-61}:\\ \;\;\;\;d1 \cdot 3\\ \mathbf{elif}\;d3 \leq 2.15 \cdot 10^{-54}:\\ \;\;\;\;d1 \cdot d2\\ \mathbf{elif}\;d3 \leq 7.8 \cdot 10^{-5}:\\ \;\;\;\;d1 \cdot 3\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot d3\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3)
 :precision binary64
 (if (<= d3 -5e-258)
   (* d1 d2)
   (if (<= d3 -1.85e-292)
     (* d1 3.0)
     (if (<= d3 2.2e-298)
       (* d1 d2)
       (if (<= d3 3.3e-282)
         (* d1 3.0)
         (if (<= d3 9.5e-280)
           (* d1 d2)
           (if (<= d3 6.2e-161)
             (* d1 3.0)
             (if (<= d3 1.12e-157)
               (* d1 d2)
               (if (<= d3 6.8e-61)
                 (* d1 3.0)
                 (if (<= d3 2.15e-54)
                   (* d1 d2)
                   (if (<= d3 7.8e-5) (* d1 3.0) (* d1 d3))))))))))))

C

double code(double d1, double d2, double d3) {
	double tmp;
	if (d3 <= -5e-258) {
		tmp = d1 * d2;
	} else if (d3 <= -1.85e-292) {
		tmp = d1 * 3.0;
	} else if (d3 <= 2.2e-298) {
		tmp = d1 * d2;
	} else if (d3 <= 3.3e-282) {
		tmp = d1 * 3.0;
	} else if (d3 <= 9.5e-280) {
		tmp = d1 * d2;
	} else if (d3 <= 6.2e-161) {
		tmp = d1 * 3.0;
	} else if (d3 <= 1.12e-157) {
		tmp = d1 * d2;
	} else if (d3 <= 6.8e-61) {
		tmp = d1 * 3.0;
	} else if (d3 <= 2.15e-54) {
		tmp = d1 * d2;
	} else if (d3 <= 7.8e-5) {
		tmp = d1 * 3.0;
	} else {
		tmp = d1 * d3;
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8) :: tmp
    if (d3 <= (-5d-258)) then
        tmp = d1 * d2
    else if (d3 <= (-1.85d-292)) then
        tmp = d1 * 3.0d0
    else if (d3 <= 2.2d-298) then
        tmp = d1 * d2
    else if (d3 <= 3.3d-282) then
        tmp = d1 * 3.0d0
    else if (d3 <= 9.5d-280) then
        tmp = d1 * d2
    else if (d3 <= 6.2d-161) then
        tmp = d1 * 3.0d0
    else if (d3 <= 1.12d-157) then
        tmp = d1 * d2
    else if (d3 <= 6.8d-61) then
        tmp = d1 * 3.0d0
    else if (d3 <= 2.15d-54) then
        tmp = d1 * d2
    else if (d3 <= 7.8d-5) then
        tmp = d1 * 3.0d0
    else
        tmp = d1 * d3
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3) {
	double tmp;
	if (d3 <= -5e-258) {
		tmp = d1 * d2;
	} else if (d3 <= -1.85e-292) {
		tmp = d1 * 3.0;
	} else if (d3 <= 2.2e-298) {
		tmp = d1 * d2;
	} else if (d3 <= 3.3e-282) {
		tmp = d1 * 3.0;
	} else if (d3 <= 9.5e-280) {
		tmp = d1 * d2;
	} else if (d3 <= 6.2e-161) {
		tmp = d1 * 3.0;
	} else if (d3 <= 1.12e-157) {
		tmp = d1 * d2;
	} else if (d3 <= 6.8e-61) {
		tmp = d1 * 3.0;
	} else if (d3 <= 2.15e-54) {
		tmp = d1 * d2;
	} else if (d3 <= 7.8e-5) {
		tmp = d1 * 3.0;
	} else {
		tmp = d1 * d3;
	}
	return tmp;
}

Python

def code(d1, d2, d3):
	tmp = 0
	if d3 <= -5e-258:
		tmp = d1 * d2
	elif d3 <= -1.85e-292:
		tmp = d1 * 3.0
	elif d3 <= 2.2e-298:
		tmp = d1 * d2
	elif d3 <= 3.3e-282:
		tmp = d1 * 3.0
	elif d3 <= 9.5e-280:
		tmp = d1 * d2
	elif d3 <= 6.2e-161:
		tmp = d1 * 3.0
	elif d3 <= 1.12e-157:
		tmp = d1 * d2
	elif d3 <= 6.8e-61:
		tmp = d1 * 3.0
	elif d3 <= 2.15e-54:
		tmp = d1 * d2
	elif d3 <= 7.8e-5:
		tmp = d1 * 3.0
	else:
		tmp = d1 * d3
	return tmp

Julia

function code(d1, d2, d3)
	tmp = 0.0
	if (d3 <= -5e-258)
		tmp = Float64(d1 * d2);
	elseif (d3 <= -1.85e-292)
		tmp = Float64(d1 * 3.0);
	elseif (d3 <= 2.2e-298)
		tmp = Float64(d1 * d2);
	elseif (d3 <= 3.3e-282)
		tmp = Float64(d1 * 3.0);
	elseif (d3 <= 9.5e-280)
		tmp = Float64(d1 * d2);
	elseif (d3 <= 6.2e-161)
		tmp = Float64(d1 * 3.0);
	elseif (d3 <= 1.12e-157)
		tmp = Float64(d1 * d2);
	elseif (d3 <= 6.8e-61)
		tmp = Float64(d1 * 3.0);
	elseif (d3 <= 2.15e-54)
		tmp = Float64(d1 * d2);
	elseif (d3 <= 7.8e-5)
		tmp = Float64(d1 * 3.0);
	else
		tmp = Float64(d1 * d3);
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3)
	tmp = 0.0;
	if (d3 <= -5e-258)
		tmp = d1 * d2;
	elseif (d3 <= -1.85e-292)
		tmp = d1 * 3.0;
	elseif (d3 <= 2.2e-298)
		tmp = d1 * d2;
	elseif (d3 <= 3.3e-282)
		tmp = d1 * 3.0;
	elseif (d3 <= 9.5e-280)
		tmp = d1 * d2;
	elseif (d3 <= 6.2e-161)
		tmp = d1 * 3.0;
	elseif (d3 <= 1.12e-157)
		tmp = d1 * d2;
	elseif (d3 <= 6.8e-61)
		tmp = d1 * 3.0;
	elseif (d3 <= 2.15e-54)
		tmp = d1 * d2;
	elseif (d3 <= 7.8e-5)
		tmp = d1 * 3.0;
	else
		tmp = d1 * d3;
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_] := If[LessEqual[d3, -5e-258], N[(d1 * d2), $MachinePrecision], If[LessEqual[d3, -1.85e-292], N[(d1 * 3.0), $MachinePrecision], If[LessEqual[d3, 2.2e-298], N[(d1 * d2), $MachinePrecision], If[LessEqual[d3, 3.3e-282], N[(d1 * 3.0), $MachinePrecision], If[LessEqual[d3, 9.5e-280], N[(d1 * d2), $MachinePrecision], If[LessEqual[d3, 6.2e-161], N[(d1 * 3.0), $MachinePrecision], If[LessEqual[d3, 1.12e-157], N[(d1 * d2), $MachinePrecision], If[LessEqual[d3, 6.8e-61], N[(d1 * 3.0), $MachinePrecision], If[LessEqual[d3, 2.15e-54], N[(d1 * d2), $MachinePrecision], If[LessEqual[d3, 7.8e-5], N[(d1 * 3.0), $MachinePrecision], N[(d1 * d3), $MachinePrecision]]]]]]]]]]]

Derivation

1. Split input into 3 regimes

2. if d3 < -4.9999999999999999e-258 or -1.84999999999999998e-292 < d3 < 2.2e-298 or 3.3e-282 < d3 < 9.50000000000000082e-280 or 6.1999999999999997e-161 < d3 < 1.12000000000000001e-157 or 6.7999999999999996e-61 < d3 < 2.15e-54

   1. Initial program 99.2%

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

      1. distribute-lft-out 99.2%

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

      2. distribute-lft-out 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in d2 around inf 48.6%

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

   if -4.9999999999999999e-258 < d3 < -1.84999999999999998e-292 or 2.2e-298 < d3 < 3.3e-282 or 9.50000000000000082e-280 < d3 < 6.1999999999999997e-161 or 1.12000000000000001e-157 < d3 < 6.7999999999999996e-61 or 2.15e-54 < d3 < 7.7999999999999999e-5

   1. Initial program 99.8%

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

      1. distribute-lft-out 99.8%

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

      2. distribute-lft-out 99.8%

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

   3. Simplified 99.8%

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

   5. Taylor expanded in d3 around 0 99.0%

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

   6. Taylor expanded in d2 around 0 61.5%

      \[\leadsto \color{blue}{3 \cdot d1} \]
   7. Step-by-step derivation

      1. *-commutative 61.5%

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

   8. Simplified 61.5%

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

   if 7.7999999999999999e-5 < d3

   1. Initial program 93.6%

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

      1. distribute-lft-out 93.6%

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

      2. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around inf 73.2%

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

Alternative 3: 75.4% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d3 \leq 150000:\\ \;\;\;\;d1 \cdot \left(3 + d2\right)\\ \mathbf{elif}\;d3 \leq 1.7 \cdot 10^{+99} \lor \neg \left(d3 \leq 5.2 \cdot 10^{+99}\right) \land \left(d3 \leq 4.5 \cdot 10^{+163} \lor \neg \left(d3 \leq 3.4 \cdot 10^{+168}\right)\right):\\ \;\;\;\;d1 \cdot d3\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot d2\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3)
 :precision binary64
 (if (<= d3 150000.0)
   (* d1 (+ 3.0 d2))
   (if (or (<= d3 1.7e+99)
           (and (not (<= d3 5.2e+99))
                (or (<= d3 4.5e+163) (not (<= d3 3.4e+168)))))
     (* d1 d3)
     (* d1 d2))))

C

double code(double d1, double d2, double d3) {
	double tmp;
	if (d3 <= 150000.0) {
		tmp = d1 * (3.0 + d2);
	} else if ((d3 <= 1.7e+99) || (!(d3 <= 5.2e+99) && ((d3 <= 4.5e+163) || !(d3 <= 3.4e+168)))) {
		tmp = d1 * d3;
	} else {
		tmp = d1 * d2;
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8) :: tmp
    if (d3 <= 150000.0d0) then
        tmp = d1 * (3.0d0 + d2)
    else if ((d3 <= 1.7d+99) .or. (.not. (d3 <= 5.2d+99)) .and. (d3 <= 4.5d+163) .or. (.not. (d3 <= 3.4d+168))) then
        tmp = d1 * d3
    else
        tmp = d1 * d2
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3) {
	double tmp;
	if (d3 <= 150000.0) {
		tmp = d1 * (3.0 + d2);
	} else if ((d3 <= 1.7e+99) || (!(d3 <= 5.2e+99) && ((d3 <= 4.5e+163) || !(d3 <= 3.4e+168)))) {
		tmp = d1 * d3;
	} else {
		tmp = d1 * d2;
	}
	return tmp;
}

Python

def code(d1, d2, d3):
	tmp = 0
	if d3 <= 150000.0:
		tmp = d1 * (3.0 + d2)
	elif (d3 <= 1.7e+99) or (not (d3 <= 5.2e+99) and ((d3 <= 4.5e+163) or not (d3 <= 3.4e+168))):
		tmp = d1 * d3
	else:
		tmp = d1 * d2
	return tmp

Julia

function code(d1, d2, d3)
	tmp = 0.0
	if (d3 <= 150000.0)
		tmp = Float64(d1 * Float64(3.0 + d2));
	elseif ((d3 <= 1.7e+99) || (!(d3 <= 5.2e+99) && ((d3 <= 4.5e+163) || !(d3 <= 3.4e+168))))
		tmp = Float64(d1 * d3);
	else
		tmp = Float64(d1 * d2);
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3)
	tmp = 0.0;
	if (d3 <= 150000.0)
		tmp = d1 * (3.0 + d2);
	elseif ((d3 <= 1.7e+99) || (~((d3 <= 5.2e+99)) && ((d3 <= 4.5e+163) || ~((d3 <= 3.4e+168)))))
		tmp = d1 * d3;
	else
		tmp = d1 * d2;
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_] := If[LessEqual[d3, 150000.0], N[(d1 * N[(3.0 + d2), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[d3, 1.7e+99], And[N[Not[LessEqual[d3, 5.2e+99]], $MachinePrecision], Or[LessEqual[d3, 4.5e+163], N[Not[LessEqual[d3, 3.4e+168]], $MachinePrecision]]]], N[(d1 * d3), $MachinePrecision], N[(d1 * d2), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if d3 < 1.5e5

   1. Initial program 99.4%

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

      1. distribute-lft-out 99.4%

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

      2. distribute-lft-out 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in d3 around 0 74.2%

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

   if 1.5e5 < d3 < 1.69999999999999992e99 or 5.1999999999999999e99 < d3 < 4.49999999999999988e163 or 3.40000000000000003e168 < d3

   1. Initial program 92.8%

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

      1. distribute-lft-out 92.8%

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

      2. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around inf 81.6%

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

   if 1.69999999999999992e99 < d3 < 5.1999999999999999e99 or 4.49999999999999988e163 < d3 < 3.40000000000000003e168

   1. Initial program 100.0%

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

      1. distribute-lft-out 100.0%

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

      2. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around inf 100.0%

      \[\leadsto \color{blue}{d1 \cdot d2} \]
3. Recombined 3 regimes into one program.

4. Final simplification 76.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;d3 \leq 150000:\\ \;\;\;\;d1 \cdot \left(3 + d2\right)\\ \mathbf{elif}\;d3 \leq 1.7 \cdot 10^{+99} \lor \neg \left(d3 \leq 5.2 \cdot 10^{+99}\right) \land \left(d3 \leq 4.5 \cdot 10^{+163} \lor \neg \left(d3 \leq 3.4 \cdot 10^{+168}\right)\right):\\ \;\;\;\;d1 \cdot d3\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot d2\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 54.7% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d2 \leq -1800000 \lor \neg \left(d2 \leq 1.55 \cdot 10^{-209}\right):\\ \;\;\;\;d1 \cdot d2\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot 3\\ \end{array} \end{array} \]

FPCore

(FPCore (d1 d2 d3)
 :precision binary64
 (if (or (<= d2 -1800000.0) (not (<= d2 1.55e-209))) (* d1 d2) (* d1 3.0)))

C

double code(double d1, double d2, double d3) {
	double tmp;
	if ((d2 <= -1800000.0) || !(d2 <= 1.55e-209)) {
		tmp = d1 * d2;
	} else {
		tmp = d1 * 3.0;
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8) :: tmp
    if ((d2 <= (-1800000.0d0)) .or. (.not. (d2 <= 1.55d-209))) then
        tmp = d1 * d2
    else
        tmp = d1 * 3.0d0
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3) {
	double tmp;
	if ((d2 <= -1800000.0) || !(d2 <= 1.55e-209)) {
		tmp = d1 * d2;
	} else {
		tmp = d1 * 3.0;
	}
	return tmp;
}

Python

def code(d1, d2, d3):
	tmp = 0
	if (d2 <= -1800000.0) or not (d2 <= 1.55e-209):
		tmp = d1 * d2
	else:
		tmp = d1 * 3.0
	return tmp

Julia

function code(d1, d2, d3)
	tmp = 0.0
	if ((d2 <= -1800000.0) || !(d2 <= 1.55e-209))
		tmp = Float64(d1 * d2);
	else
		tmp = Float64(d1 * 3.0);
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3)
	tmp = 0.0;
	if ((d2 <= -1800000.0) || ~((d2 <= 1.55e-209)))
		tmp = d1 * d2;
	else
		tmp = d1 * 3.0;
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_] := If[Or[LessEqual[d2, -1800000.0], N[Not[LessEqual[d2, 1.55e-209]], $MachinePrecision]], N[(d1 * d2), $MachinePrecision], N[(d1 * 3.0), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d2 < -1.8e6 or 1.55e-209 < d2

   1. Initial program 96.9%

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

      1. distribute-lft-out 96.9%

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

      2. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around inf 63.5%

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

   if -1.8e6 < d2 < 1.55e-209

   1. Initial program 99.8%

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

      1. distribute-lft-out 99.8%

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

      2. distribute-lft-out 99.8%

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

   3. Simplified 99.8%

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

   5. Taylor expanded in d3 around 0 48.2%

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

   6. Taylor expanded in d2 around 0 46.4%

      \[\leadsto \color{blue}{3 \cdot d1} \]
   7. Step-by-step derivation

      1. *-commutative 46.4%

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

   8. Simplified 46.4%

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

4. Final simplification 57.4%

   \[\leadsto \begin{array}{l} \mathbf{if}\;d2 \leq -1800000 \lor \neg \left(d2 \leq 1.55 \cdot 10^{-209}\right):\\ \;\;\;\;d1 \cdot d2\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot 3\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 80.8% accurate, 1.1× speedup

Math

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

FPCore

(FPCore (d1 d2 d3)
 :precision binary64
 (if (<= d3 2.35e-10) (* d1 (+ 3.0 d2)) (* d1 (+ d2 d3))))

C

double code(double d1, double d2, double d3) {
	double tmp;
	if (d3 <= 2.35e-10) {
		tmp = d1 * (3.0 + d2);
	} else {
		tmp = d1 * (d2 + d3);
	}
	return tmp;
}

Fortran

real(8) function code(d1, d2, d3)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8) :: tmp
    if (d3 <= 2.35d-10) then
        tmp = d1 * (3.0d0 + d2)
    else
        tmp = d1 * (d2 + d3)
    end if
    code = tmp
end function

Java

public static double code(double d1, double d2, double d3) {
	double tmp;
	if (d3 <= 2.35e-10) {
		tmp = d1 * (3.0 + d2);
	} else {
		tmp = d1 * (d2 + d3);
	}
	return tmp;
}

Python

def code(d1, d2, d3):
	tmp = 0
	if d3 <= 2.35e-10:
		tmp = d1 * (3.0 + d2)
	else:
		tmp = d1 * (d2 + d3)
	return tmp

Julia

function code(d1, d2, d3)
	tmp = 0.0
	if (d3 <= 2.35e-10)
		tmp = Float64(d1 * Float64(3.0 + d2));
	else
		tmp = Float64(d1 * Float64(d2 + d3));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1, d2, d3)
	tmp = 0.0;
	if (d3 <= 2.35e-10)
		tmp = d1 * (3.0 + d2);
	else
		tmp = d1 * (d2 + d3);
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_, d2_, d3_] := If[LessEqual[d3, 2.35e-10], N[(d1 * N[(3.0 + d2), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(d2 + d3), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d3 < 2.3500000000000002e-10

   1. Initial program 99.3%

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

      1. distribute-lft-out 99.4%

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

      2. distribute-lft-out 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in d3 around 0 74.8%

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

   if 2.3500000000000002e-10 < d3

   1. Initial program 93.8%

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

      1. distribute-lft-out 93.8%

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

      2. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d2 around inf 88.4%

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

      1. associate-/l* 79.6%

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

   7. Simplified 79.6%

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

   8. Taylor expanded in d3 around inf 85.6%

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

   9. Taylor expanded in d2 around 0 88.4%

      \[\leadsto \color{blue}{d1 \cdot d2 + d1 \cdot d3} \]
   10. Step-by-step derivation

       1. +-commutative 88.4%

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

       2. distribute-lft-out 94.6%

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

   11. Simplified 94.6%

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

4. Final simplification 79.8%

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

Alternative 6: 76.8% accurate, 1.1× speedup

Math

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

FPCore

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

C

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

Fortran

real(8) function code(d1, d2, d3)
    real(8), intent (in) :: d1
    real(8), intent (in) :: d2
    real(8), intent (in) :: d3
    real(8) :: tmp
    if (d2 <= (-7d+15)) then
        tmp = d1 * (3.0d0 + d2)
    else
        tmp = d1 * (3.0d0 + d3)
    end if
    code = tmp
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Split input into 2 regimes

2. if d2 < -7e15

   1. Initial program 95.3%

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

      1. distribute-lft-out 95.3%

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

      2. distribute-lft-out 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in d3 around 0 78.9%

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

   if -7e15 < d2

   1. Initial program 98.8%

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

      1. distribute-lft-out 98.8%

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

      2. distribute-lft-out 99.9%

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

   3. Simplified 99.9%

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

   5. Taylor expanded in d2 around 0 73.3%

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

Alternative 7: 99.9% accurate, 1.6× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 97.9%

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

   1. distribute-lft-out 98.0%

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

   2. distribute-lft-out 99.9%

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

3. Simplified 99.9%

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

5. Final simplification 99.9%

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

Alternative 8: 27.0% accurate, 3.7× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 97.9%

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

   1. distribute-lft-out 98.0%

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

   2. distribute-lft-out 99.9%

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

3. Simplified 99.9%

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

5. Taylor expanded in d3 around 0 64.0%

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

6. Taylor expanded in d2 around 0 24.5%

   \[\leadsto \color{blue}{3 \cdot d1} \]
7. Step-by-step derivation

   1. *-commutative 24.5%

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

8. Simplified 24.5%

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

Developer target: 99.9% accurate, 1.6× speedup

Math

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

FPCore

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

C

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

Fortran

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

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Reproduce

herbie shell --seed 2024107 
(FPCore (d1 d2 d3)
  :name "FastMath test3"
  :precision binary64

  :alt
  (* d1 (+ (+ 3.0 d2) d3))

  (+ (+ (* d1 3.0) (* d1 d2)) (* d1 d3)))