Falkner and Boettcher, Appendix A

Percentage Accurate: 90.0% → 99.0%

Time: 11.0s

Alternatives: 9

Speedup: 1.0×

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

• could not determine a ground truth

  1. a = -1.9999999999999999e-154
  2. k = 0.0
  3. m = -2.00000000000000007e154

Specification

Math

\[\begin{array}{l} \\ \frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \end{array} \]

FPCore

(FPCore (a k m)
 :precision binary64
 (/ (* a (pow k m)) (+ (+ 1.0 (* 10.0 k)) (* k k))))

C

double code(double a, double k, double m) {
	return (a * pow(k, m)) / ((1.0 + (10.0 * k)) + (k * k));
}

Fortran

real(8) function code(a, k, m)
    real(8), intent (in) :: a
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    code = (a * (k ** m)) / ((1.0d0 + (10.0d0 * k)) + (k * k))
end function

Java

public static double code(double a, double k, double m) {
	return (a * Math.pow(k, m)) / ((1.0 + (10.0 * k)) + (k * k));
}

Python

def code(a, k, m):
	return (a * math.pow(k, m)) / ((1.0 + (10.0 * k)) + (k * k))

Julia

function code(a, k, m)
	return Float64(Float64(a * (k ^ m)) / Float64(Float64(1.0 + Float64(10.0 * k)) + Float64(k * k)))
end

MATLAB

function tmp = code(a, k, m)
	tmp = (a * (k ^ m)) / ((1.0 + (10.0 * k)) + (k * k));
end

Wolfram

code[a_, k_, m_] := N[(N[(a * N[Power[k, m], $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + N[(10.0 * k), $MachinePrecision]), $MachinePrecision] + N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 90.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \end{array} \]

FPCore

(FPCore (a k m)
 :precision binary64
 (/ (* a (pow k m)) (+ (+ 1.0 (* 10.0 k)) (* k k))))

C

double code(double a, double k, double m) {
	return (a * pow(k, m)) / ((1.0 + (10.0 * k)) + (k * k));
}

Fortran

real(8) function code(a, k, m)
    real(8), intent (in) :: a
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    code = (a * (k ** m)) / ((1.0d0 + (10.0d0 * k)) + (k * k))
end function

Java

public static double code(double a, double k, double m) {
	return (a * Math.pow(k, m)) / ((1.0 + (10.0 * k)) + (k * k));
}

Python

def code(a, k, m):
	return (a * math.pow(k, m)) / ((1.0 + (10.0 * k)) + (k * k))

Julia

function code(a, k, m)
	return Float64(Float64(a * (k ^ m)) / Float64(Float64(1.0 + Float64(10.0 * k)) + Float64(k * k)))
end

MATLAB

function tmp = code(a, k, m)
	tmp = (a * (k ^ m)) / ((1.0 + (10.0 * k)) + (k * k));
end

Wolfram

code[a_, k_, m_] := N[(N[(a * N[Power[k, m], $MachinePrecision]), $MachinePrecision] / N[(N[(1.0 + N[(10.0 * k), $MachinePrecision]), $MachinePrecision] + N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 99.0% accurate, 0.4× speedup

Math

\[\begin{array}{l} \\ \frac{a \cdot \frac{{k}^{m}}{\mathsf{hypot}\left(1, k\right)}}{\mathsf{hypot}\left(1, k\right)} \end{array} \]

FPCore

(FPCore (a k m)
 :precision binary64
 (/ (* a (/ (pow k m) (hypot 1.0 k))) (hypot 1.0 k)))

C

double code(double a, double k, double m) {
	return (a * (pow(k, m) / hypot(1.0, k))) / hypot(1.0, k);
}

Java

public static double code(double a, double k, double m) {
	return (a * (Math.pow(k, m) / Math.hypot(1.0, k))) / Math.hypot(1.0, k);
}

Python

def code(a, k, m):
	return (a * (math.pow(k, m) / math.hypot(1.0, k))) / math.hypot(1.0, k)

Julia

function code(a, k, m)
	return Float64(Float64(a * Float64((k ^ m) / hypot(1.0, k))) / hypot(1.0, k))
end

MATLAB

function tmp = code(a, k, m)
	tmp = (a * ((k ^ m) / hypot(1.0, k))) / hypot(1.0, k);
end

Wolfram

code[a_, k_, m_] := N[(N[(a * N[(N[Power[k, m], $MachinePrecision] / N[Sqrt[1.0 ^ 2 + k ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Sqrt[1.0 ^ 2 + k ^ 2], $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 89.4%

   \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
2. Step-by-step derivation

   1. *-commutative 89.4%

      \[\leadsto \frac{a \cdot {k}^{m}}{\left(1 + \color{blue}{k \cdot 10}\right) + k \cdot k} \]

3. Simplified 89.4%

   \[\leadsto \color{blue}{\frac{a \cdot {k}^{m}}{\left(1 + k \cdot 10\right) + k \cdot k}} \]
4. Add Preprocessing

5. Taylor expanded in k around 0 89.0%

   \[\leadsto \frac{a \cdot {k}^{m}}{\color{blue}{1} + k \cdot k} \]
6. Step-by-step derivation

   1. add-sqr-sqrt 67.8%

      \[\leadsto \color{blue}{\sqrt{\frac{a \cdot {k}^{m}}{1 + k \cdot k}} \cdot \sqrt{\frac{a \cdot {k}^{m}}{1 + k \cdot k}}} \]

   2. sqrt-div 64.4%

      \[\leadsto \color{blue}{\frac{\sqrt{a \cdot {k}^{m}}}{\sqrt{1 + k \cdot k}}} \cdot \sqrt{\frac{a \cdot {k}^{m}}{1 + k \cdot k}} \]

   3. hypot-1-def 64.4%

      \[\leadsto \frac{\sqrt{a \cdot {k}^{m}}}{\color{blue}{\mathsf{hypot}\left(1, k\right)}} \cdot \sqrt{\frac{a \cdot {k}^{m}}{1 + k \cdot k}} \]

   4. sqrt-div 64.3%

      \[\leadsto \frac{\sqrt{a \cdot {k}^{m}}}{\mathsf{hypot}\left(1, k\right)} \cdot \color{blue}{\frac{\sqrt{a \cdot {k}^{m}}}{\sqrt{1 + k \cdot k}}} \]

   5. hypot-1-def 69.7%

      \[\leadsto \frac{\sqrt{a \cdot {k}^{m}}}{\mathsf{hypot}\left(1, k\right)} \cdot \frac{\sqrt{a \cdot {k}^{m}}}{\color{blue}{\mathsf{hypot}\left(1, k\right)}} \]

7. Applied egg-rr 69.7%

   \[\leadsto \color{blue}{\frac{\sqrt{a \cdot {k}^{m}}}{\mathsf{hypot}\left(1, k\right)} \cdot \frac{\sqrt{a \cdot {k}^{m}}}{\mathsf{hypot}\left(1, k\right)}} \]
8. Step-by-step derivation

   1. unpow2 69.7%

      \[\leadsto \color{blue}{{\left(\frac{\sqrt{a \cdot {k}^{m}}}{\mathsf{hypot}\left(1, k\right)}\right)}^{2}} \]

9. Simplified 69.7%

   \[\leadsto \color{blue}{{\left(\frac{\sqrt{a \cdot {k}^{m}}}{\mathsf{hypot}\left(1, k\right)}\right)}^{2}} \]
10. Step-by-step derivation

    1. unpow2 69.7%

       \[\leadsto \color{blue}{\frac{\sqrt{a \cdot {k}^{m}}}{\mathsf{hypot}\left(1, k\right)} \cdot \frac{\sqrt{a \cdot {k}^{m}}}{\mathsf{hypot}\left(1, k\right)}} \]

    2. associate-*r/ 69.7%

       \[\leadsto \color{blue}{\frac{\frac{\sqrt{a \cdot {k}^{m}}}{\mathsf{hypot}\left(1, k\right)} \cdot \sqrt{a \cdot {k}^{m}}}{\mathsf{hypot}\left(1, k\right)}} \]

11. Applied egg-rr 69.7%

    \[\leadsto \color{blue}{\frac{\frac{\sqrt{a \cdot {k}^{m}}}{\mathsf{hypot}\left(1, k\right)} \cdot \sqrt{a \cdot {k}^{m}}}{\mathsf{hypot}\left(1, k\right)}} \]
12. Step-by-step derivation

    1. associate-*l/ 69.7%

       \[\leadsto \frac{\color{blue}{\frac{\sqrt{a \cdot {k}^{m}} \cdot \sqrt{a \cdot {k}^{m}}}{\mathsf{hypot}\left(1, k\right)}}}{\mathsf{hypot}\left(1, k\right)} \]

    2. add-sqr-sqrt 99.5%

       \[\leadsto \frac{\frac{\color{blue}{a \cdot {k}^{m}}}{\mathsf{hypot}\left(1, k\right)}}{\mathsf{hypot}\left(1, k\right)} \]

13. Applied egg-rr 99.5%

    \[\leadsto \frac{\color{blue}{\frac{a \cdot {k}^{m}}{\mathsf{hypot}\left(1, k\right)}}}{\mathsf{hypot}\left(1, k\right)} \]
14. Step-by-step derivation

    1. associate-/l* 99.5%

       \[\leadsto \frac{\color{blue}{a \cdot \frac{{k}^{m}}{\mathsf{hypot}\left(1, k\right)}}}{\mathsf{hypot}\left(1, k\right)} \]

15. Simplified 99.5%

    \[\leadsto \frac{\color{blue}{a \cdot \frac{{k}^{m}}{\mathsf{hypot}\left(1, k\right)}}}{\mathsf{hypot}\left(1, k\right)} \]
16. Add Preprocessing

Alternative 2: 98.4% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := a \cdot {k}^{m}\\ \mathbf{if}\;\frac{t\_0}{\left(1 + k \cdot 10\right) + k \cdot k} \leq 10^{+159}:\\ \;\;\;\;\frac{{k}^{m}}{\mathsf{hypot}\left(1, k\right)} \cdot \frac{a}{\mathsf{hypot}\left(1, k\right)}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (a k m)
 :precision binary64
 (let* ((t_0 (* a (pow k m))))
   (if (<= (/ t_0 (+ (+ 1.0 (* k 10.0)) (* k k))) 1e+159)
     (* (/ (pow k m) (hypot 1.0 k)) (/ a (hypot 1.0 k)))
     t_0)))

C

double code(double a, double k, double m) {
	double t_0 = a * pow(k, m);
	double tmp;
	if ((t_0 / ((1.0 + (k * 10.0)) + (k * k))) <= 1e+159) {
		tmp = (pow(k, m) / hypot(1.0, k)) * (a / hypot(1.0, k));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Java

public static double code(double a, double k, double m) {
	double t_0 = a * Math.pow(k, m);
	double tmp;
	if ((t_0 / ((1.0 + (k * 10.0)) + (k * k))) <= 1e+159) {
		tmp = (Math.pow(k, m) / Math.hypot(1.0, k)) * (a / Math.hypot(1.0, k));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(a, k, m):
	t_0 = a * math.pow(k, m)
	tmp = 0
	if (t_0 / ((1.0 + (k * 10.0)) + (k * k))) <= 1e+159:
		tmp = (math.pow(k, m) / math.hypot(1.0, k)) * (a / math.hypot(1.0, k))
	else:
		tmp = t_0
	return tmp

Julia

function code(a, k, m)
	t_0 = Float64(a * (k ^ m))
	tmp = 0.0
	if (Float64(t_0 / Float64(Float64(1.0 + Float64(k * 10.0)) + Float64(k * k))) <= 1e+159)
		tmp = Float64(Float64((k ^ m) / hypot(1.0, k)) * Float64(a / hypot(1.0, k)));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, k, m)
	t_0 = a * (k ^ m);
	tmp = 0.0;
	if ((t_0 / ((1.0 + (k * 10.0)) + (k * k))) <= 1e+159)
		tmp = ((k ^ m) / hypot(1.0, k)) * (a / hypot(1.0, k));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, k_, m_] := Block[{t$95$0 = N[(a * N[Power[k, m], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[(t$95$0 / N[(N[(1.0 + N[(k * 10.0), $MachinePrecision]), $MachinePrecision] + N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1e+159], N[(N[(N[Power[k, m], $MachinePrecision] / N[Sqrt[1.0 ^ 2 + k ^ 2], $MachinePrecision]), $MachinePrecision] * N[(a / N[Sqrt[1.0 ^ 2 + k ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]

Derivation

1. Split input into 2 regimes

2. if (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 10 binary64) k)) (*.f64 k k))) < 9.9999999999999993e158

   1. Initial program 96.1%

      \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
   2. Step-by-step derivation

      1. *-commutative 96.1%

         \[\leadsto \frac{a \cdot {k}^{m}}{\left(1 + \color{blue}{k \cdot 10}\right) + k \cdot k} \]

   3. Simplified 96.1%

      \[\leadsto \color{blue}{\frac{a \cdot {k}^{m}}{\left(1 + k \cdot 10\right) + k \cdot k}} \]
   4. Add Preprocessing

   5. Taylor expanded in k around 0 95.6%

      \[\leadsto \frac{a \cdot {k}^{m}}{\color{blue}{1} + k \cdot k} \]
   6. Step-by-step derivation

      1. *-commutative 95.6%

         \[\leadsto \frac{\color{blue}{{k}^{m} \cdot a}}{1 + k \cdot k} \]

      2. add-sqr-sqrt 95.6%

         \[\leadsto \frac{{k}^{m} \cdot a}{\color{blue}{\sqrt{1 + k \cdot k} \cdot \sqrt{1 + k \cdot k}}} \]

      3. times-frac 94.6%

         \[\leadsto \color{blue}{\frac{{k}^{m}}{\sqrt{1 + k \cdot k}} \cdot \frac{a}{\sqrt{1 + k \cdot k}}} \]

      4. hypot-1-def 94.6%

         \[\leadsto \frac{{k}^{m}}{\color{blue}{\mathsf{hypot}\left(1, k\right)}} \cdot \frac{a}{\sqrt{1 + k \cdot k}} \]

      5. hypot-1-def 98.4%

         \[\leadsto \frac{{k}^{m}}{\mathsf{hypot}\left(1, k\right)} \cdot \frac{a}{\color{blue}{\mathsf{hypot}\left(1, k\right)}} \]

   7. Applied egg-rr 98.4%

      \[\leadsto \color{blue}{\frac{{k}^{m}}{\mathsf{hypot}\left(1, k\right)} \cdot \frac{a}{\mathsf{hypot}\left(1, k\right)}} \]

   if 9.9999999999999993e158 < (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 10 binary64) k)) (*.f64 k k)))

   1. Initial program 63.5%

      \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
   2. Step-by-step derivation

      1. *-commutative 63.5%

         \[\leadsto \frac{a \cdot {k}^{m}}{\left(1 + \color{blue}{k \cdot 10}\right) + k \cdot k} \]

   3. Simplified 63.5%

      \[\leadsto \color{blue}{\frac{a \cdot {k}^{m}}{\left(1 + k \cdot 10\right) + k \cdot k}} \]
   4. Add Preprocessing

   5. Taylor expanded in k around 0 100.0%

      \[\leadsto \color{blue}{a \cdot {k}^{m}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 98.7%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{a \cdot {k}^{m}}{\left(1 + k \cdot 10\right) + k \cdot k} \leq 10^{+159}:\\ \;\;\;\;\frac{{k}^{m}}{\mathsf{hypot}\left(1, k\right)} \cdot \frac{a}{\mathsf{hypot}\left(1, k\right)}\\ \mathbf{else}:\\ \;\;\;\;a \cdot {k}^{m}\\ \end{array} \]
5. Add Preprocessing

Alternative 3: 97.5% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := a \cdot {k}^{m}\\ t_1 := \frac{t\_0}{\left(1 + k \cdot 10\right) + k \cdot k}\\ \mathbf{if}\;t\_1 \leq 10^{+159}:\\ \;\;\;\;t\_1\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (a k m)
 :precision binary64
 (let* ((t_0 (* a (pow k m))) (t_1 (/ t_0 (+ (+ 1.0 (* k 10.0)) (* k k)))))
   (if (<= t_1 1e+159) t_1 t_0)))

C

double code(double a, double k, double m) {
	double t_0 = a * pow(k, m);
	double t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k));
	double tmp;
	if (t_1 <= 1e+159) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(a, k, m)
    real(8), intent (in) :: a
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = a * (k ** m)
    t_1 = t_0 / ((1.0d0 + (k * 10.0d0)) + (k * k))
    if (t_1 <= 1d+159) then
        tmp = t_1
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double a, double k, double m) {
	double t_0 = a * Math.pow(k, m);
	double t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k));
	double tmp;
	if (t_1 <= 1e+159) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(a, k, m):
	t_0 = a * math.pow(k, m)
	t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k))
	tmp = 0
	if t_1 <= 1e+159:
		tmp = t_1
	else:
		tmp = t_0
	return tmp

Julia

function code(a, k, m)
	t_0 = Float64(a * (k ^ m))
	t_1 = Float64(t_0 / Float64(Float64(1.0 + Float64(k * 10.0)) + Float64(k * k)))
	tmp = 0.0
	if (t_1 <= 1e+159)
		tmp = t_1;
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, k, m)
	t_0 = a * (k ^ m);
	t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k));
	tmp = 0.0;
	if (t_1 <= 1e+159)
		tmp = t_1;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, k_, m_] := Block[{t$95$0 = N[(a * N[Power[k, m], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 / N[(N[(1.0 + N[(k * 10.0), $MachinePrecision]), $MachinePrecision] + N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, 1e+159], t$95$1, t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 10 binary64) k)) (*.f64 k k))) < 9.9999999999999993e158

   1. Initial program 96.1%

      \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
   2. Add Preprocessing

   if 9.9999999999999993e158 < (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 #s(literal 1 binary64) (*.f64 #s(literal 10 binary64) k)) (*.f64 k k)))

   1. Initial program 63.5%

      \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
   2. Step-by-step derivation

      1. *-commutative 63.5%

         \[\leadsto \frac{a \cdot {k}^{m}}{\left(1 + \color{blue}{k \cdot 10}\right) + k \cdot k} \]

   3. Simplified 63.5%

      \[\leadsto \color{blue}{\frac{a \cdot {k}^{m}}{\left(1 + k \cdot 10\right) + k \cdot k}} \]
   4. Add Preprocessing

   5. Taylor expanded in k around 0 100.0%

      \[\leadsto \color{blue}{a \cdot {k}^{m}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 96.9%

   \[\leadsto \begin{array}{l} \mathbf{if}\;\frac{a \cdot {k}^{m}}{\left(1 + k \cdot 10\right) + k \cdot k} \leq 10^{+159}:\\ \;\;\;\;\frac{a \cdot {k}^{m}}{\left(1 + k \cdot 10\right) + k \cdot k}\\ \mathbf{else}:\\ \;\;\;\;a \cdot {k}^{m}\\ \end{array} \]
5. Add Preprocessing

Alternative 4: 97.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;m \leq 1.7 \cdot 10^{-8}:\\ \;\;\;\;a \cdot \frac{{k}^{m}}{1 + k \cdot \left(k + 10\right)}\\ \mathbf{else}:\\ \;\;\;\;a \cdot {k}^{m}\\ \end{array} \end{array} \]

FPCore

(FPCore (a k m)
 :precision binary64
 (if (<= m 1.7e-8)
   (* a (/ (pow k m) (+ 1.0 (* k (+ k 10.0)))))
   (* a (pow k m))))

C

double code(double a, double k, double m) {
	double tmp;
	if (m <= 1.7e-8) {
		tmp = a * (pow(k, m) / (1.0 + (k * (k + 10.0))));
	} else {
		tmp = a * pow(k, m);
	}
	return tmp;
}

Fortran

real(8) function code(a, k, m)
    real(8), intent (in) :: a
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: tmp
    if (m <= 1.7d-8) then
        tmp = a * ((k ** m) / (1.0d0 + (k * (k + 10.0d0))))
    else
        tmp = a * (k ** m)
    end if
    code = tmp
end function

Java

public static double code(double a, double k, double m) {
	double tmp;
	if (m <= 1.7e-8) {
		tmp = a * (Math.pow(k, m) / (1.0 + (k * (k + 10.0))));
	} else {
		tmp = a * Math.pow(k, m);
	}
	return tmp;
}

Python

def code(a, k, m):
	tmp = 0
	if m <= 1.7e-8:
		tmp = a * (math.pow(k, m) / (1.0 + (k * (k + 10.0))))
	else:
		tmp = a * math.pow(k, m)
	return tmp

Julia

function code(a, k, m)
	tmp = 0.0
	if (m <= 1.7e-8)
		tmp = Float64(a * Float64((k ^ m) / Float64(1.0 + Float64(k * Float64(k + 10.0)))));
	else
		tmp = Float64(a * (k ^ m));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, k, m)
	tmp = 0.0;
	if (m <= 1.7e-8)
		tmp = a * ((k ^ m) / (1.0 + (k * (k + 10.0))));
	else
		tmp = a * (k ^ m);
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, k_, m_] := If[LessEqual[m, 1.7e-8], N[(a * N[(N[Power[k, m], $MachinePrecision] / N[(1.0 + N[(k * N[(k + 10.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(a * N[Power[k, m], $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if m < 1.7e-8

   1. Initial program 95.3%

      \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
   2. Step-by-step derivation

      1. associate-/l* 95.3%

         \[\leadsto \color{blue}{a \cdot \frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k}} \]

      2. remove-double-neg 95.3%

         \[\leadsto a \cdot \color{blue}{\left(-\left(-\frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k}\right)\right)} \]

      3. distribute-frac-neg2 95.3%

         \[\leadsto a \cdot \left(-\color{blue}{\frac{{k}^{m}}{-\left(\left(1 + 10 \cdot k\right) + k \cdot k\right)}}\right) \]

      4. distribute-neg-frac2 95.3%

         \[\leadsto a \cdot \color{blue}{\frac{{k}^{m}}{-\left(-\left(\left(1 + 10 \cdot k\right) + k \cdot k\right)\right)}} \]

      5. remove-double-neg 95.3%

         \[\leadsto a \cdot \frac{{k}^{m}}{\color{blue}{\left(1 + 10 \cdot k\right) + k \cdot k}} \]

      6. sqr-neg 95.3%

         \[\leadsto a \cdot \frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + \color{blue}{\left(-k\right) \cdot \left(-k\right)}} \]

      7. associate-+l+ 95.3%

         \[\leadsto a \cdot \frac{{k}^{m}}{\color{blue}{1 + \left(10 \cdot k + \left(-k\right) \cdot \left(-k\right)\right)}} \]

      8. sqr-neg 95.3%

         \[\leadsto a \cdot \frac{{k}^{m}}{1 + \left(10 \cdot k + \color{blue}{k \cdot k}\right)} \]

      9. distribute-rgt-out 95.3%

         \[\leadsto a \cdot \frac{{k}^{m}}{1 + \color{blue}{k \cdot \left(10 + k\right)}} \]

   3. Simplified 95.3%

      \[\leadsto \color{blue}{a \cdot \frac{{k}^{m}}{1 + k \cdot \left(10 + k\right)}} \]
   4. Add Preprocessing

   if 1.7e-8 < m

   1. Initial program 77.6%

      \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
   2. Step-by-step derivation

      1. *-commutative 77.6%

         \[\leadsto \frac{a \cdot {k}^{m}}{\left(1 + \color{blue}{k \cdot 10}\right) + k \cdot k} \]

   3. Simplified 77.6%

      \[\leadsto \color{blue}{\frac{a \cdot {k}^{m}}{\left(1 + k \cdot 10\right) + k \cdot k}} \]
   4. Add Preprocessing

   5. Taylor expanded in k around 0 100.0%

      \[\leadsto \color{blue}{a \cdot {k}^{m}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 96.8%

   \[\leadsto \begin{array}{l} \mathbf{if}\;m \leq 1.7 \cdot 10^{-8}:\\ \;\;\;\;a \cdot \frac{{k}^{m}}{1 + k \cdot \left(k + 10\right)}\\ \mathbf{else}:\\ \;\;\;\;a \cdot {k}^{m}\\ \end{array} \]
5. Add Preprocessing

Alternative 5: 96.6% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := a \cdot {k}^{m}\\ \mathbf{if}\;m \leq 1.7 \cdot 10^{-8}:\\ \;\;\;\;\frac{t\_0}{1 + k \cdot k}\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (a k m)
 :precision binary64
 (let* ((t_0 (* a (pow k m)))) (if (<= m 1.7e-8) (/ t_0 (+ 1.0 (* k k))) t_0)))

C

double code(double a, double k, double m) {
	double t_0 = a * pow(k, m);
	double tmp;
	if (m <= 1.7e-8) {
		tmp = t_0 / (1.0 + (k * k));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Fortran

real(8) function code(a, k, m)
    real(8), intent (in) :: a
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: t_0
    real(8) :: tmp
    t_0 = a * (k ** m)
    if (m <= 1.7d-8) then
        tmp = t_0 / (1.0d0 + (k * k))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double a, double k, double m) {
	double t_0 = a * Math.pow(k, m);
	double tmp;
	if (m <= 1.7e-8) {
		tmp = t_0 / (1.0 + (k * k));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(a, k, m):
	t_0 = a * math.pow(k, m)
	tmp = 0
	if m <= 1.7e-8:
		tmp = t_0 / (1.0 + (k * k))
	else:
		tmp = t_0
	return tmp

Julia

function code(a, k, m)
	t_0 = Float64(a * (k ^ m))
	tmp = 0.0
	if (m <= 1.7e-8)
		tmp = Float64(t_0 / Float64(1.0 + Float64(k * k)));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, k, m)
	t_0 = a * (k ^ m);
	tmp = 0.0;
	if (m <= 1.7e-8)
		tmp = t_0 / (1.0 + (k * k));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, k_, m_] := Block[{t$95$0 = N[(a * N[Power[k, m], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[m, 1.7e-8], N[(t$95$0 / N[(1.0 + N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]

Derivation

1. Split input into 2 regimes

2. if m < 1.7e-8

   1. Initial program 95.3%

      \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
   2. Step-by-step derivation

      1. *-commutative 95.3%

         \[\leadsto \frac{a \cdot {k}^{m}}{\left(1 + \color{blue}{k \cdot 10}\right) + k \cdot k} \]

   3. Simplified 95.3%

      \[\leadsto \color{blue}{\frac{a \cdot {k}^{m}}{\left(1 + k \cdot 10\right) + k \cdot k}} \]
   4. Add Preprocessing

   5. Taylor expanded in k around 0 94.7%

      \[\leadsto \frac{a \cdot {k}^{m}}{\color{blue}{1} + k \cdot k} \]

   if 1.7e-8 < m

   1. Initial program 77.6%

      \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
   2. Step-by-step derivation

      1. *-commutative 77.6%

         \[\leadsto \frac{a \cdot {k}^{m}}{\left(1 + \color{blue}{k \cdot 10}\right) + k \cdot k} \]

   3. Simplified 77.6%

      \[\leadsto \color{blue}{\frac{a \cdot {k}^{m}}{\left(1 + k \cdot 10\right) + k \cdot k}} \]
   4. Add Preprocessing

   5. Taylor expanded in k around 0 100.0%

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

Alternative 6: 97.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;m \leq -0.028 \lor \neg \left(m \leq 5 \cdot 10^{-9}\right):\\ \;\;\;\;a \cdot {k}^{m}\\ \mathbf{else}:\\ \;\;\;\;\frac{a}{1 + k \cdot \left(k + 10\right)}\\ \end{array} \end{array} \]

FPCore

(FPCore (a k m)
 :precision binary64
 (if (or (<= m -0.028) (not (<= m 5e-9)))
   (* a (pow k m))
   (/ a (+ 1.0 (* k (+ k 10.0))))))

C

double code(double a, double k, double m) {
	double tmp;
	if ((m <= -0.028) || !(m <= 5e-9)) {
		tmp = a * pow(k, m);
	} else {
		tmp = a / (1.0 + (k * (k + 10.0)));
	}
	return tmp;
}

Fortran

real(8) function code(a, k, m)
    real(8), intent (in) :: a
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: tmp
    if ((m <= (-0.028d0)) .or. (.not. (m <= 5d-9))) then
        tmp = a * (k ** m)
    else
        tmp = a / (1.0d0 + (k * (k + 10.0d0)))
    end if
    code = tmp
end function

Java

public static double code(double a, double k, double m) {
	double tmp;
	if ((m <= -0.028) || !(m <= 5e-9)) {
		tmp = a * Math.pow(k, m);
	} else {
		tmp = a / (1.0 + (k * (k + 10.0)));
	}
	return tmp;
}

Python

def code(a, k, m):
	tmp = 0
	if (m <= -0.028) or not (m <= 5e-9):
		tmp = a * math.pow(k, m)
	else:
		tmp = a / (1.0 + (k * (k + 10.0)))
	return tmp

Julia

function code(a, k, m)
	tmp = 0.0
	if ((m <= -0.028) || !(m <= 5e-9))
		tmp = Float64(a * (k ^ m));
	else
		tmp = Float64(a / Float64(1.0 + Float64(k * Float64(k + 10.0))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, k, m)
	tmp = 0.0;
	if ((m <= -0.028) || ~((m <= 5e-9)))
		tmp = a * (k ^ m);
	else
		tmp = a / (1.0 + (k * (k + 10.0)));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, k_, m_] := If[Or[LessEqual[m, -0.028], N[Not[LessEqual[m, 5e-9]], $MachinePrecision]], N[(a * N[Power[k, m], $MachinePrecision]), $MachinePrecision], N[(a / N[(1.0 + N[(k * N[(k + 10.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if m < -0.0280000000000000006 or 5.0000000000000001e-9 < m

   1. Initial program 88.9%

      \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
   2. Step-by-step derivation

      1. *-commutative 88.9%

         \[\leadsto \frac{a \cdot {k}^{m}}{\left(1 + \color{blue}{k \cdot 10}\right) + k \cdot k} \]

   3. Simplified 88.9%

      \[\leadsto \color{blue}{\frac{a \cdot {k}^{m}}{\left(1 + k \cdot 10\right) + k \cdot k}} \]
   4. Add Preprocessing

   5. Taylor expanded in k around 0 100.0%

      \[\leadsto \color{blue}{a \cdot {k}^{m}} \]

   if -0.0280000000000000006 < m < 5.0000000000000001e-9

   1. Initial program 90.6%

      \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
   2. Step-by-step derivation

      1. associate-/l* 90.5%

         \[\leadsto \color{blue}{a \cdot \frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k}} \]

      2. remove-double-neg 90.5%

         \[\leadsto a \cdot \color{blue}{\left(-\left(-\frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k}\right)\right)} \]

      3. distribute-frac-neg2 90.5%

         \[\leadsto a \cdot \left(-\color{blue}{\frac{{k}^{m}}{-\left(\left(1 + 10 \cdot k\right) + k \cdot k\right)}}\right) \]

      4. distribute-neg-frac2 90.5%

         \[\leadsto a \cdot \color{blue}{\frac{{k}^{m}}{-\left(-\left(\left(1 + 10 \cdot k\right) + k \cdot k\right)\right)}} \]

      5. remove-double-neg 90.5%

         \[\leadsto a \cdot \frac{{k}^{m}}{\color{blue}{\left(1 + 10 \cdot k\right) + k \cdot k}} \]

      6. sqr-neg 90.5%

         \[\leadsto a \cdot \frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + \color{blue}{\left(-k\right) \cdot \left(-k\right)}} \]

      7. associate-+l+ 90.5%

         \[\leadsto a \cdot \frac{{k}^{m}}{\color{blue}{1 + \left(10 \cdot k + \left(-k\right) \cdot \left(-k\right)\right)}} \]

      8. sqr-neg 90.5%

         \[\leadsto a \cdot \frac{{k}^{m}}{1 + \left(10 \cdot k + \color{blue}{k \cdot k}\right)} \]

      9. distribute-rgt-out 90.5%

         \[\leadsto a \cdot \frac{{k}^{m}}{1 + \color{blue}{k \cdot \left(10 + k\right)}} \]

   3. Simplified 90.5%

      \[\leadsto \color{blue}{a \cdot \frac{{k}^{m}}{1 + k \cdot \left(10 + k\right)}} \]
   4. Add Preprocessing

   5. Taylor expanded in m around 0 89.5%

      \[\leadsto \color{blue}{\frac{a}{1 + k \cdot \left(10 + k\right)}} \]
3. Recombined 2 regimes into one program.

4. Final simplification 96.5%

   \[\leadsto \begin{array}{l} \mathbf{if}\;m \leq -0.028 \lor \neg \left(m \leq 5 \cdot 10^{-9}\right):\\ \;\;\;\;a \cdot {k}^{m}\\ \mathbf{else}:\\ \;\;\;\;\frac{a}{1 + k \cdot \left(k + 10\right)}\\ \end{array} \]
5. Add Preprocessing

Alternative 7: 53.2% accurate, 6.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;m \leq 1.75:\\ \;\;\;\;\frac{a}{1 + k \cdot \left(k + 10\right)}\\ \mathbf{else}:\\ \;\;\;\;a + k \cdot \left(99 \cdot \left(a \cdot k\right) + a \cdot -10\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (a k m)
 :precision binary64
 (if (<= m 1.75)
   (/ a (+ 1.0 (* k (+ k 10.0))))
   (+ a (* k (+ (* 99.0 (* a k)) (* a -10.0))))))

C

double code(double a, double k, double m) {
	double tmp;
	if (m <= 1.75) {
		tmp = a / (1.0 + (k * (k + 10.0)));
	} else {
		tmp = a + (k * ((99.0 * (a * k)) + (a * -10.0)));
	}
	return tmp;
}

Fortran

real(8) function code(a, k, m)
    real(8), intent (in) :: a
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: tmp
    if (m <= 1.75d0) then
        tmp = a / (1.0d0 + (k * (k + 10.0d0)))
    else
        tmp = a + (k * ((99.0d0 * (a * k)) + (a * (-10.0d0))))
    end if
    code = tmp
end function

Java

public static double code(double a, double k, double m) {
	double tmp;
	if (m <= 1.75) {
		tmp = a / (1.0 + (k * (k + 10.0)));
	} else {
		tmp = a + (k * ((99.0 * (a * k)) + (a * -10.0)));
	}
	return tmp;
}

Python

def code(a, k, m):
	tmp = 0
	if m <= 1.75:
		tmp = a / (1.0 + (k * (k + 10.0)))
	else:
		tmp = a + (k * ((99.0 * (a * k)) + (a * -10.0)))
	return tmp

Julia

function code(a, k, m)
	tmp = 0.0
	if (m <= 1.75)
		tmp = Float64(a / Float64(1.0 + Float64(k * Float64(k + 10.0))));
	else
		tmp = Float64(a + Float64(k * Float64(Float64(99.0 * Float64(a * k)) + Float64(a * -10.0))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(a, k, m)
	tmp = 0.0;
	if (m <= 1.75)
		tmp = a / (1.0 + (k * (k + 10.0)));
	else
		tmp = a + (k * ((99.0 * (a * k)) + (a * -10.0)));
	end
	tmp_2 = tmp;
end

Wolfram

code[a_, k_, m_] := If[LessEqual[m, 1.75], N[(a / N[(1.0 + N[(k * N[(k + 10.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(a + N[(k * N[(N[(99.0 * N[(a * k), $MachinePrecision]), $MachinePrecision] + N[(a * -10.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if m < 1.75

   1. Initial program 95.4%

      \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
   2. Step-by-step derivation

      1. associate-/l* 95.3%

         \[\leadsto \color{blue}{a \cdot \frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k}} \]

      2. remove-double-neg 95.3%

         \[\leadsto a \cdot \color{blue}{\left(-\left(-\frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k}\right)\right)} \]

      3. distribute-frac-neg2 95.3%

         \[\leadsto a \cdot \left(-\color{blue}{\frac{{k}^{m}}{-\left(\left(1 + 10 \cdot k\right) + k \cdot k\right)}}\right) \]

      4. distribute-neg-frac2 95.3%

         \[\leadsto a \cdot \color{blue}{\frac{{k}^{m}}{-\left(-\left(\left(1 + 10 \cdot k\right) + k \cdot k\right)\right)}} \]

      5. remove-double-neg 95.3%

         \[\leadsto a \cdot \frac{{k}^{m}}{\color{blue}{\left(1 + 10 \cdot k\right) + k \cdot k}} \]

      6. sqr-neg 95.3%

         \[\leadsto a \cdot \frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + \color{blue}{\left(-k\right) \cdot \left(-k\right)}} \]

      7. associate-+l+ 95.3%

         \[\leadsto a \cdot \frac{{k}^{m}}{\color{blue}{1 + \left(10 \cdot k + \left(-k\right) \cdot \left(-k\right)\right)}} \]

      8. sqr-neg 95.3%

         \[\leadsto a \cdot \frac{{k}^{m}}{1 + \left(10 \cdot k + \color{blue}{k \cdot k}\right)} \]

      9. distribute-rgt-out 95.3%

         \[\leadsto a \cdot \frac{{k}^{m}}{1 + \color{blue}{k \cdot \left(10 + k\right)}} \]

   3. Simplified 95.3%

      \[\leadsto \color{blue}{a \cdot \frac{{k}^{m}}{1 + k \cdot \left(10 + k\right)}} \]
   4. Add Preprocessing

   5. Taylor expanded in m around 0 64.8%

      \[\leadsto \color{blue}{\frac{a}{1 + k \cdot \left(10 + k\right)}} \]

   if 1.75 < m

   1. Initial program 77.1%

      \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
   2. Step-by-step derivation

      1. associate-/l* 77.1%

         \[\leadsto \color{blue}{a \cdot \frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k}} \]

      2. remove-double-neg 77.1%

         \[\leadsto a \cdot \color{blue}{\left(-\left(-\frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k}\right)\right)} \]

      3. distribute-frac-neg2 77.1%

         \[\leadsto a \cdot \left(-\color{blue}{\frac{{k}^{m}}{-\left(\left(1 + 10 \cdot k\right) + k \cdot k\right)}}\right) \]

      4. distribute-neg-frac2 77.1%

         \[\leadsto a \cdot \color{blue}{\frac{{k}^{m}}{-\left(-\left(\left(1 + 10 \cdot k\right) + k \cdot k\right)\right)}} \]

      5. remove-double-neg 77.1%

         \[\leadsto a \cdot \frac{{k}^{m}}{\color{blue}{\left(1 + 10 \cdot k\right) + k \cdot k}} \]

      6. sqr-neg 77.1%

         \[\leadsto a \cdot \frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + \color{blue}{\left(-k\right) \cdot \left(-k\right)}} \]

      7. associate-+l+ 77.1%

         \[\leadsto a \cdot \frac{{k}^{m}}{\color{blue}{1 + \left(10 \cdot k + \left(-k\right) \cdot \left(-k\right)\right)}} \]

      8. sqr-neg 77.1%

         \[\leadsto a \cdot \frac{{k}^{m}}{1 + \left(10 \cdot k + \color{blue}{k \cdot k}\right)} \]

      9. distribute-rgt-out 77.1%

         \[\leadsto a \cdot \frac{{k}^{m}}{1 + \color{blue}{k \cdot \left(10 + k\right)}} \]

   3. Simplified 77.1%

      \[\leadsto \color{blue}{a \cdot \frac{{k}^{m}}{1 + k \cdot \left(10 + k\right)}} \]
   4. Add Preprocessing

   5. Taylor expanded in m around 0 2.9%

      \[\leadsto \color{blue}{\frac{a}{1 + k \cdot \left(10 + k\right)}} \]

   6. Taylor expanded in k around 0 14.3%

      \[\leadsto \color{blue}{a + k \cdot \left(k \cdot \left(-1 \cdot \left(k \cdot \left(-10 \cdot a + -10 \cdot \left(a + -100 \cdot a\right)\right)\right) - \left(a + -100 \cdot a\right)\right) - 10 \cdot a\right)} \]
   7. Step-by-step derivation

      1. cancel-sign-sub-inv 14.3%

         \[\leadsto a + k \cdot \color{blue}{\left(k \cdot \left(-1 \cdot \left(k \cdot \left(-10 \cdot a + -10 \cdot \left(a + -100 \cdot a\right)\right)\right) - \left(a + -100 \cdot a\right)\right) + \left(-10\right) \cdot a\right)} \]

      2. mul-1-neg 14.3%

         \[\leadsto a + k \cdot \left(k \cdot \left(\color{blue}{\left(-k \cdot \left(-10 \cdot a + -10 \cdot \left(a + -100 \cdot a\right)\right)\right)} - \left(a + -100 \cdot a\right)\right) + \left(-10\right) \cdot a\right) \]

      3. distribute-lft-out 14.3%

         \[\leadsto a + k \cdot \left(k \cdot \left(\left(-k \cdot \color{blue}{\left(-10 \cdot \left(a + \left(a + -100 \cdot a\right)\right)\right)}\right) - \left(a + -100 \cdot a\right)\right) + \left(-10\right) \cdot a\right) \]

      4. distribute-rgt1-in 14.3%

         \[\leadsto a + k \cdot \left(k \cdot \left(\left(-k \cdot \left(-10 \cdot \left(a + \color{blue}{\left(-100 + 1\right) \cdot a}\right)\right)\right) - \left(a + -100 \cdot a\right)\right) + \left(-10\right) \cdot a\right) \]

      5. metadata-eval 14.3%

         \[\leadsto a + k \cdot \left(k \cdot \left(\left(-k \cdot \left(-10 \cdot \left(a + \color{blue}{-99} \cdot a\right)\right)\right) - \left(a + -100 \cdot a\right)\right) + \left(-10\right) \cdot a\right) \]

      6. distribute-rgt1-in 14.3%

         \[\leadsto a + k \cdot \left(k \cdot \left(\left(-k \cdot \left(-10 \cdot \left(a + -99 \cdot a\right)\right)\right) - \color{blue}{\left(-100 + 1\right) \cdot a}\right) + \left(-10\right) \cdot a\right) \]

      7. metadata-eval 14.3%

         \[\leadsto a + k \cdot \left(k \cdot \left(\left(-k \cdot \left(-10 \cdot \left(a + -99 \cdot a\right)\right)\right) - \color{blue}{-99} \cdot a\right) + \left(-10\right) \cdot a\right) \]

      8. metadata-eval 14.3%

         \[\leadsto a + k \cdot \left(k \cdot \left(\left(-k \cdot \left(-10 \cdot \left(a + -99 \cdot a\right)\right)\right) - -99 \cdot a\right) + \color{blue}{-10} \cdot a\right) \]

      9. *-commutative 14.3%

         \[\leadsto a + k \cdot \left(k \cdot \left(\left(-k \cdot \left(-10 \cdot \left(a + -99 \cdot a\right)\right)\right) - -99 \cdot a\right) + \color{blue}{a \cdot -10}\right) \]

   8. Simplified 14.3%

      \[\leadsto \color{blue}{a + k \cdot \left(k \cdot \left(\left(-k \cdot \left(-10 \cdot \left(a + -99 \cdot a\right)\right)\right) - -99 \cdot a\right) + a \cdot -10\right)} \]

   9. Taylor expanded in k around 0 26.1%

      \[\leadsto a + k \cdot \left(\color{blue}{99 \cdot \left(a \cdot k\right)} + a \cdot -10\right) \]
3. Recombined 2 regimes into one program.

4. Final simplification 52.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;m \leq 1.75:\\ \;\;\;\;\frac{a}{1 + k \cdot \left(k + 10\right)}\\ \mathbf{else}:\\ \;\;\;\;a + k \cdot \left(99 \cdot \left(a \cdot k\right) + a \cdot -10\right)\\ \end{array} \]
5. Add Preprocessing

Alternative 8: 45.0% accurate, 12.7× speedup

Math

\[\begin{array}{l} \\ \frac{a}{1 + k \cdot \left(k + 10\right)} \end{array} \]

FPCore

(FPCore (a k m) :precision binary64 (/ a (+ 1.0 (* k (+ k 10.0)))))

C

double code(double a, double k, double m) {
	return a / (1.0 + (k * (k + 10.0)));
}

Fortran

real(8) function code(a, k, m)
    real(8), intent (in) :: a
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    code = a / (1.0d0 + (k * (k + 10.0d0)))
end function

Java

public static double code(double a, double k, double m) {
	return a / (1.0 + (k * (k + 10.0)));
}

Python

def code(a, k, m):
	return a / (1.0 + (k * (k + 10.0)))

Julia

function code(a, k, m)
	return Float64(a / Float64(1.0 + Float64(k * Float64(k + 10.0))))
end

MATLAB

function tmp = code(a, k, m)
	tmp = a / (1.0 + (k * (k + 10.0)));
end

Wolfram

code[a_, k_, m_] := N[(a / N[(1.0 + N[(k * N[(k + 10.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 89.4%

   \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
2. Step-by-step derivation

   1. associate-/l* 89.4%

      \[\leadsto \color{blue}{a \cdot \frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k}} \]

   2. remove-double-neg 89.4%

      \[\leadsto a \cdot \color{blue}{\left(-\left(-\frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k}\right)\right)} \]

   3. distribute-frac-neg2 89.4%

      \[\leadsto a \cdot \left(-\color{blue}{\frac{{k}^{m}}{-\left(\left(1 + 10 \cdot k\right) + k \cdot k\right)}}\right) \]

   4. distribute-neg-frac2 89.4%

      \[\leadsto a \cdot \color{blue}{\frac{{k}^{m}}{-\left(-\left(\left(1 + 10 \cdot k\right) + k \cdot k\right)\right)}} \]

   5. remove-double-neg 89.4%

      \[\leadsto a \cdot \frac{{k}^{m}}{\color{blue}{\left(1 + 10 \cdot k\right) + k \cdot k}} \]

   6. sqr-neg 89.4%

      \[\leadsto a \cdot \frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + \color{blue}{\left(-k\right) \cdot \left(-k\right)}} \]

   7. associate-+l+ 89.4%

      \[\leadsto a \cdot \frac{{k}^{m}}{\color{blue}{1 + \left(10 \cdot k + \left(-k\right) \cdot \left(-k\right)\right)}} \]

   8. sqr-neg 89.4%

      \[\leadsto a \cdot \frac{{k}^{m}}{1 + \left(10 \cdot k + \color{blue}{k \cdot k}\right)} \]

   9. distribute-rgt-out 89.4%

      \[\leadsto a \cdot \frac{{k}^{m}}{1 + \color{blue}{k \cdot \left(10 + k\right)}} \]

3. Simplified 89.4%

   \[\leadsto \color{blue}{a \cdot \frac{{k}^{m}}{1 + k \cdot \left(10 + k\right)}} \]
4. Add Preprocessing

5. Taylor expanded in m around 0 44.7%

   \[\leadsto \color{blue}{\frac{a}{1 + k \cdot \left(10 + k\right)}} \]

6. Final simplification 44.7%

   \[\leadsto \frac{a}{1 + k \cdot \left(k + 10\right)} \]
7. Add Preprocessing

Alternative 9: 19.8% accurate, 114.0× speedup

Math

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

FPCore

(FPCore (a k m) :precision binary64 a)

C

double code(double a, double k, double m) {
	return a;
}

Fortran

real(8) function code(a, k, m)
    real(8), intent (in) :: a
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    code = a
end function

Java

public static double code(double a, double k, double m) {
	return a;
}

Python

def code(a, k, m):
	return a

Julia

function code(a, k, m)
	return a
end

MATLAB

function tmp = code(a, k, m)
	tmp = a;
end

Wolfram

code[a_, k_, m_] := a

Derivation

1. Initial program 89.4%

   \[\frac{a \cdot {k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k} \]
2. Step-by-step derivation

   1. associate-/l* 89.4%

      \[\leadsto \color{blue}{a \cdot \frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k}} \]

   2. remove-double-neg 89.4%

      \[\leadsto a \cdot \color{blue}{\left(-\left(-\frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + k \cdot k}\right)\right)} \]

   3. distribute-frac-neg2 89.4%

      \[\leadsto a \cdot \left(-\color{blue}{\frac{{k}^{m}}{-\left(\left(1 + 10 \cdot k\right) + k \cdot k\right)}}\right) \]

   4. distribute-neg-frac2 89.4%

      \[\leadsto a \cdot \color{blue}{\frac{{k}^{m}}{-\left(-\left(\left(1 + 10 \cdot k\right) + k \cdot k\right)\right)}} \]

   5. remove-double-neg 89.4%

      \[\leadsto a \cdot \frac{{k}^{m}}{\color{blue}{\left(1 + 10 \cdot k\right) + k \cdot k}} \]

   6. sqr-neg 89.4%

      \[\leadsto a \cdot \frac{{k}^{m}}{\left(1 + 10 \cdot k\right) + \color{blue}{\left(-k\right) \cdot \left(-k\right)}} \]

   7. associate-+l+ 89.4%

      \[\leadsto a \cdot \frac{{k}^{m}}{\color{blue}{1 + \left(10 \cdot k + \left(-k\right) \cdot \left(-k\right)\right)}} \]

   8. sqr-neg 89.4%

      \[\leadsto a \cdot \frac{{k}^{m}}{1 + \left(10 \cdot k + \color{blue}{k \cdot k}\right)} \]

   9. distribute-rgt-out 89.4%

      \[\leadsto a \cdot \frac{{k}^{m}}{1 + \color{blue}{k \cdot \left(10 + k\right)}} \]

3. Simplified 89.4%

   \[\leadsto \color{blue}{a \cdot \frac{{k}^{m}}{1 + k \cdot \left(10 + k\right)}} \]
4. Add Preprocessing

5. Taylor expanded in m around 0 44.7%

   \[\leadsto \color{blue}{\frac{a}{1 + k \cdot \left(10 + k\right)}} \]

6. Taylor expanded in k around 0 17.2%

   \[\leadsto \color{blue}{a} \]
7. Add Preprocessing

Reproduce

herbie shell --seed 2024111 
(FPCore (a k m)
  :name "Falkner and Boettcher, Appendix A"
  :precision binary64
  (/ (* a (pow k m)) (+ (+ 1.0 (* 10.0 k)) (* k k))))