Falkner and Boettcher, Appendix A

Percentage Accurate: 90.0% → 99.7%

Time: 11.6s

Alternatives: 13

Speedup: 1.0×

• 23.5% 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.7% accurate, 0.3× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ a_s = \mathsf{copysign}\left(1, a\right) \\ \begin{array}{l} t_0 := {k}^{m} \cdot a_m\\ t_1 := \frac{t_0}{\left(1 + k \cdot 10\right) + k \cdot k}\\ a_s \cdot \begin{array}{l} \mathbf{if}\;t_1 \leq 0:\\ \;\;\;\;\frac{{k}^{m}}{\mathsf{hypot}\left(1, k\right)} \cdot \frac{a_m}{\mathsf{hypot}\left(1, k\right)}\\ \mathbf{elif}\;t_1 \leq 4 \cdot 10^{+204}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
a_s = (copysign.f64 1 a)
(FPCore (a_s a_m k m)
 :precision binary64
 (let* ((t_0 (* (pow k m) a_m)) (t_1 (/ t_0 (+ (+ 1.0 (* k 10.0)) (* k k)))))
   (*
    a_s
    (if (<= t_1 0.0)
      (* (/ (pow k m) (hypot 1.0 k)) (/ a_m (hypot 1.0 k)))
      (if (<= t_1 4e+204) t_1 t_0)))))

C

a_m = fabs(a);
a_s = copysign(1.0, a);
double code(double a_s, double a_m, double k, double m) {
	double t_0 = pow(k, m) * a_m;
	double t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k));
	double tmp;
	if (t_1 <= 0.0) {
		tmp = (pow(k, m) / hypot(1.0, k)) * (a_m / hypot(1.0, k));
	} else if (t_1 <= 4e+204) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return a_s * tmp;
}

Java

a_m = Math.abs(a);
a_s = Math.copySign(1.0, a);
public static double code(double a_s, double a_m, double k, double m) {
	double t_0 = Math.pow(k, m) * a_m;
	double t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k));
	double tmp;
	if (t_1 <= 0.0) {
		tmp = (Math.pow(k, m) / Math.hypot(1.0, k)) * (a_m / Math.hypot(1.0, k));
	} else if (t_1 <= 4e+204) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return a_s * tmp;
}

Python

a_m = math.fabs(a)
a_s = math.copysign(1.0, a)
def code(a_s, a_m, k, m):
	t_0 = math.pow(k, m) * a_m
	t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k))
	tmp = 0
	if t_1 <= 0.0:
		tmp = (math.pow(k, m) / math.hypot(1.0, k)) * (a_m / math.hypot(1.0, k))
	elif t_1 <= 4e+204:
		tmp = t_1
	else:
		tmp = t_0
	return a_s * tmp

Julia

a_m = abs(a)
a_s = copysign(1.0, a)
function code(a_s, a_m, k, m)
	t_0 = Float64((k ^ m) * a_m)
	t_1 = Float64(t_0 / Float64(Float64(1.0 + Float64(k * 10.0)) + Float64(k * k)))
	tmp = 0.0
	if (t_1 <= 0.0)
		tmp = Float64(Float64((k ^ m) / hypot(1.0, k)) * Float64(a_m / hypot(1.0, k)));
	elseif (t_1 <= 4e+204)
		tmp = t_1;
	else
		tmp = t_0;
	end
	return Float64(a_s * tmp)
end

MATLAB

a_m = abs(a);
a_s = sign(a) * abs(1.0);
function tmp_2 = code(a_s, a_m, k, m)
	t_0 = (k ^ m) * a_m;
	t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k));
	tmp = 0.0;
	if (t_1 <= 0.0)
		tmp = ((k ^ m) / hypot(1.0, k)) * (a_m / hypot(1.0, k));
	elseif (t_1 <= 4e+204)
		tmp = t_1;
	else
		tmp = t_0;
	end
	tmp_2 = a_s * tmp;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
a_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, a$95$m_, k_, m_] := Block[{t$95$0 = N[(N[Power[k, m], $MachinePrecision] * a$95$m), $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]}, N[(a$95$s * If[LessEqual[t$95$1, 0.0], N[(N[(N[Power[k, m], $MachinePrecision] / N[Sqrt[1.0 ^ 2 + k ^ 2], $MachinePrecision]), $MachinePrecision] * N[(a$95$m / N[Sqrt[1.0 ^ 2 + k ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t$95$1, 4e+204], t$95$1, t$95$0]]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 1 (*.f64 10 k)) (*.f64 k k))) < 0.0

   1. Initial program 95.5%

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

      1. *-commutative 95.5%

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

   3. Simplified 95.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 94.6%

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

      1. *-commutative 94.6%

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

      2. pow2 94.6%

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

      3. add-sqr-sqrt 94.6%

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

      4. times-frac 93.6%

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

      5. pow2 93.6%

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

      6. hypot-1-def 93.6%

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

      7. pow2 93.6%

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

      8. hypot-1-def 98.0%

         \[\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.0%

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

   if 0.0 < (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 1 (*.f64 10 k)) (*.f64 k k))) < 3.99999999999999996e204

   1. Initial program 99.7%

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

   if 3.99999999999999996e204 < (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 1 (*.f64 10 k)) (*.f64 k k)))

   1. Initial program 57.1%

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

      1. associate-*l/ 52.4%

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

      2. sqr-neg 52.4%

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

      3. associate-+l+ 52.4%

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

      4. sqr-neg 52.4%

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

      5. distribute-rgt-out 52.4%

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

   3. Simplified 52.4%

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

   5. Taylor expanded in k around 0 100.0%

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

4. Final simplification 98.5%

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

Alternative 2: 99.0% accurate, 0.4× speedup

Math

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

FPCore

a_m = (fabs.f64 a)
a_s = (copysign.f64 1 a)
(FPCore (a_s a_m k m)
 :precision binary64
 (* a_s (/ (* (/ (pow k m) (hypot 1.0 k)) a_m) (hypot 1.0 k))))

C

a_m = fabs(a);
a_s = copysign(1.0, a);
double code(double a_s, double a_m, double k, double m) {
	return a_s * (((pow(k, m) / hypot(1.0, k)) * a_m) / hypot(1.0, k));
}

Java

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

Python

a_m = math.fabs(a)
a_s = math.copysign(1.0, a)
def code(a_s, a_m, k, m):
	return a_s * (((math.pow(k, m) / math.hypot(1.0, k)) * a_m) / math.hypot(1.0, k))

Julia

a_m = abs(a)
a_s = copysign(1.0, a)
function code(a_s, a_m, k, m)
	return Float64(a_s * Float64(Float64(Float64((k ^ m) / hypot(1.0, k)) * a_m) / hypot(1.0, k)))
end

MATLAB

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

Wolfram

a_m = N[Abs[a], $MachinePrecision]
a_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, a$95$m_, k_, m_] := N[(a$95$s * N[(N[(N[(N[Power[k, m], $MachinePrecision] / N[Sqrt[1.0 ^ 2 + k ^ 2], $MachinePrecision]), $MachinePrecision] * a$95$m), $MachinePrecision] / N[Sqrt[1.0 ^ 2 + k ^ 2], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

1. Initial program 89.6%

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

   1. *-commutative 89.6%

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

3. Simplified 89.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 87.9%

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

   1. *-un-lft-identity 87.9%

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

   2. pow2 87.9%

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

   3. add-sqr-sqrt 87.9%

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

   4. times-frac 87.8%

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

   5. pow2 87.8%

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

   6. hypot-1-def 87.8%

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

   7. pow2 87.8%

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

   8. hypot-1-def 98.1%

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

7. Applied egg-rr 98.1%

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

   1. associate-*l/ 98.2%

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

   2. *-lft-identity 98.2%

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

   3. associate-/l* 98.2%

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

9. Simplified 98.2%

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

    1. clear-num 98.1%

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

    2. associate-/r/ 98.2%

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

    3. clear-num 98.2%

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

11. Applied egg-rr 98.2%

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

12. Final simplification 98.2%

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

Alternative 3: 97.6% accurate, 0.5× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ a_s = \mathsf{copysign}\left(1, a\right) \\ \begin{array}{l} t_0 := {k}^{m} \cdot a_m\\ t_1 := \frac{t_0}{\left(1 + k \cdot 10\right) + k \cdot k}\\ a_s \cdot \begin{array}{l} \mathbf{if}\;t_1 \leq 4 \cdot 10^{+204}:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
a_s = (copysign.f64 1 a)
(FPCore (a_s a_m k m)
 :precision binary64
 (let* ((t_0 (* (pow k m) a_m)) (t_1 (/ t_0 (+ (+ 1.0 (* k 10.0)) (* k k)))))
   (* a_s (if (<= t_1 4e+204) t_1 t_0))))

C

a_m = fabs(a);
a_s = copysign(1.0, a);
double code(double a_s, double a_m, double k, double m) {
	double t_0 = pow(k, m) * a_m;
	double t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k));
	double tmp;
	if (t_1 <= 4e+204) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return a_s * tmp;
}

Fortran

a_m = abs(a)
a_s = copysign(1.0d0, a)
real(8) function code(a_s, a_m, k, m)
    real(8), intent (in) :: a_s
    real(8), intent (in) :: a_m
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (k ** m) * a_m
    t_1 = t_0 / ((1.0d0 + (k * 10.0d0)) + (k * k))
    if (t_1 <= 4d+204) then
        tmp = t_1
    else
        tmp = t_0
    end if
    code = a_s * tmp
end function

Java

a_m = Math.abs(a);
a_s = Math.copySign(1.0, a);
public static double code(double a_s, double a_m, double k, double m) {
	double t_0 = Math.pow(k, m) * a_m;
	double t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k));
	double tmp;
	if (t_1 <= 4e+204) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return a_s * tmp;
}

Python

a_m = math.fabs(a)
a_s = math.copysign(1.0, a)
def code(a_s, a_m, k, m):
	t_0 = math.pow(k, m) * a_m
	t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k))
	tmp = 0
	if t_1 <= 4e+204:
		tmp = t_1
	else:
		tmp = t_0
	return a_s * tmp

Julia

a_m = abs(a)
a_s = copysign(1.0, a)
function code(a_s, a_m, k, m)
	t_0 = Float64((k ^ m) * a_m)
	t_1 = Float64(t_0 / Float64(Float64(1.0 + Float64(k * 10.0)) + Float64(k * k)))
	tmp = 0.0
	if (t_1 <= 4e+204)
		tmp = t_1;
	else
		tmp = t_0;
	end
	return Float64(a_s * tmp)
end

MATLAB

a_m = abs(a);
a_s = sign(a) * abs(1.0);
function tmp_2 = code(a_s, a_m, k, m)
	t_0 = (k ^ m) * a_m;
	t_1 = t_0 / ((1.0 + (k * 10.0)) + (k * k));
	tmp = 0.0;
	if (t_1 <= 4e+204)
		tmp = t_1;
	else
		tmp = t_0;
	end
	tmp_2 = a_s * tmp;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
a_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, a$95$m_, k_, m_] := Block[{t$95$0 = N[(N[Power[k, m], $MachinePrecision] * a$95$m), $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]}, N[(a$95$s * If[LessEqual[t$95$1, 4e+204], t$95$1, t$95$0]), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 1 (*.f64 10 k)) (*.f64 k k))) < 3.99999999999999996e204

   1. Initial program 96.0%

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

   if 3.99999999999999996e204 < (/.f64 (*.f64 a (pow.f64 k m)) (+.f64 (+.f64 1 (*.f64 10 k)) (*.f64 k k)))

   1. Initial program 57.1%

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

      1. associate-*l/ 52.4%

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

      2. sqr-neg 52.4%

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

      3. associate-+l+ 52.4%

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

      4. sqr-neg 52.4%

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

      5. distribute-rgt-out 52.4%

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

   3. Simplified 52.4%

      \[\leadsto \color{blue}{\frac{a}{1 + k \cdot \left(10 + k\right)} \cdot {k}^{m}} \]
   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.6%

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

Alternative 4: 97.6% accurate, 0.9× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ a_s = \mathsf{copysign}\left(1, a\right) \\ \begin{array}{l} t_0 := {k}^{m} \cdot a_m\\ t_1 := \frac{t_0}{1 + k \cdot k}\\ a_s \cdot \begin{array}{l} \mathbf{if}\;m \leq -3.5 \cdot 10^{-14}:\\ \;\;\;\;t_1\\ \mathbf{elif}\;m \leq 2 \cdot 10^{-22}:\\ \;\;\;\;\frac{a_m}{1 + \left(k \cdot 10 + {k}^{2}\right)}\\ \mathbf{elif}\;m \leq 2.4:\\ \;\;\;\;t_1\\ \mathbf{else}:\\ \;\;\;\;t_0\\ \end{array} \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
a_s = (copysign.f64 1 a)
(FPCore (a_s a_m k m)
 :precision binary64
 (let* ((t_0 (* (pow k m) a_m)) (t_1 (/ t_0 (+ 1.0 (* k k)))))
   (*
    a_s
    (if (<= m -3.5e-14)
      t_1
      (if (<= m 2e-22)
        (/ a_m (+ 1.0 (+ (* k 10.0) (pow k 2.0))))
        (if (<= m 2.4) t_1 t_0))))))

C

a_m = fabs(a);
a_s = copysign(1.0, a);
double code(double a_s, double a_m, double k, double m) {
	double t_0 = pow(k, m) * a_m;
	double t_1 = t_0 / (1.0 + (k * k));
	double tmp;
	if (m <= -3.5e-14) {
		tmp = t_1;
	} else if (m <= 2e-22) {
		tmp = a_m / (1.0 + ((k * 10.0) + pow(k, 2.0)));
	} else if (m <= 2.4) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return a_s * tmp;
}

Fortran

a_m = abs(a)
a_s = copysign(1.0d0, a)
real(8) function code(a_s, a_m, k, m)
    real(8), intent (in) :: a_s
    real(8), intent (in) :: a_m
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = (k ** m) * a_m
    t_1 = t_0 / (1.0d0 + (k * k))
    if (m <= (-3.5d-14)) then
        tmp = t_1
    else if (m <= 2d-22) then
        tmp = a_m / (1.0d0 + ((k * 10.0d0) + (k ** 2.0d0)))
    else if (m <= 2.4d0) then
        tmp = t_1
    else
        tmp = t_0
    end if
    code = a_s * tmp
end function

Java

a_m = Math.abs(a);
a_s = Math.copySign(1.0, a);
public static double code(double a_s, double a_m, double k, double m) {
	double t_0 = Math.pow(k, m) * a_m;
	double t_1 = t_0 / (1.0 + (k * k));
	double tmp;
	if (m <= -3.5e-14) {
		tmp = t_1;
	} else if (m <= 2e-22) {
		tmp = a_m / (1.0 + ((k * 10.0) + Math.pow(k, 2.0)));
	} else if (m <= 2.4) {
		tmp = t_1;
	} else {
		tmp = t_0;
	}
	return a_s * tmp;
}

Python

a_m = math.fabs(a)
a_s = math.copysign(1.0, a)
def code(a_s, a_m, k, m):
	t_0 = math.pow(k, m) * a_m
	t_1 = t_0 / (1.0 + (k * k))
	tmp = 0
	if m <= -3.5e-14:
		tmp = t_1
	elif m <= 2e-22:
		tmp = a_m / (1.0 + ((k * 10.0) + math.pow(k, 2.0)))
	elif m <= 2.4:
		tmp = t_1
	else:
		tmp = t_0
	return a_s * tmp

Julia

a_m = abs(a)
a_s = copysign(1.0, a)
function code(a_s, a_m, k, m)
	t_0 = Float64((k ^ m) * a_m)
	t_1 = Float64(t_0 / Float64(1.0 + Float64(k * k)))
	tmp = 0.0
	if (m <= -3.5e-14)
		tmp = t_1;
	elseif (m <= 2e-22)
		tmp = Float64(a_m / Float64(1.0 + Float64(Float64(k * 10.0) + (k ^ 2.0))));
	elseif (m <= 2.4)
		tmp = t_1;
	else
		tmp = t_0;
	end
	return Float64(a_s * tmp)
end

MATLAB

a_m = abs(a);
a_s = sign(a) * abs(1.0);
function tmp_2 = code(a_s, a_m, k, m)
	t_0 = (k ^ m) * a_m;
	t_1 = t_0 / (1.0 + (k * k));
	tmp = 0.0;
	if (m <= -3.5e-14)
		tmp = t_1;
	elseif (m <= 2e-22)
		tmp = a_m / (1.0 + ((k * 10.0) + (k ^ 2.0)));
	elseif (m <= 2.4)
		tmp = t_1;
	else
		tmp = t_0;
	end
	tmp_2 = a_s * tmp;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
a_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, a$95$m_, k_, m_] := Block[{t$95$0 = N[(N[Power[k, m], $MachinePrecision] * a$95$m), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 / N[(1.0 + N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, N[(a$95$s * If[LessEqual[m, -3.5e-14], t$95$1, If[LessEqual[m, 2e-22], N[(a$95$m / N[(1.0 + N[(N[(k * 10.0), $MachinePrecision] + N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[m, 2.4], t$95$1, t$95$0]]]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if m < -3.5000000000000002e-14 or 2.0000000000000001e-22 < m < 2.39999999999999991

   1. Initial program 98.9%

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

      1. *-commutative 98.9%

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

   3. Simplified 98.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 98.9%

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

   if -3.5000000000000002e-14 < m < 2.0000000000000001e-22

   1. Initial program 90.5%

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

      1. *-commutative 90.5%

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

   3. Simplified 90.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 m around 0 90.5%

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

   if 2.39999999999999991 < m

   1. Initial program 79.8%

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

      1. associate-*l/ 73.0%

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

      2. sqr-neg 73.0%

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

      3. associate-+l+ 73.0%

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

      4. sqr-neg 73.0%

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

      5. distribute-rgt-out 73.0%

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

   3. Simplified 73.0%

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

   5. Taylor expanded in k around 0 100.0%

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

4. Final simplification 96.6%

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

Alternative 5: 97.1% accurate, 0.9× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ a_s = \mathsf{copysign}\left(1, a\right) \\ a_s \cdot \begin{array}{l} \mathbf{if}\;m \leq -0.00085 \lor \neg \left(m \leq 0.96\right):\\ \;\;\;\;{k}^{m} \cdot a_m\\ \mathbf{else}:\\ \;\;\;\;\frac{a_m}{1 + \left(k \cdot 10 + {k}^{2}\right)}\\ \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
a_s = (copysign.f64 1 a)
(FPCore (a_s a_m k m)
 :precision binary64
 (*
  a_s
  (if (or (<= m -0.00085) (not (<= m 0.96)))
    (* (pow k m) a_m)
    (/ a_m (+ 1.0 (+ (* k 10.0) (pow k 2.0)))))))

C

a_m = fabs(a);
a_s = copysign(1.0, a);
double code(double a_s, double a_m, double k, double m) {
	double tmp;
	if ((m <= -0.00085) || !(m <= 0.96)) {
		tmp = pow(k, m) * a_m;
	} else {
		tmp = a_m / (1.0 + ((k * 10.0) + pow(k, 2.0)));
	}
	return a_s * tmp;
}

Fortran

a_m = abs(a)
a_s = copysign(1.0d0, a)
real(8) function code(a_s, a_m, k, m)
    real(8), intent (in) :: a_s
    real(8), intent (in) :: a_m
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: tmp
    if ((m <= (-0.00085d0)) .or. (.not. (m <= 0.96d0))) then
        tmp = (k ** m) * a_m
    else
        tmp = a_m / (1.0d0 + ((k * 10.0d0) + (k ** 2.0d0)))
    end if
    code = a_s * tmp
end function

Java

a_m = Math.abs(a);
a_s = Math.copySign(1.0, a);
public static double code(double a_s, double a_m, double k, double m) {
	double tmp;
	if ((m <= -0.00085) || !(m <= 0.96)) {
		tmp = Math.pow(k, m) * a_m;
	} else {
		tmp = a_m / (1.0 + ((k * 10.0) + Math.pow(k, 2.0)));
	}
	return a_s * tmp;
}

Python

a_m = math.fabs(a)
a_s = math.copysign(1.0, a)
def code(a_s, a_m, k, m):
	tmp = 0
	if (m <= -0.00085) or not (m <= 0.96):
		tmp = math.pow(k, m) * a_m
	else:
		tmp = a_m / (1.0 + ((k * 10.0) + math.pow(k, 2.0)))
	return a_s * tmp

Julia

a_m = abs(a)
a_s = copysign(1.0, a)
function code(a_s, a_m, k, m)
	tmp = 0.0
	if ((m <= -0.00085) || !(m <= 0.96))
		tmp = Float64((k ^ m) * a_m);
	else
		tmp = Float64(a_m / Float64(1.0 + Float64(Float64(k * 10.0) + (k ^ 2.0))));
	end
	return Float64(a_s * tmp)
end

MATLAB

a_m = abs(a);
a_s = sign(a) * abs(1.0);
function tmp_2 = code(a_s, a_m, k, m)
	tmp = 0.0;
	if ((m <= -0.00085) || ~((m <= 0.96)))
		tmp = (k ^ m) * a_m;
	else
		tmp = a_m / (1.0 + ((k * 10.0) + (k ^ 2.0)));
	end
	tmp_2 = a_s * tmp;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
a_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, a$95$m_, k_, m_] := N[(a$95$s * If[Or[LessEqual[m, -0.00085], N[Not[LessEqual[m, 0.96]], $MachinePrecision]], N[(N[Power[k, m], $MachinePrecision] * a$95$m), $MachinePrecision], N[(a$95$m / N[(1.0 + N[(N[(k * 10.0), $MachinePrecision] + N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

1. Split input into 2 regimes

2. if m < -8.49999999999999953e-4 or 0.95999999999999996 < m

   1. Initial program 89.2%

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

      1. associate-*l/ 85.6%

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

      2. sqr-neg 85.6%

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

      3. associate-+l+ 85.6%

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

      4. sqr-neg 85.6%

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

      5. distribute-rgt-out 85.6%

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

   3. Simplified 85.6%

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

   5. Taylor expanded in k around 0 100.0%

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

   if -8.49999999999999953e-4 < m < 0.95999999999999996

   1. Initial program 90.3%

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

      1. *-commutative 90.3%

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

   3. Simplified 90.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 m around 0 89.1%

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

4. Final simplification 96.2%

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

Alternative 6: 97.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ a_s = \mathsf{copysign}\left(1, a\right) \\ a_s \cdot \begin{array}{l} \mathbf{if}\;m \leq 2.7:\\ \;\;\;\;{k}^{m} \cdot \frac{a_m}{1 + k \cdot \left(k + 10\right)}\\ \mathbf{else}:\\ \;\;\;\;{k}^{m} \cdot a_m\\ \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
a_s = (copysign.f64 1 a)
(FPCore (a_s a_m k m)
 :precision binary64
 (*
  a_s
  (if (<= m 2.7)
    (* (pow k m) (/ a_m (+ 1.0 (* k (+ k 10.0)))))
    (* (pow k m) a_m))))

C

a_m = fabs(a);
a_s = copysign(1.0, a);
double code(double a_s, double a_m, double k, double m) {
	double tmp;
	if (m <= 2.7) {
		tmp = pow(k, m) * (a_m / (1.0 + (k * (k + 10.0))));
	} else {
		tmp = pow(k, m) * a_m;
	}
	return a_s * tmp;
}

Fortran

a_m = abs(a)
a_s = copysign(1.0d0, a)
real(8) function code(a_s, a_m, k, m)
    real(8), intent (in) :: a_s
    real(8), intent (in) :: a_m
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: tmp
    if (m <= 2.7d0) then
        tmp = (k ** m) * (a_m / (1.0d0 + (k * (k + 10.0d0))))
    else
        tmp = (k ** m) * a_m
    end if
    code = a_s * tmp
end function

Java

a_m = Math.abs(a);
a_s = Math.copySign(1.0, a);
public static double code(double a_s, double a_m, double k, double m) {
	double tmp;
	if (m <= 2.7) {
		tmp = Math.pow(k, m) * (a_m / (1.0 + (k * (k + 10.0))));
	} else {
		tmp = Math.pow(k, m) * a_m;
	}
	return a_s * tmp;
}

Python

a_m = math.fabs(a)
a_s = math.copysign(1.0, a)
def code(a_s, a_m, k, m):
	tmp = 0
	if m <= 2.7:
		tmp = math.pow(k, m) * (a_m / (1.0 + (k * (k + 10.0))))
	else:
		tmp = math.pow(k, m) * a_m
	return a_s * tmp

Julia

a_m = abs(a)
a_s = copysign(1.0, a)
function code(a_s, a_m, k, m)
	tmp = 0.0
	if (m <= 2.7)
		tmp = Float64((k ^ m) * Float64(a_m / Float64(1.0 + Float64(k * Float64(k + 10.0)))));
	else
		tmp = Float64((k ^ m) * a_m);
	end
	return Float64(a_s * tmp)
end

MATLAB

a_m = abs(a);
a_s = sign(a) * abs(1.0);
function tmp_2 = code(a_s, a_m, k, m)
	tmp = 0.0;
	if (m <= 2.7)
		tmp = (k ^ m) * (a_m / (1.0 + (k * (k + 10.0))));
	else
		tmp = (k ^ m) * a_m;
	end
	tmp_2 = a_s * tmp;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
a_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, a$95$m_, k_, m_] := N[(a$95$s * If[LessEqual[m, 2.7], N[(N[Power[k, m], $MachinePrecision] * N[(a$95$m / N[(1.0 + N[(k * N[(k + 10.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[Power[k, m], $MachinePrecision] * a$95$m), $MachinePrecision]]), $MachinePrecision]

Derivation

1. Split input into 2 regimes

2. if m < 2.7000000000000002

   1. Initial program 94.8%

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

      1. associate-*l/ 94.8%

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

      2. sqr-neg 94.8%

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

      3. associate-+l+ 94.8%

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

      4. sqr-neg 94.8%

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

      5. distribute-rgt-out 94.8%

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

   3. Simplified 94.8%

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

   if 2.7000000000000002 < m

   1. Initial program 79.8%

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

      1. associate-*l/ 73.0%

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

      2. sqr-neg 73.0%

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

      3. associate-+l+ 73.0%

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

      4. sqr-neg 73.0%

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

      5. distribute-rgt-out 73.0%

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

   3. Simplified 73.0%

      \[\leadsto \color{blue}{\frac{a}{1 + k \cdot \left(10 + k\right)} \cdot {k}^{m}} \]
   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.6%

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

Alternative 7: 97.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ a_s = \mathsf{copysign}\left(1, a\right) \\ a_s \cdot \begin{array}{l} \mathbf{if}\;m \leq -1.2 \lor \neg \left(m \leq 0.47\right):\\ \;\;\;\;{k}^{m} \cdot a_m\\ \mathbf{else}:\\ \;\;\;\;\frac{a_m}{1 + k \cdot \left(k + 10\right)}\\ \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
a_s = (copysign.f64 1 a)
(FPCore (a_s a_m k m)
 :precision binary64
 (*
  a_s
  (if (or (<= m -1.2) (not (<= m 0.47)))
    (* (pow k m) a_m)
    (/ a_m (+ 1.0 (* k (+ k 10.0)))))))

C

a_m = fabs(a);
a_s = copysign(1.0, a);
double code(double a_s, double a_m, double k, double m) {
	double tmp;
	if ((m <= -1.2) || !(m <= 0.47)) {
		tmp = pow(k, m) * a_m;
	} else {
		tmp = a_m / (1.0 + (k * (k + 10.0)));
	}
	return a_s * tmp;
}

Fortran

a_m = abs(a)
a_s = copysign(1.0d0, a)
real(8) function code(a_s, a_m, k, m)
    real(8), intent (in) :: a_s
    real(8), intent (in) :: a_m
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: tmp
    if ((m <= (-1.2d0)) .or. (.not. (m <= 0.47d0))) then
        tmp = (k ** m) * a_m
    else
        tmp = a_m / (1.0d0 + (k * (k + 10.0d0)))
    end if
    code = a_s * tmp
end function

Java

a_m = Math.abs(a);
a_s = Math.copySign(1.0, a);
public static double code(double a_s, double a_m, double k, double m) {
	double tmp;
	if ((m <= -1.2) || !(m <= 0.47)) {
		tmp = Math.pow(k, m) * a_m;
	} else {
		tmp = a_m / (1.0 + (k * (k + 10.0)));
	}
	return a_s * tmp;
}

Python

a_m = math.fabs(a)
a_s = math.copysign(1.0, a)
def code(a_s, a_m, k, m):
	tmp = 0
	if (m <= -1.2) or not (m <= 0.47):
		tmp = math.pow(k, m) * a_m
	else:
		tmp = a_m / (1.0 + (k * (k + 10.0)))
	return a_s * tmp

Julia

a_m = abs(a)
a_s = copysign(1.0, a)
function code(a_s, a_m, k, m)
	tmp = 0.0
	if ((m <= -1.2) || !(m <= 0.47))
		tmp = Float64((k ^ m) * a_m);
	else
		tmp = Float64(a_m / Float64(1.0 + Float64(k * Float64(k + 10.0))));
	end
	return Float64(a_s * tmp)
end

MATLAB

a_m = abs(a);
a_s = sign(a) * abs(1.0);
function tmp_2 = code(a_s, a_m, k, m)
	tmp = 0.0;
	if ((m <= -1.2) || ~((m <= 0.47)))
		tmp = (k ^ m) * a_m;
	else
		tmp = a_m / (1.0 + (k * (k + 10.0)));
	end
	tmp_2 = a_s * tmp;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
a_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, a$95$m_, k_, m_] := N[(a$95$s * If[Or[LessEqual[m, -1.2], N[Not[LessEqual[m, 0.47]], $MachinePrecision]], N[(N[Power[k, m], $MachinePrecision] * a$95$m), $MachinePrecision], N[(a$95$m / N[(1.0 + N[(k * N[(k + 10.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

1. Split input into 2 regimes

2. if m < -1.19999999999999996 or 0.46999999999999997 < m

   1. Initial program 89.2%

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

      1. associate-*l/ 85.6%

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

      2. sqr-neg 85.6%

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

      3. associate-+l+ 85.6%

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

      4. sqr-neg 85.6%

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

      5. distribute-rgt-out 85.6%

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

   3. Simplified 85.6%

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

   5. Taylor expanded in k around 0 100.0%

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

   if -1.19999999999999996 < m < 0.46999999999999997

   1. Initial program 90.3%

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

      1. associate-*l/ 90.3%

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

      2. sqr-neg 90.3%

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

      3. associate-+l+ 90.3%

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

      4. sqr-neg 90.3%

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

      5. distribute-rgt-out 90.3%

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

   3. Simplified 90.3%

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

   5. Taylor expanded in m around 0 89.1%

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

4. Final simplification 96.2%

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

Alternative 8: 44.0% accurate, 6.0× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ a_s = \mathsf{copysign}\left(1, a\right) \\ a_s \cdot \begin{array}{l} \mathbf{if}\;k \leq -1.85 \cdot 10^{+117} \lor \neg \left(k \leq 0.075\right):\\ \;\;\;\;a_m \cdot \frac{1}{k \cdot \left(k + 10\right)}\\ \mathbf{else}:\\ \;\;\;\;a_m \cdot \left(1 + k \cdot -10\right)\\ \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
a_s = (copysign.f64 1 a)
(FPCore (a_s a_m k m)
 :precision binary64
 (*
  a_s
  (if (or (<= k -1.85e+117) (not (<= k 0.075)))
    (* a_m (/ 1.0 (* k (+ k 10.0))))
    (* a_m (+ 1.0 (* k -10.0))))))

C

a_m = fabs(a);
a_s = copysign(1.0, a);
double code(double a_s, double a_m, double k, double m) {
	double tmp;
	if ((k <= -1.85e+117) || !(k <= 0.075)) {
		tmp = a_m * (1.0 / (k * (k + 10.0)));
	} else {
		tmp = a_m * (1.0 + (k * -10.0));
	}
	return a_s * tmp;
}

Fortran

a_m = abs(a)
a_s = copysign(1.0d0, a)
real(8) function code(a_s, a_m, k, m)
    real(8), intent (in) :: a_s
    real(8), intent (in) :: a_m
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: tmp
    if ((k <= (-1.85d+117)) .or. (.not. (k <= 0.075d0))) then
        tmp = a_m * (1.0d0 / (k * (k + 10.0d0)))
    else
        tmp = a_m * (1.0d0 + (k * (-10.0d0)))
    end if
    code = a_s * tmp
end function

Java

a_m = Math.abs(a);
a_s = Math.copySign(1.0, a);
public static double code(double a_s, double a_m, double k, double m) {
	double tmp;
	if ((k <= -1.85e+117) || !(k <= 0.075)) {
		tmp = a_m * (1.0 / (k * (k + 10.0)));
	} else {
		tmp = a_m * (1.0 + (k * -10.0));
	}
	return a_s * tmp;
}

Python

a_m = math.fabs(a)
a_s = math.copysign(1.0, a)
def code(a_s, a_m, k, m):
	tmp = 0
	if (k <= -1.85e+117) or not (k <= 0.075):
		tmp = a_m * (1.0 / (k * (k + 10.0)))
	else:
		tmp = a_m * (1.0 + (k * -10.0))
	return a_s * tmp

Julia

a_m = abs(a)
a_s = copysign(1.0, a)
function code(a_s, a_m, k, m)
	tmp = 0.0
	if ((k <= -1.85e+117) || !(k <= 0.075))
		tmp = Float64(a_m * Float64(1.0 / Float64(k * Float64(k + 10.0))));
	else
		tmp = Float64(a_m * Float64(1.0 + Float64(k * -10.0)));
	end
	return Float64(a_s * tmp)
end

MATLAB

a_m = abs(a);
a_s = sign(a) * abs(1.0);
function tmp_2 = code(a_s, a_m, k, m)
	tmp = 0.0;
	if ((k <= -1.85e+117) || ~((k <= 0.075)))
		tmp = a_m * (1.0 / (k * (k + 10.0)));
	else
		tmp = a_m * (1.0 + (k * -10.0));
	end
	tmp_2 = a_s * tmp;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
a_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, a$95$m_, k_, m_] := N[(a$95$s * If[Or[LessEqual[k, -1.85e+117], N[Not[LessEqual[k, 0.075]], $MachinePrecision]], N[(a$95$m * N[(1.0 / N[(k * N[(k + 10.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(a$95$m * N[(1.0 + N[(k * -10.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

1. Split input into 2 regimes

2. if k < -1.8499999999999999e117 or 0.0749999999999999972 < k

   1. Initial program 79.1%

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

      1. *-commutative 79.1%

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

   3. Simplified 79.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 m around 0 55.5%

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

      1. frac-2neg 55.5%

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

      2. +-commutative 55.5%

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

      3. distribute-neg-in 55.5%

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

      4. pow2 55.5%

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

      5. distribute-rgt-in 55.4%

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

      6. +-commutative 55.4%

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

      7. distribute-neg-in 55.4%

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

      8. fma-udef 55.4%

         \[\leadsto \frac{-a}{-\color{blue}{\mathsf{fma}\left(k, k + 10, 1\right)}} \]

      9. frac-2neg 55.4%

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

      10. clear-num 55.4%

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

      11. associate-/r/ 55.4%

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

   7. Applied egg-rr 55.4%

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

   8. Taylor expanded in k around inf 54.4%

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

      1. +-commutative 54.4%

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

      2. unpow2 54.4%

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

      3. distribute-rgt-in 54.4%

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

   10. Simplified 54.4%

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

   if -1.8499999999999999e117 < k < 0.0749999999999999972

   1. Initial program 99.9%

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

      1. *-commutative 99.9%

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

   3. Simplified 99.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 m around 0 33.3%

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

      1. frac-2neg 33.3%

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

      2. +-commutative 33.3%

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

      3. distribute-neg-in 33.3%

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

      4. pow2 33.3%

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

      5. distribute-rgt-in 33.3%

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

      6. +-commutative 33.3%

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

      7. distribute-neg-in 33.3%

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

      8. fma-udef 33.3%

         \[\leadsto \frac{-a}{-\color{blue}{\mathsf{fma}\left(k, k + 10, 1\right)}} \]

      9. frac-2neg 33.3%

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

      10. clear-num 33.3%

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

      11. associate-/r/ 33.3%

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

   7. Applied egg-rr 33.3%

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

   8. Taylor expanded in k around 0 33.2%

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

      1. *-commutative 33.2%

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

   10. Simplified 33.2%

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

4. Final simplification 43.7%

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

Alternative 9: 28.0% accurate, 6.7× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ a_s = \mathsf{copysign}\left(1, a\right) \\ a_s \cdot \begin{array}{l} \mathbf{if}\;k \leq -2.05 \cdot 10^{+120} \lor \neg \left(k \leq 0.075\right):\\ \;\;\;\;0.1 \cdot \frac{a_m}{k}\\ \mathbf{else}:\\ \;\;\;\;a_m \cdot \left(1 + k \cdot -10\right)\\ \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
a_s = (copysign.f64 1 a)
(FPCore (a_s a_m k m)
 :precision binary64
 (*
  a_s
  (if (or (<= k -2.05e+120) (not (<= k 0.075)))
    (* 0.1 (/ a_m k))
    (* a_m (+ 1.0 (* k -10.0))))))

C

a_m = fabs(a);
a_s = copysign(1.0, a);
double code(double a_s, double a_m, double k, double m) {
	double tmp;
	if ((k <= -2.05e+120) || !(k <= 0.075)) {
		tmp = 0.1 * (a_m / k);
	} else {
		tmp = a_m * (1.0 + (k * -10.0));
	}
	return a_s * tmp;
}

Fortran

a_m = abs(a)
a_s = copysign(1.0d0, a)
real(8) function code(a_s, a_m, k, m)
    real(8), intent (in) :: a_s
    real(8), intent (in) :: a_m
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: tmp
    if ((k <= (-2.05d+120)) .or. (.not. (k <= 0.075d0))) then
        tmp = 0.1d0 * (a_m / k)
    else
        tmp = a_m * (1.0d0 + (k * (-10.0d0)))
    end if
    code = a_s * tmp
end function

Java

a_m = Math.abs(a);
a_s = Math.copySign(1.0, a);
public static double code(double a_s, double a_m, double k, double m) {
	double tmp;
	if ((k <= -2.05e+120) || !(k <= 0.075)) {
		tmp = 0.1 * (a_m / k);
	} else {
		tmp = a_m * (1.0 + (k * -10.0));
	}
	return a_s * tmp;
}

Python

a_m = math.fabs(a)
a_s = math.copysign(1.0, a)
def code(a_s, a_m, k, m):
	tmp = 0
	if (k <= -2.05e+120) or not (k <= 0.075):
		tmp = 0.1 * (a_m / k)
	else:
		tmp = a_m * (1.0 + (k * -10.0))
	return a_s * tmp

Julia

a_m = abs(a)
a_s = copysign(1.0, a)
function code(a_s, a_m, k, m)
	tmp = 0.0
	if ((k <= -2.05e+120) || !(k <= 0.075))
		tmp = Float64(0.1 * Float64(a_m / k));
	else
		tmp = Float64(a_m * Float64(1.0 + Float64(k * -10.0)));
	end
	return Float64(a_s * tmp)
end

MATLAB

a_m = abs(a);
a_s = sign(a) * abs(1.0);
function tmp_2 = code(a_s, a_m, k, m)
	tmp = 0.0;
	if ((k <= -2.05e+120) || ~((k <= 0.075)))
		tmp = 0.1 * (a_m / k);
	else
		tmp = a_m * (1.0 + (k * -10.0));
	end
	tmp_2 = a_s * tmp;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
a_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, a$95$m_, k_, m_] := N[(a$95$s * If[Or[LessEqual[k, -2.05e+120], N[Not[LessEqual[k, 0.075]], $MachinePrecision]], N[(0.1 * N[(a$95$m / k), $MachinePrecision]), $MachinePrecision], N[(a$95$m * N[(1.0 + N[(k * -10.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

1. Split input into 2 regimes

2. if k < -2.05e120 or 0.0749999999999999972 < k

   1. Initial program 79.1%

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

      1. *-commutative 79.1%

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

   3. Simplified 79.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 m around 0 55.5%

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

   6. Taylor expanded in k around 0 23.0%

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

      1. *-commutative 23.0%

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

   8. Simplified 23.0%

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

   9. Taylor expanded in k around inf 23.0%

      \[\leadsto \color{blue}{0.1 \cdot \frac{a}{k}} \]

   if -2.05e120 < k < 0.0749999999999999972

   1. Initial program 99.9%

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

      1. *-commutative 99.9%

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

   3. Simplified 99.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 m around 0 33.3%

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

      1. frac-2neg 33.3%

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

      2. +-commutative 33.3%

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

      3. distribute-neg-in 33.3%

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

      4. pow2 33.3%

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

      5. distribute-rgt-in 33.3%

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

      6. +-commutative 33.3%

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

      7. distribute-neg-in 33.3%

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

      8. fma-udef 33.3%

         \[\leadsto \frac{-a}{-\color{blue}{\mathsf{fma}\left(k, k + 10, 1\right)}} \]

      9. frac-2neg 33.3%

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

      10. clear-num 33.3%

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

      11. associate-/r/ 33.3%

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

   7. Applied egg-rr 33.3%

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

   8. Taylor expanded in k around 0 33.2%

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

      1. *-commutative 33.2%

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

   10. Simplified 33.2%

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

4. Final simplification 28.2%

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

Alternative 10: 27.5% accurate, 7.6× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ a_s = \mathsf{copysign}\left(1, a\right) \\ a_s \cdot \begin{array}{l} \mathbf{if}\;k \leq -1.15 \cdot 10^{+119} \lor \neg \left(k \leq 0.1\right):\\ \;\;\;\;0.1 \cdot \frac{a_m}{k}\\ \mathbf{else}:\\ \;\;\;\;a_m\\ \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
a_s = (copysign.f64 1 a)
(FPCore (a_s a_m k m)
 :precision binary64
 (* a_s (if (or (<= k -1.15e+119) (not (<= k 0.1))) (* 0.1 (/ a_m k)) a_m)))

C

a_m = fabs(a);
a_s = copysign(1.0, a);
double code(double a_s, double a_m, double k, double m) {
	double tmp;
	if ((k <= -1.15e+119) || !(k <= 0.1)) {
		tmp = 0.1 * (a_m / k);
	} else {
		tmp = a_m;
	}
	return a_s * tmp;
}

Fortran

a_m = abs(a)
a_s = copysign(1.0d0, a)
real(8) function code(a_s, a_m, k, m)
    real(8), intent (in) :: a_s
    real(8), intent (in) :: a_m
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: tmp
    if ((k <= (-1.15d+119)) .or. (.not. (k <= 0.1d0))) then
        tmp = 0.1d0 * (a_m / k)
    else
        tmp = a_m
    end if
    code = a_s * tmp
end function

Java

a_m = Math.abs(a);
a_s = Math.copySign(1.0, a);
public static double code(double a_s, double a_m, double k, double m) {
	double tmp;
	if ((k <= -1.15e+119) || !(k <= 0.1)) {
		tmp = 0.1 * (a_m / k);
	} else {
		tmp = a_m;
	}
	return a_s * tmp;
}

Python

a_m = math.fabs(a)
a_s = math.copysign(1.0, a)
def code(a_s, a_m, k, m):
	tmp = 0
	if (k <= -1.15e+119) or not (k <= 0.1):
		tmp = 0.1 * (a_m / k)
	else:
		tmp = a_m
	return a_s * tmp

Julia

a_m = abs(a)
a_s = copysign(1.0, a)
function code(a_s, a_m, k, m)
	tmp = 0.0
	if ((k <= -1.15e+119) || !(k <= 0.1))
		tmp = Float64(0.1 * Float64(a_m / k));
	else
		tmp = a_m;
	end
	return Float64(a_s * tmp)
end

MATLAB

a_m = abs(a);
a_s = sign(a) * abs(1.0);
function tmp_2 = code(a_s, a_m, k, m)
	tmp = 0.0;
	if ((k <= -1.15e+119) || ~((k <= 0.1)))
		tmp = 0.1 * (a_m / k);
	else
		tmp = a_m;
	end
	tmp_2 = a_s * tmp;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
a_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, a$95$m_, k_, m_] := N[(a$95$s * If[Or[LessEqual[k, -1.15e+119], N[Not[LessEqual[k, 0.1]], $MachinePrecision]], N[(0.1 * N[(a$95$m / k), $MachinePrecision]), $MachinePrecision], a$95$m]), $MachinePrecision]

Derivation

1. Split input into 2 regimes

2. if k < -1.15e119 or 0.10000000000000001 < k

   1. Initial program 79.1%

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

      1. *-commutative 79.1%

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

   3. Simplified 79.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 m around 0 55.5%

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

   6. Taylor expanded in k around 0 23.0%

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

      1. *-commutative 23.0%

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

   8. Simplified 23.0%

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

   9. Taylor expanded in k around inf 23.0%

      \[\leadsto \color{blue}{0.1 \cdot \frac{a}{k}} \]

   if -1.15e119 < k < 0.10000000000000001

   1. Initial program 99.9%

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

      1. associate-*l/ 99.2%

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

      2. sqr-neg 99.2%

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

      3. associate-+l+ 99.2%

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

      4. sqr-neg 99.2%

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

      5. distribute-rgt-out 99.2%

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

   3. Simplified 99.2%

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

   5. Taylor expanded in m around 0 33.3%

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

   6. Taylor expanded in k around 0 31.9%

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

4. Final simplification 27.5%

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

Alternative 11: 46.2% accurate, 8.1× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ a_s = \mathsf{copysign}\left(1, a\right) \\ \begin{array}{l} t_0 := k \cdot \left(k + 10\right)\\ a_s \cdot \begin{array}{l} \mathbf{if}\;m \leq -1.6 \cdot 10^{+36}:\\ \;\;\;\;a_m \cdot \frac{1}{t_0}\\ \mathbf{else}:\\ \;\;\;\;\frac{a_m}{1 + t_0}\\ \end{array} \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
a_s = (copysign.f64 1 a)
(FPCore (a_s a_m k m)
 :precision binary64
 (let* ((t_0 (* k (+ k 10.0))))
   (* a_s (if (<= m -1.6e+36) (* a_m (/ 1.0 t_0)) (/ a_m (+ 1.0 t_0))))))

C

a_m = fabs(a);
a_s = copysign(1.0, a);
double code(double a_s, double a_m, double k, double m) {
	double t_0 = k * (k + 10.0);
	double tmp;
	if (m <= -1.6e+36) {
		tmp = a_m * (1.0 / t_0);
	} else {
		tmp = a_m / (1.0 + t_0);
	}
	return a_s * tmp;
}

Fortran

a_m = abs(a)
a_s = copysign(1.0d0, a)
real(8) function code(a_s, a_m, k, m)
    real(8), intent (in) :: a_s
    real(8), intent (in) :: a_m
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: t_0
    real(8) :: tmp
    t_0 = k * (k + 10.0d0)
    if (m <= (-1.6d+36)) then
        tmp = a_m * (1.0d0 / t_0)
    else
        tmp = a_m / (1.0d0 + t_0)
    end if
    code = a_s * tmp
end function

Java

a_m = Math.abs(a);
a_s = Math.copySign(1.0, a);
public static double code(double a_s, double a_m, double k, double m) {
	double t_0 = k * (k + 10.0);
	double tmp;
	if (m <= -1.6e+36) {
		tmp = a_m * (1.0 / t_0);
	} else {
		tmp = a_m / (1.0 + t_0);
	}
	return a_s * tmp;
}

Python

a_m = math.fabs(a)
a_s = math.copysign(1.0, a)
def code(a_s, a_m, k, m):
	t_0 = k * (k + 10.0)
	tmp = 0
	if m <= -1.6e+36:
		tmp = a_m * (1.0 / t_0)
	else:
		tmp = a_m / (1.0 + t_0)
	return a_s * tmp

Julia

a_m = abs(a)
a_s = copysign(1.0, a)
function code(a_s, a_m, k, m)
	t_0 = Float64(k * Float64(k + 10.0))
	tmp = 0.0
	if (m <= -1.6e+36)
		tmp = Float64(a_m * Float64(1.0 / t_0));
	else
		tmp = Float64(a_m / Float64(1.0 + t_0));
	end
	return Float64(a_s * tmp)
end

MATLAB

a_m = abs(a);
a_s = sign(a) * abs(1.0);
function tmp_2 = code(a_s, a_m, k, m)
	t_0 = k * (k + 10.0);
	tmp = 0.0;
	if (m <= -1.6e+36)
		tmp = a_m * (1.0 / t_0);
	else
		tmp = a_m / (1.0 + t_0);
	end
	tmp_2 = a_s * tmp;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
a_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, a$95$m_, k_, m_] := Block[{t$95$0 = N[(k * N[(k + 10.0), $MachinePrecision]), $MachinePrecision]}, N[(a$95$s * If[LessEqual[m, -1.6e+36], N[(a$95$m * N[(1.0 / t$95$0), $MachinePrecision]), $MachinePrecision], N[(a$95$m / N[(1.0 + t$95$0), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if m < -1.5999999999999999e36

   1. Initial program 100.0%

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

      1. *-commutative 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in m around 0 41.8%

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

      1. frac-2neg 41.8%

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

      2. +-commutative 41.8%

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

      3. distribute-neg-in 41.8%

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

      4. pow2 41.8%

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

      5. distribute-rgt-in 41.8%

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

      6. +-commutative 41.8%

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

      7. distribute-neg-in 41.8%

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

      8. fma-udef 41.8%

         \[\leadsto \frac{-a}{-\color{blue}{\mathsf{fma}\left(k, k + 10, 1\right)}} \]

      9. frac-2neg 41.8%

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

      10. clear-num 41.8%

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

      11. associate-/r/ 41.8%

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

   7. Applied egg-rr 41.8%

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

   8. Taylor expanded in k around inf 50.3%

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

      1. +-commutative 50.3%

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

      2. unpow2 50.3%

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

      3. distribute-rgt-in 50.3%

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

   10. Simplified 50.3%

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

   if -1.5999999999999999e36 < m

   1. Initial program 85.5%

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

      1. associate-*l/ 82.3%

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

      2. sqr-neg 82.3%

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

      3. associate-+l+ 82.3%

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

      4. sqr-neg 82.3%

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

      5. distribute-rgt-out 82.3%

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

   3. Simplified 82.3%

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

   5. Taylor expanded in m around 0 45.2%

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

4. Final simplification 46.7%

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

Alternative 12: 29.5% accurate, 9.5× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ a_s = \mathsf{copysign}\left(1, a\right) \\ a_s \cdot \begin{array}{l} \mathbf{if}\;m \leq -2.8 \cdot 10^{+36}:\\ \;\;\;\;0.1 \cdot \frac{a_m}{k}\\ \mathbf{else}:\\ \;\;\;\;\frac{a_m}{1 + k \cdot 10}\\ \end{array} \end{array} \]

FPCore

a_m = (fabs.f64 a)
a_s = (copysign.f64 1 a)
(FPCore (a_s a_m k m)
 :precision binary64
 (* a_s (if (<= m -2.8e+36) (* 0.1 (/ a_m k)) (/ a_m (+ 1.0 (* k 10.0))))))

C

a_m = fabs(a);
a_s = copysign(1.0, a);
double code(double a_s, double a_m, double k, double m) {
	double tmp;
	if (m <= -2.8e+36) {
		tmp = 0.1 * (a_m / k);
	} else {
		tmp = a_m / (1.0 + (k * 10.0));
	}
	return a_s * tmp;
}

Fortran

a_m = abs(a)
a_s = copysign(1.0d0, a)
real(8) function code(a_s, a_m, k, m)
    real(8), intent (in) :: a_s
    real(8), intent (in) :: a_m
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    real(8) :: tmp
    if (m <= (-2.8d+36)) then
        tmp = 0.1d0 * (a_m / k)
    else
        tmp = a_m / (1.0d0 + (k * 10.0d0))
    end if
    code = a_s * tmp
end function

Java

a_m = Math.abs(a);
a_s = Math.copySign(1.0, a);
public static double code(double a_s, double a_m, double k, double m) {
	double tmp;
	if (m <= -2.8e+36) {
		tmp = 0.1 * (a_m / k);
	} else {
		tmp = a_m / (1.0 + (k * 10.0));
	}
	return a_s * tmp;
}

Python

a_m = math.fabs(a)
a_s = math.copysign(1.0, a)
def code(a_s, a_m, k, m):
	tmp = 0
	if m <= -2.8e+36:
		tmp = 0.1 * (a_m / k)
	else:
		tmp = a_m / (1.0 + (k * 10.0))
	return a_s * tmp

Julia

a_m = abs(a)
a_s = copysign(1.0, a)
function code(a_s, a_m, k, m)
	tmp = 0.0
	if (m <= -2.8e+36)
		tmp = Float64(0.1 * Float64(a_m / k));
	else
		tmp = Float64(a_m / Float64(1.0 + Float64(k * 10.0)));
	end
	return Float64(a_s * tmp)
end

MATLAB

a_m = abs(a);
a_s = sign(a) * abs(1.0);
function tmp_2 = code(a_s, a_m, k, m)
	tmp = 0.0;
	if (m <= -2.8e+36)
		tmp = 0.1 * (a_m / k);
	else
		tmp = a_m / (1.0 + (k * 10.0));
	end
	tmp_2 = a_s * tmp;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
a_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, a$95$m_, k_, m_] := N[(a$95$s * If[LessEqual[m, -2.8e+36], N[(0.1 * N[(a$95$m / k), $MachinePrecision]), $MachinePrecision], N[(a$95$m / N[(1.0 + N[(k * 10.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

1. Split input into 2 regimes

2. if m < -2.8000000000000001e36

   1. Initial program 100.0%

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

      1. *-commutative 100.0%

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

   3. Simplified 100.0%

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

   5. Taylor expanded in m around 0 41.8%

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

   6. Taylor expanded in k around 0 17.4%

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

      1. *-commutative 17.4%

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

   8. Simplified 17.4%

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

   9. Taylor expanded in k around inf 25.9%

      \[\leadsto \color{blue}{0.1 \cdot \frac{a}{k}} \]

   if -2.8000000000000001e36 < m

   1. Initial program 85.5%

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

      1. *-commutative 85.5%

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

   3. Simplified 85.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 m around 0 45.3%

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

   6. Taylor expanded in k around 0 31.8%

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

      1. *-commutative 31.8%

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

   8. Simplified 31.8%

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

4. Final simplification 30.2%

   \[\leadsto \begin{array}{l} \mathbf{if}\;m \leq -2.8 \cdot 10^{+36}:\\ \;\;\;\;0.1 \cdot \frac{a}{k}\\ \mathbf{else}:\\ \;\;\;\;\frac{a}{1 + k \cdot 10}\\ \end{array} \]
5. Add Preprocessing

Alternative 13: 20.1% accurate, 114.0× speedup

Math

\[\begin{array}{l} a_m = \left|a\right| \\ a_s = \mathsf{copysign}\left(1, a\right) \\ a_s \cdot a_m \end{array} \]

FPCore

a_m = (fabs.f64 a)
a_s = (copysign.f64 1 a)
(FPCore (a_s a_m k m) :precision binary64 (* a_s a_m))

C

a_m = fabs(a);
a_s = copysign(1.0, a);
double code(double a_s, double a_m, double k, double m) {
	return a_s * a_m;
}

Fortran

a_m = abs(a)
a_s = copysign(1.0d0, a)
real(8) function code(a_s, a_m, k, m)
    real(8), intent (in) :: a_s
    real(8), intent (in) :: a_m
    real(8), intent (in) :: k
    real(8), intent (in) :: m
    code = a_s * a_m
end function

Java

a_m = Math.abs(a);
a_s = Math.copySign(1.0, a);
public static double code(double a_s, double a_m, double k, double m) {
	return a_s * a_m;
}

Python

a_m = math.fabs(a)
a_s = math.copysign(1.0, a)
def code(a_s, a_m, k, m):
	return a_s * a_m

Julia

a_m = abs(a)
a_s = copysign(1.0, a)
function code(a_s, a_m, k, m)
	return Float64(a_s * a_m)
end

MATLAB

a_m = abs(a);
a_s = sign(a) * abs(1.0);
function tmp = code(a_s, a_m, k, m)
	tmp = a_s * a_m;
end

Wolfram

a_m = N[Abs[a], $MachinePrecision]
a_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[a]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[a$95$s_, a$95$m_, k_, m_] := N[(a$95$s * a$95$m), $MachinePrecision]

Derivation

1. Initial program 89.6%

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

   1. associate-*l/ 87.3%

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

   2. sqr-neg 87.3%

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

   3. associate-+l+ 87.3%

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

   4. sqr-neg 87.3%

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

   5. distribute-rgt-out 87.2%

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

3. Simplified 87.2%

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

5. Taylor expanded in m around 0 44.3%

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

6. Taylor expanded in k around 0 18.2%

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

7. Final simplification 18.2%

   \[\leadsto a \]
8. Add Preprocessing

Reproduce

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