FastMath test5

Percentage Accurate: 99.9% → 100.0%

Time: 38.5s

Alternatives: 10

Speedup: 1.0×

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

Specification

Math

\[\begin{array}{l} \\ \left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \end{array} \]

FPCore

(FPCore (d1)
 :precision binary64
 (* (* d1 (* (* (* (* (* d1 (* d1 d1)) d1) d1) (* d1 d1)) d1)) d1))

C

double code(double d1) {
	return (d1 * (((((d1 * (d1 * d1)) * d1) * d1) * (d1 * d1)) * d1)) * d1;
}

Fortran

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

Java

public static double code(double d1) {
	return (d1 * (((((d1 * (d1 * d1)) * d1) * d1) * (d1 * d1)) * d1)) * d1;
}

Python

def code(d1):
	return (d1 * (((((d1 * (d1 * d1)) * d1) * d1) * (d1 * d1)) * d1)) * d1

Julia

function code(d1)
	return Float64(Float64(d1 * Float64(Float64(Float64(Float64(Float64(d1 * Float64(d1 * d1)) * d1) * d1) * Float64(d1 * d1)) * d1)) * d1)
end

MATLAB

function tmp = code(d1)
	tmp = (d1 * (((((d1 * (d1 * d1)) * d1) * d1) * (d1 * d1)) * d1)) * d1;
end

Wolfram

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

Initial Program: 99.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \end{array} \]

FPCore

(FPCore (d1)
 :precision binary64
 (* (* d1 (* (* (* (* (* d1 (* d1 d1)) d1) d1) (* d1 d1)) d1)) d1))

C

double code(double d1) {
	return (d1 * (((((d1 * (d1 * d1)) * d1) * d1) * (d1 * d1)) * d1)) * d1;
}

Fortran

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

Java

public static double code(double d1) {
	return (d1 * (((((d1 * (d1 * d1)) * d1) * d1) * (d1 * d1)) * d1)) * d1;
}

Python

def code(d1):
	return (d1 * (((((d1 * (d1 * d1)) * d1) * d1) * (d1 * d1)) * d1)) * d1

Julia

function code(d1)
	return Float64(Float64(d1 * Float64(Float64(Float64(Float64(Float64(d1 * Float64(d1 * d1)) * d1) * d1) * Float64(d1 * d1)) * d1)) * d1)
end

MATLAB

function tmp = code(d1)
	tmp = (d1 * (((((d1 * (d1 * d1)) * d1) * d1) * (d1 * d1)) * d1)) * d1;
end

Wolfram

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

Alternative 1: 100.0% accurate, 0.2× speedup

Math

\[\begin{array}{l} \\ {d1}^{10} \end{array} \]

FPCore

(FPCore (d1) :precision binary64 (pow d1 10.0))

C

double code(double d1) {
	return pow(d1, 10.0);
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    code = d1 ** 10.0d0
end function

Java

public static double code(double d1) {
	return Math.pow(d1, 10.0);
}

Python

def code(d1):
	return math.pow(d1, 10.0)

Julia

function code(d1)
	return d1 ^ 10.0
end

MATLAB

function tmp = code(d1)
	tmp = d1 ^ 10.0;
end

Wolfram

code[d1_] := N[Power[d1, 10.0], $MachinePrecision]

Derivation

1. Initial program 99.8%

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

   1. *-commutative 99.8%

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

   2. associate-*l* 99.8%

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

   3. sqr-neg 99.8%

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

   4. associate-*l* 99.8%

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

   5. sqr-neg 99.8%

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

   6. associate-*r* 99.8%

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

   7. sqr-neg 99.8%

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

   8. associate-*l* 99.8%

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

   9. sqr-neg 99.8%

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

   10. associate-*l* 99.8%

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

3. Simplified 100.0%

   \[\leadsto \color{blue}{{d1}^{10}} \]

4. Final simplification 100.0%

   \[\leadsto {d1}^{10} \]

Alternative 2: 99.9% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ d1 \cdot \left(d1 \cdot \left(d1 \cdot \left(\left(d1 \cdot d1\right) \cdot \left(d1 \cdot \left(d1 \cdot \left(d1 \cdot \left(d1 \cdot d1\right)\right)\right)\right)\right)\right)\right) \end{array} \]

FPCore

(FPCore (d1)
 :precision binary64
 (* d1 (* d1 (* d1 (* (* d1 d1) (* d1 (* d1 (* d1 (* d1 d1)))))))))

C

double code(double d1) {
	return d1 * (d1 * (d1 * ((d1 * d1) * (d1 * (d1 * (d1 * (d1 * d1)))))));
}

Fortran

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

Java

public static double code(double d1) {
	return d1 * (d1 * (d1 * ((d1 * d1) * (d1 * (d1 * (d1 * (d1 * d1)))))));
}

Python

def code(d1):
	return d1 * (d1 * (d1 * ((d1 * d1) * (d1 * (d1 * (d1 * (d1 * d1)))))))

Julia

function code(d1)
	return Float64(d1 * Float64(d1 * Float64(d1 * Float64(Float64(d1 * d1) * Float64(d1 * Float64(d1 * Float64(d1 * Float64(d1 * d1))))))))
end

MATLAB

function tmp = code(d1)
	tmp = d1 * (d1 * (d1 * ((d1 * d1) * (d1 * (d1 * (d1 * (d1 * d1)))))));
end

Wolfram

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

Derivation

1. Initial program 99.8%

   \[\left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \]

2. Final simplification 99.8%

   \[\leadsto d1 \cdot \left(d1 \cdot \left(d1 \cdot \left(\left(d1 \cdot d1\right) \cdot \left(d1 \cdot \left(d1 \cdot \left(d1 \cdot \left(d1 \cdot d1\right)\right)\right)\right)\right)\right)\right) \]

Alternative 3: 64.4% accurate, 1.3× speedup

Math

\[\begin{array}{l} \\ d1 \cdot \left(d1 \cdot \left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot \left(d1 \cdot \left(d1 \cdot 27\right)\right)\right)\right) \end{array} \]

FPCore

(FPCore (d1)
 :precision binary64
 (* d1 (* d1 (* (* d1 (* d1 d1)) (* d1 (* d1 27.0))))))

C

double code(double d1) {
	return d1 * (d1 * ((d1 * (d1 * d1)) * (d1 * (d1 * 27.0))));
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    code = d1 * (d1 * ((d1 * (d1 * d1)) * (d1 * (d1 * 27.0d0))))
end function

Java

public static double code(double d1) {
	return d1 * (d1 * ((d1 * (d1 * d1)) * (d1 * (d1 * 27.0))));
}

Python

def code(d1):
	return d1 * (d1 * ((d1 * (d1 * d1)) * (d1 * (d1 * 27.0))))

Julia

function code(d1)
	return Float64(d1 * Float64(d1 * Float64(Float64(d1 * Float64(d1 * d1)) * Float64(d1 * Float64(d1 * 27.0)))))
end

MATLAB

function tmp = code(d1)
	tmp = d1 * (d1 * ((d1 * (d1 * d1)) * (d1 * (d1 * 27.0))));
end

Wolfram

code[d1_] := N[(d1 * N[(d1 * N[(N[(d1 * N[(d1 * d1), $MachinePrecision]), $MachinePrecision] * N[(d1 * N[(d1 * 27.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.8%

   \[\left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \]

3. Applied egg-rr 63.4%

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

   1. log1p-expm1-u_binary64 64.3%

      \[\leadsto \color{blue}{\left(d1 \cdot \mathsf{log1p}\left(\mathsf{expm1}\left(\left(\left(\left(27 \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right)\right) \cdot d1} \]

5. Applied rewrite-once 64.3%

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

   1. log1p-expm1 63.4%

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

   2. associate-*l* 63.4%

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

   3. *-commutative 63.4%

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

   4. *-commutative 63.4%

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

7. Simplified 63.4%

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

8. Final simplification 63.4%

   \[\leadsto d1 \cdot \left(d1 \cdot \left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot \left(d1 \cdot \left(d1 \cdot 27\right)\right)\right)\right) \]

Alternative 4: 65.5% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d1 \leq 3.7 \cdot 10^{-21}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot \left(d1 \cdot 0\right)\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot \left(27 \cdot \left(d1 \cdot \left(d1 \cdot d1\right)\right)\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1)
 :precision binary64
 (if (<= d1 3.7e-21)
   (* d1 (* d1 (* d1 0.0)))
   (* d1 (* d1 (* 27.0 (* d1 (* d1 d1)))))))

C

double code(double d1) {
	double tmp;
	if (d1 <= 3.7e-21) {
		tmp = d1 * (d1 * (d1 * 0.0));
	} else {
		tmp = d1 * (d1 * (27.0 * (d1 * (d1 * d1))));
	}
	return tmp;
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    real(8) :: tmp
    if (d1 <= 3.7d-21) then
        tmp = d1 * (d1 * (d1 * 0.0d0))
    else
        tmp = d1 * (d1 * (27.0d0 * (d1 * (d1 * d1))))
    end if
    code = tmp
end function

Java

public static double code(double d1) {
	double tmp;
	if (d1 <= 3.7e-21) {
		tmp = d1 * (d1 * (d1 * 0.0));
	} else {
		tmp = d1 * (d1 * (27.0 * (d1 * (d1 * d1))));
	}
	return tmp;
}

Python

def code(d1):
	tmp = 0
	if d1 <= 3.7e-21:
		tmp = d1 * (d1 * (d1 * 0.0))
	else:
		tmp = d1 * (d1 * (27.0 * (d1 * (d1 * d1))))
	return tmp

Julia

function code(d1)
	tmp = 0.0
	if (d1 <= 3.7e-21)
		tmp = Float64(d1 * Float64(d1 * Float64(d1 * 0.0)));
	else
		tmp = Float64(d1 * Float64(d1 * Float64(27.0 * Float64(d1 * Float64(d1 * d1)))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1)
	tmp = 0.0;
	if (d1 <= 3.7e-21)
		tmp = d1 * (d1 * (d1 * 0.0));
	else
		tmp = d1 * (d1 * (27.0 * (d1 * (d1 * d1))));
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_] := If[LessEqual[d1, 3.7e-21], N[(d1 * N[(d1 * N[(d1 * 0.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(d1 * N[(27.0 * N[(d1 * N[(d1 * d1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d1 < 3.7000000000000002e-21

   1. Initial program 99.9%

      \[\left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \]

   3. Applied egg-rr 59.8%

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

   4. Taylor expanded in d1 around 0 60.1%

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

   if 3.7000000000000002e-21 < d1

   1. Initial program 99.7%

      \[\left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \]

   3. Applied egg-rr 73.8%

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

      1. log1p-expm1-u_binary64 76.8%

         \[\leadsto \color{blue}{\left(d1 \cdot \mathsf{log1p}\left(\mathsf{expm1}\left(\left(\left(\left(27 \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right)\right) \cdot d1} \]

   5. Applied rewrite-once 76.8%

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

      1. log1p-expm1 73.8%

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

      2. associate-*l* 73.8%

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

      3. *-commutative 73.8%

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

      4. *-commutative 73.8%

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

   7. Simplified 73.8%

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

   9. Applied egg-rr 69.8%

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

4. Final simplification 63.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;d1 \leq 3.7 \cdot 10^{-21}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot \left(d1 \cdot 0\right)\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot \left(27 \cdot \left(d1 \cdot \left(d1 \cdot d1\right)\right)\right)\right)\\ \end{array} \]

Alternative 5: 58.4% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d1 \leq 9.5 \cdot 10^{-18}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot \left(d1 \cdot 0\right)\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot 27\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1)
 :precision binary64
 (if (<= d1 9.5e-18) (* d1 (* d1 (* d1 0.0))) (* d1 (* d1 27.0))))

C

double code(double d1) {
	double tmp;
	if (d1 <= 9.5e-18) {
		tmp = d1 * (d1 * (d1 * 0.0));
	} else {
		tmp = d1 * (d1 * 27.0);
	}
	return tmp;
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    real(8) :: tmp
    if (d1 <= 9.5d-18) then
        tmp = d1 * (d1 * (d1 * 0.0d0))
    else
        tmp = d1 * (d1 * 27.0d0)
    end if
    code = tmp
end function

Java

public static double code(double d1) {
	double tmp;
	if (d1 <= 9.5e-18) {
		tmp = d1 * (d1 * (d1 * 0.0));
	} else {
		tmp = d1 * (d1 * 27.0);
	}
	return tmp;
}

Python

def code(d1):
	tmp = 0
	if d1 <= 9.5e-18:
		tmp = d1 * (d1 * (d1 * 0.0))
	else:
		tmp = d1 * (d1 * 27.0)
	return tmp

Julia

function code(d1)
	tmp = 0.0
	if (d1 <= 9.5e-18)
		tmp = Float64(d1 * Float64(d1 * Float64(d1 * 0.0)));
	else
		tmp = Float64(d1 * Float64(d1 * 27.0));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1)
	tmp = 0.0;
	if (d1 <= 9.5e-18)
		tmp = d1 * (d1 * (d1 * 0.0));
	else
		tmp = d1 * (d1 * 27.0);
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_] := If[LessEqual[d1, 9.5e-18], N[(d1 * N[(d1 * N[(d1 * 0.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(d1 * 27.0), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d1 < 9.5000000000000003e-18

   1. Initial program 99.9%

      \[\left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \]

   3. Applied egg-rr 59.8%

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

   4. Taylor expanded in d1 around 0 60.1%

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

   if 9.5000000000000003e-18 < d1

   1. Initial program 99.7%

      \[\left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \]

   3. Applied egg-rr 73.8%

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

      1. log1p-expm1-u_binary64 76.8%

         \[\leadsto \color{blue}{\left(d1 \cdot \mathsf{log1p}\left(\mathsf{expm1}\left(\left(\left(\left(27 \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right)\right) \cdot d1} \]

   5. Applied rewrite-once 76.8%

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

      1. log1p-expm1 73.8%

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

      2. associate-*l* 73.8%

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

      3. *-commutative 73.8%

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

      4. *-commutative 73.8%

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

   7. Simplified 73.8%

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

   9. Applied egg-rr 69.8%

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

   11. Applied egg-rr 49.8%

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

4. Final simplification 57.0%

   \[\leadsto \begin{array}{l} \mathbf{if}\;d1 \leq 9.5 \cdot 10^{-18}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot \left(d1 \cdot 0\right)\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot 27\right)\\ \end{array} \]

Alternative 6: 62.1% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d1 \leq 5.5 \cdot 10^{-19}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot \left(d1 \cdot 0\right)\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot \left(d1 \cdot 0.00390625\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1)
 :precision binary64
 (if (<= d1 5.5e-19) (* d1 (* d1 (* d1 0.0))) (* d1 (* d1 (* d1 0.00390625)))))

C

double code(double d1) {
	double tmp;
	if (d1 <= 5.5e-19) {
		tmp = d1 * (d1 * (d1 * 0.0));
	} else {
		tmp = d1 * (d1 * (d1 * 0.00390625));
	}
	return tmp;
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    real(8) :: tmp
    if (d1 <= 5.5d-19) then
        tmp = d1 * (d1 * (d1 * 0.0d0))
    else
        tmp = d1 * (d1 * (d1 * 0.00390625d0))
    end if
    code = tmp
end function

Java

public static double code(double d1) {
	double tmp;
	if (d1 <= 5.5e-19) {
		tmp = d1 * (d1 * (d1 * 0.0));
	} else {
		tmp = d1 * (d1 * (d1 * 0.00390625));
	}
	return tmp;
}

Python

def code(d1):
	tmp = 0
	if d1 <= 5.5e-19:
		tmp = d1 * (d1 * (d1 * 0.0))
	else:
		tmp = d1 * (d1 * (d1 * 0.00390625))
	return tmp

Julia

function code(d1)
	tmp = 0.0
	if (d1 <= 5.5e-19)
		tmp = Float64(d1 * Float64(d1 * Float64(d1 * 0.0)));
	else
		tmp = Float64(d1 * Float64(d1 * Float64(d1 * 0.00390625)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1)
	tmp = 0.0;
	if (d1 <= 5.5e-19)
		tmp = d1 * (d1 * (d1 * 0.0));
	else
		tmp = d1 * (d1 * (d1 * 0.00390625));
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_] := If[LessEqual[d1, 5.5e-19], N[(d1 * N[(d1 * N[(d1 * 0.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(d1 * N[(d1 * 0.00390625), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d1 < 5.4999999999999996e-19

   1. Initial program 99.9%

      \[\left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \]

   3. Applied egg-rr 59.8%

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

   4. Taylor expanded in d1 around 0 60.1%

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

   if 5.4999999999999996e-19 < d1

   1. Initial program 99.7%

      \[\left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \]

   3. Applied egg-rr 73.7%

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

   5. Applied egg-rr 58.6%

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

4. Final simplification 59.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;d1 \leq 5.5 \cdot 10^{-19}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot \left(d1 \cdot 0\right)\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot \left(d1 \cdot 0.00390625\right)\right)\\ \end{array} \]

Alternative 7: 62.2% accurate, 2.1× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;d1 \leq 9.8 \cdot 10^{-19}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot \left(d1 \cdot 0\right)\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot \left(d1 \cdot 64\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (d1)
 :precision binary64
 (if (<= d1 9.8e-19) (* d1 (* d1 (* d1 0.0))) (* d1 (* d1 (* d1 64.0)))))

C

double code(double d1) {
	double tmp;
	if (d1 <= 9.8e-19) {
		tmp = d1 * (d1 * (d1 * 0.0));
	} else {
		tmp = d1 * (d1 * (d1 * 64.0));
	}
	return tmp;
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    real(8) :: tmp
    if (d1 <= 9.8d-19) then
        tmp = d1 * (d1 * (d1 * 0.0d0))
    else
        tmp = d1 * (d1 * (d1 * 64.0d0))
    end if
    code = tmp
end function

Java

public static double code(double d1) {
	double tmp;
	if (d1 <= 9.8e-19) {
		tmp = d1 * (d1 * (d1 * 0.0));
	} else {
		tmp = d1 * (d1 * (d1 * 64.0));
	}
	return tmp;
}

Python

def code(d1):
	tmp = 0
	if d1 <= 9.8e-19:
		tmp = d1 * (d1 * (d1 * 0.0))
	else:
		tmp = d1 * (d1 * (d1 * 64.0))
	return tmp

Julia

function code(d1)
	tmp = 0.0
	if (d1 <= 9.8e-19)
		tmp = Float64(d1 * Float64(d1 * Float64(d1 * 0.0)));
	else
		tmp = Float64(d1 * Float64(d1 * Float64(d1 * 64.0)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(d1)
	tmp = 0.0;
	if (d1 <= 9.8e-19)
		tmp = d1 * (d1 * (d1 * 0.0));
	else
		tmp = d1 * (d1 * (d1 * 64.0));
	end
	tmp_2 = tmp;
end

Wolfram

code[d1_] := If[LessEqual[d1, 9.8e-19], N[(d1 * N[(d1 * N[(d1 * 0.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(d1 * N[(d1 * N[(d1 * 64.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if d1 < 9.79999999999999985e-19

   1. Initial program 99.9%

      \[\left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \]

   3. Applied egg-rr 59.8%

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

   4. Taylor expanded in d1 around 0 60.1%

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

   if 9.79999999999999985e-19 < d1

   1. Initial program 99.7%

      \[\left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \]

   3. Applied egg-rr 1.1%

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

   5. Applied egg-rr 58.6%

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

4. Final simplification 59.6%

   \[\leadsto \begin{array}{l} \mathbf{if}\;d1 \leq 9.8 \cdot 10^{-19}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot \left(d1 \cdot 0\right)\right)\\ \mathbf{else}:\\ \;\;\;\;d1 \cdot \left(d1 \cdot \left(d1 \cdot 64\right)\right)\\ \end{array} \]

Alternative 8: 52.4% accurate, 3.8× speedup

Math

\[\begin{array}{l} \\ d1 \cdot \left(d1 \cdot 27\right) \end{array} \]

FPCore

(FPCore (d1) :precision binary64 (* d1 (* d1 27.0)))

C

double code(double d1) {
	return d1 * (d1 * 27.0);
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    code = d1 * (d1 * 27.0d0)
end function

Java

public static double code(double d1) {
	return d1 * (d1 * 27.0);
}

Python

def code(d1):
	return d1 * (d1 * 27.0)

Julia

function code(d1)
	return Float64(d1 * Float64(d1 * 27.0))
end

MATLAB

function tmp = code(d1)
	tmp = d1 * (d1 * 27.0);
end

Wolfram

code[d1_] := N[(d1 * N[(d1 * 27.0), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 99.8%

   \[\left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \]

3. Applied egg-rr 63.4%

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

   1. log1p-expm1-u_binary64 64.3%

      \[\leadsto \color{blue}{\left(d1 \cdot \mathsf{log1p}\left(\mathsf{expm1}\left(\left(\left(\left(27 \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right)\right) \cdot d1} \]

5. Applied rewrite-once 64.3%

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

   1. log1p-expm1 63.4%

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

   2. associate-*l* 63.4%

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

   3. *-commutative 63.4%

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

   4. *-commutative 63.4%

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

7. Simplified 63.4%

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

9. Applied egg-rr 60.0%

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

11. Applied egg-rr 56.8%

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

12. Final simplification 56.8%

    \[\leadsto d1 \cdot \left(d1 \cdot 27\right) \]

Alternative 9: 3.3% accurate, 19.0× speedup

Math

\[\begin{array}{l} \\ 0.00390625 \end{array} \]

FPCore

(FPCore (d1) :precision binary64 0.00390625)

C

double code(double d1) {
	return 0.00390625;
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    code = 0.00390625d0
end function

Java

public static double code(double d1) {
	return 0.00390625;
}

Python

def code(d1):
	return 0.00390625

Julia

function code(d1)
	return 0.00390625
end

MATLAB

function tmp = code(d1)
	tmp = 0.00390625;
end

Wolfram

code[d1_] := 0.00390625

Derivation

1. Initial program 99.8%

   \[\left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \]

3. Applied egg-rr 63.4%

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

5. Applied egg-rr 53.9%

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

7. Applied egg-rr 3.4%

   \[\leadsto \color{blue}{0.00390625} \]

8. Final simplification 3.4%

   \[\leadsto 0.00390625 \]

Alternative 10: 3.3% accurate, 19.0× speedup

Math

\[\begin{array}{l} \\ 64 \end{array} \]

FPCore

(FPCore (d1) :precision binary64 64.0)

C

double code(double d1) {
	return 64.0;
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    code = 64.0d0
end function

Java

public static double code(double d1) {
	return 64.0;
}

Python

def code(d1):
	return 64.0

Julia

function code(d1)
	return 64.0
end

MATLAB

function tmp = code(d1)
	tmp = 64.0;
end

Wolfram

code[d1_] := 64.0

Derivation

1. Initial program 99.8%

   \[\left(d1 \cdot \left(\left(\left(\left(\left(d1 \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right) \cdot d1\right) \cdot \left(d1 \cdot d1\right)\right) \cdot d1\right)\right) \cdot d1 \]

3. Applied egg-rr 42.1%

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

5. Applied egg-rr 53.8%

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

7. Applied egg-rr 3.4%

   \[\leadsto \color{blue}{64} \]

8. Final simplification 3.4%

   \[\leadsto 64 \]

Developer target: 100.0% accurate, 0.2× speedup

Math

\[\begin{array}{l} \\ {d1}^{10} \end{array} \]

FPCore

(FPCore (d1) :precision binary64 (pow d1 10.0))

C

double code(double d1) {
	return pow(d1, 10.0);
}

Fortran

real(8) function code(d1)
    real(8), intent (in) :: d1
    code = d1 ** 10.0d0
end function

Java

public static double code(double d1) {
	return Math.pow(d1, 10.0);
}

Python

def code(d1):
	return math.pow(d1, 10.0)

Julia

function code(d1)
	return d1 ^ 10.0
end

MATLAB

function tmp = code(d1)
	tmp = d1 ^ 10.0;
end

Wolfram

code[d1_] := N[Power[d1, 10.0], $MachinePrecision]

Reproduce

herbie shell --seed 2023297 
(FPCore (d1)
  :name "FastMath test5"
  :precision binary64

  :herbie-target
  (pow d1 10.0)

  (* (* d1 (* (* (* (* (* d1 (* d1 d1)) d1) d1) (* d1 d1)) d1)) d1))