Maksimov and Kolovsky, Equation (4)

Percentage Accurate: 86.5% → 86.5%

Time: 3.0s

Alternatives: 11

Speedup: 1.0×

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

Specification

\[\mathsf{TRUE}\left(\right)\]

Math

\[\begin{array}{l} \\ \left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (+ (* (* J (- (exp l) (exp (- l)))) (cos (/ K 2.0))) U))

C

double code(double J, double l, double K, double U) {
	return ((J * (exp(l) - exp(-l))) * cos((K / 2.0))) + U;
}

Fortran

real(8) function code(j, l, k, u)
    real(8), intent (in) :: j
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8), intent (in) :: u
    code = ((j * (exp(l) - exp(-l))) * cos((k / 2.0d0))) + u
end function

Java

public static double code(double J, double l, double K, double U) {
	return ((J * (Math.exp(l) - Math.exp(-l))) * Math.cos((K / 2.0))) + U;
}

Python

def code(J, l, K, U):
	return ((J * (math.exp(l) - math.exp(-l))) * math.cos((K / 2.0))) + U

Julia

function code(J, l, K, U)
	return Float64(Float64(Float64(J * Float64(exp(l) - exp(Float64(-l)))) * cos(Float64(K / 2.0))) + U)
end

MATLAB

function tmp = code(J, l, K, U)
	tmp = ((J * (exp(l) - exp(-l))) * cos((K / 2.0))) + U;
end

Wolfram

code[J_, l_, K_, U_] := N[(N[(N[(J * N[(N[Exp[l], $MachinePrecision] - N[Exp[(-l)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(K / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]

Initial Program: 86.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (+ (* (* J (- (exp l) (exp (- l)))) (cos (/ K 2.0))) U))

C

double code(double J, double l, double K, double U) {
	return ((J * (exp(l) - exp(-l))) * cos((K / 2.0))) + U;
}

Fortran

real(8) function code(j, l, k, u)
    real(8), intent (in) :: j
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8), intent (in) :: u
    code = ((j * (exp(l) - exp(-l))) * cos((k / 2.0d0))) + u
end function

Java

public static double code(double J, double l, double K, double U) {
	return ((J * (Math.exp(l) - Math.exp(-l))) * Math.cos((K / 2.0))) + U;
}

Python

def code(J, l, K, U):
	return ((J * (math.exp(l) - math.exp(-l))) * math.cos((K / 2.0))) + U

Julia

function code(J, l, K, U)
	return Float64(Float64(Float64(J * Float64(exp(l) - exp(Float64(-l)))) * cos(Float64(K / 2.0))) + U)
end

MATLAB

function tmp = code(J, l, K, U)
	tmp = ((J * (exp(l) - exp(-l))) * cos((K / 2.0))) + U;
end

Wolfram

code[J_, l_, K_, U_] := N[(N[(N[(J * N[(N[Exp[l], $MachinePrecision] - N[Exp[(-l)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(K / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]

Alternative 1: 86.5% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (+ (* (* J (- (exp l) (exp (- l)))) (cos (/ K 2.0))) U))

C

double code(double J, double l, double K, double U) {
	return ((J * (exp(l) - exp(-l))) * cos((K / 2.0))) + U;
}

Fortran

real(8) function code(j, l, k, u)
    real(8), intent (in) :: j
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8), intent (in) :: u
    code = ((j * (exp(l) - exp(-l))) * cos((k / 2.0d0))) + u
end function

Java

public static double code(double J, double l, double K, double U) {
	return ((J * (Math.exp(l) - Math.exp(-l))) * Math.cos((K / 2.0))) + U;
}

Python

def code(J, l, K, U):
	return ((J * (math.exp(l) - math.exp(-l))) * math.cos((K / 2.0))) + U

Julia

function code(J, l, K, U)
	return Float64(Float64(Float64(J * Float64(exp(l) - exp(Float64(-l)))) * cos(Float64(K / 2.0))) + U)
end

MATLAB

function tmp = code(J, l, K, U)
	tmp = ((J * (exp(l) - exp(-l))) * cos((K / 2.0))) + U;
end

Wolfram

code[J_, l_, K_, U_] := N[(N[(N[(J * N[(N[Exp[l], $MachinePrecision] - N[Exp[(-l)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(K / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]

Derivation

1. Initial program 85.8%

   \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
2. Add Preprocessing
3. Add Preprocessing

Alternative 2: 86.2% accurate, 0.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := J \cdot \left(e^{\ell} - e^{-\ell}\right)\\ t_1 := t\_0 \cdot \cos \left(\frac{K}{2}\right)\\ \mathbf{if}\;t\_1 \leq -2 \cdot 10^{+262}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t\_1 \leq 10^{+127}:\\ \;\;\;\;t\_0 + U\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0 (* J (- (exp l) (exp (- l))))) (t_1 (* t_0 (cos (/ K 2.0)))))
   (if (<= t_1 -2e+262) t_1 (if (<= t_1 1e+127) (+ t_0 U) t_1))))

C

double code(double J, double l, double K, double U) {
	double t_0 = J * (exp(l) - exp(-l));
	double t_1 = t_0 * cos((K / 2.0));
	double tmp;
	if (t_1 <= -2e+262) {
		tmp = t_1;
	} else if (t_1 <= 1e+127) {
		tmp = t_0 + U;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(j, l, k, u)
    real(8), intent (in) :: j
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8), intent (in) :: u
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = j * (exp(l) - exp(-l))
    t_1 = t_0 * cos((k / 2.0d0))
    if (t_1 <= (-2d+262)) then
        tmp = t_1
    else if (t_1 <= 1d+127) then
        tmp = t_0 + u
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = J * (Math.exp(l) - Math.exp(-l));
	double t_1 = t_0 * Math.cos((K / 2.0));
	double tmp;
	if (t_1 <= -2e+262) {
		tmp = t_1;
	} else if (t_1 <= 1e+127) {
		tmp = t_0 + U;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = J * (math.exp(l) - math.exp(-l))
	t_1 = t_0 * math.cos((K / 2.0))
	tmp = 0
	if t_1 <= -2e+262:
		tmp = t_1
	elif t_1 <= 1e+127:
		tmp = t_0 + U
	else:
		tmp = t_1
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(J * Float64(exp(l) - exp(Float64(-l))))
	t_1 = Float64(t_0 * cos(Float64(K / 2.0)))
	tmp = 0.0
	if (t_1 <= -2e+262)
		tmp = t_1;
	elseif (t_1 <= 1e+127)
		tmp = Float64(t_0 + U);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = J * (exp(l) - exp(-l));
	t_1 = t_0 * cos((K / 2.0));
	tmp = 0.0;
	if (t_1 <= -2e+262)
		tmp = t_1;
	elseif (t_1 <= 1e+127)
		tmp = t_0 + U;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(J * N[(N[Exp[l], $MachinePrecision] - N[Exp[(-l)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(t$95$0 * N[Cos[N[(K / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t$95$1, -2e+262], t$95$1, If[LessEqual[t$95$1, 1e+127], N[(t$95$0 + U), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 2 regimes

2. if (*.f64 (*.f64 J (-.f64 (exp.f64 l) (exp.f64 (neg.f64 l)))) (cos.f64 (/.f64 K #s(literal 2 binary64)))) < -2e262 or 9.99999999999999955e126 < (*.f64 (*.f64 J (-.f64 (exp.f64 l) (exp.f64 (neg.f64 l)))) (cos.f64 (/.f64 K #s(literal 2 binary64))))

   1. Initial program 99.2%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{U + J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} \]

   5. Applied rewrites 99.2%

      \[\leadsto \color{blue}{\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right)} \]

   if -2e262 < (*.f64 (*.f64 J (-.f64 (exp.f64 l) (exp.f64 (neg.f64 l)))) (cos.f64 (/.f64 K #s(literal 2 binary64)))) < 9.99999999999999955e126

   1. Initial program 72.6%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 72.2%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 3: 72.3% accurate, 0.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{\ell} - e^{-\ell}\\ t_1 := J \cdot t\_0\\ \mathbf{if}\;t\_0 \leq -0.002:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;t\_0 \leq 0.004:\\ \;\;\;\;t\_0 + U\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0 (- (exp l) (exp (- l)))) (t_1 (* J t_0)))
   (if (<= t_0 -0.002) t_1 (if (<= t_0 0.004) (+ t_0 U) t_1))))

C

double code(double J, double l, double K, double U) {
	double t_0 = exp(l) - exp(-l);
	double t_1 = J * t_0;
	double tmp;
	if (t_0 <= -0.002) {
		tmp = t_1;
	} else if (t_0 <= 0.004) {
		tmp = t_0 + U;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Fortran

real(8) function code(j, l, k, u)
    real(8), intent (in) :: j
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8), intent (in) :: u
    real(8) :: t_0
    real(8) :: t_1
    real(8) :: tmp
    t_0 = exp(l) - exp(-l)
    t_1 = j * t_0
    if (t_0 <= (-0.002d0)) then
        tmp = t_1
    else if (t_0 <= 0.004d0) then
        tmp = t_0 + u
    else
        tmp = t_1
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = Math.exp(l) - Math.exp(-l);
	double t_1 = J * t_0;
	double tmp;
	if (t_0 <= -0.002) {
		tmp = t_1;
	} else if (t_0 <= 0.004) {
		tmp = t_0 + U;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = math.exp(l) - math.exp(-l)
	t_1 = J * t_0
	tmp = 0
	if t_0 <= -0.002:
		tmp = t_1
	elif t_0 <= 0.004:
		tmp = t_0 + U
	else:
		tmp = t_1
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(exp(l) - exp(Float64(-l)))
	t_1 = Float64(J * t_0)
	tmp = 0.0
	if (t_0 <= -0.002)
		tmp = t_1;
	elseif (t_0 <= 0.004)
		tmp = Float64(t_0 + U);
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = exp(l) - exp(-l);
	t_1 = J * t_0;
	tmp = 0.0;
	if (t_0 <= -0.002)
		tmp = t_1;
	elseif (t_0 <= 0.004)
		tmp = t_0 + U;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(N[Exp[l], $MachinePrecision] - N[Exp[(-l)], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(J * t$95$0), $MachinePrecision]}, If[LessEqual[t$95$0, -0.002], t$95$1, If[LessEqual[t$95$0, 0.004], N[(t$95$0 + U), $MachinePrecision], t$95$1]]]]

Derivation

1. Split input into 2 regimes

2. if (-.f64 (exp.f64 l) (exp.f64 (neg.f64 l))) < -2e-3 or 0.0040000000000000001 < (-.f64 (exp.f64 l) (exp.f64 (neg.f64 l)))

   1. Initial program 99.9%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 76.3%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in J around 0

      \[\leadsto \color{blue}{U + J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} \]

   8. Applied rewrites 76.3%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} \]

   if -2e-3 < (-.f64 (exp.f64 l) (exp.f64 (neg.f64 l))) < 0.0040000000000000001

   1. Initial program 71.8%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 71.0%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in J around 0

      \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

   8. Applied rewrites 70.8%

      \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 4: 45.6% accurate, 0.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \leq 10^{+307}:\\ \;\;\;\;\left(-\ell\right) + U\\ \mathbf{else}:\\ \;\;\;\;e^{\ell}\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (if (<= (+ (* (* J (- (exp l) (exp (- l)))) (cos (/ K 2.0))) U) 1e+307)
   (+ (- l) U)
   (exp l)))

C

double code(double J, double l, double K, double U) {
	double tmp;
	if ((((J * (exp(l) - exp(-l))) * cos((K / 2.0))) + U) <= 1e+307) {
		tmp = -l + U;
	} else {
		tmp = exp(l);
	}
	return tmp;
}

Fortran

real(8) function code(j, l, k, u)
    real(8), intent (in) :: j
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8), intent (in) :: u
    real(8) :: tmp
    if ((((j * (exp(l) - exp(-l))) * cos((k / 2.0d0))) + u) <= 1d+307) then
        tmp = -l + u
    else
        tmp = exp(l)
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double tmp;
	if ((((J * (Math.exp(l) - Math.exp(-l))) * Math.cos((K / 2.0))) + U) <= 1e+307) {
		tmp = -l + U;
	} else {
		tmp = Math.exp(l);
	}
	return tmp;
}

Python

def code(J, l, K, U):
	tmp = 0
	if (((J * (math.exp(l) - math.exp(-l))) * math.cos((K / 2.0))) + U) <= 1e+307:
		tmp = -l + U
	else:
		tmp = math.exp(l)
	return tmp

Julia

function code(J, l, K, U)
	tmp = 0.0
	if (Float64(Float64(Float64(J * Float64(exp(l) - exp(Float64(-l)))) * cos(Float64(K / 2.0))) + U) <= 1e+307)
		tmp = Float64(Float64(-l) + U);
	else
		tmp = exp(l);
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	tmp = 0.0;
	if ((((J * (exp(l) - exp(-l))) * cos((K / 2.0))) + U) <= 1e+307)
		tmp = -l + U;
	else
		tmp = exp(l);
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := If[LessEqual[N[(N[(N[(J * N[(N[Exp[l], $MachinePrecision] - N[Exp[(-l)], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(K / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision], 1e+307], N[((-l) + U), $MachinePrecision], N[Exp[l], $MachinePrecision]]

Derivation

1. Split input into 2 regimes

2. if (+.f64 (*.f64 (*.f64 J (-.f64 (exp.f64 l) (exp.f64 (neg.f64 l)))) (cos.f64 (/.f64 K #s(literal 2 binary64)))) U) < 9.99999999999999986e306

   1. Initial program 81.3%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 75.6%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in J around 0

      \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

   8. Applied rewrites 63.8%

      \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]

   9. Taylor expanded in l around 0

      \[\leadsto \ell \cdot \color{blue}{\left(2 \cdot J + {\ell}^{2} \cdot \left(\frac{1}{3} \cdot J + {\ell}^{2} \cdot \left(\frac{1}{2520} \cdot \left(J \cdot {\ell}^{2}\right) + \frac{1}{60} \cdot J\right)\right)\right)} + U \]

   11. Applied rewrites 43.2%

       \[\leadsto \left(-\ell\right) + U \]

   if 9.99999999999999986e306 < (+.f64 (*.f64 (*.f64 J (-.f64 (exp.f64 l) (exp.f64 (neg.f64 l)))) (cos.f64 (/.f64 K #s(literal 2 binary64)))) U)

   1. Initial program 100.0%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around -inf

      \[\leadsto \color{blue}{-1 \cdot \left(J \cdot \left(-1 \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right) + -1 \cdot \frac{U}{J}\right)\right)} \]

   5. Applied rewrites 59.7%

      \[\leadsto \color{blue}{e^{\ell}} \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 5: 80.0% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{\ell} - e^{-\ell}\\ \mathbf{if}\;\cos \left(\frac{K}{2}\right) \leq 0.02:\\ \;\;\;\;t\_0 + U\\ \mathbf{else}:\\ \;\;\;\;J \cdot t\_0 + U\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0 (- (exp l) (exp (- l)))))
   (if (<= (cos (/ K 2.0)) 0.02) (+ t_0 U) (+ (* J t_0) U))))

C

double code(double J, double l, double K, double U) {
	double t_0 = exp(l) - exp(-l);
	double tmp;
	if (cos((K / 2.0)) <= 0.02) {
		tmp = t_0 + U;
	} else {
		tmp = (J * t_0) + U;
	}
	return tmp;
}

Fortran

real(8) function code(j, l, k, u)
    real(8), intent (in) :: j
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8), intent (in) :: u
    real(8) :: t_0
    real(8) :: tmp
    t_0 = exp(l) - exp(-l)
    if (cos((k / 2.0d0)) <= 0.02d0) then
        tmp = t_0 + u
    else
        tmp = (j * t_0) + u
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = Math.exp(l) - Math.exp(-l);
	double tmp;
	if (Math.cos((K / 2.0)) <= 0.02) {
		tmp = t_0 + U;
	} else {
		tmp = (J * t_0) + U;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = math.exp(l) - math.exp(-l)
	tmp = 0
	if math.cos((K / 2.0)) <= 0.02:
		tmp = t_0 + U
	else:
		tmp = (J * t_0) + U
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(exp(l) - exp(Float64(-l)))
	tmp = 0.0
	if (cos(Float64(K / 2.0)) <= 0.02)
		tmp = Float64(t_0 + U);
	else
		tmp = Float64(Float64(J * t_0) + U);
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = exp(l) - exp(-l);
	tmp = 0.0;
	if (cos((K / 2.0)) <= 0.02)
		tmp = t_0 + U;
	else
		tmp = (J * t_0) + U;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(N[Exp[l], $MachinePrecision] - N[Exp[(-l)], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[N[Cos[N[(K / 2.0), $MachinePrecision]], $MachinePrecision], 0.02], N[(t$95$0 + U), $MachinePrecision], N[(N[(J * t$95$0), $MachinePrecision] + U), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if (cos.f64 (/.f64 K #s(literal 2 binary64))) < 0.0200000000000000004

   1. Initial program 81.6%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 32.5%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in J around 0

      \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

   8. Applied rewrites 61.2%

      \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]

   if 0.0200000000000000004 < (cos.f64 (/.f64 K #s(literal 2 binary64)))

   1. Initial program 87.1%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 87.0%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 6: 61.3% accurate, 1.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{-\ell}\\ \mathbf{if}\;J \leq -2.1 \cdot 10^{+34}:\\ \;\;\;\;t\_0 + U\\ \mathbf{else}:\\ \;\;\;\;\left(e^{\ell} - t\_0\right) + U\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0 (exp (- l))))
   (if (<= J -2.1e+34) (+ t_0 U) (+ (- (exp l) t_0) U))))

C

double code(double J, double l, double K, double U) {
	double t_0 = exp(-l);
	double tmp;
	if (J <= -2.1e+34) {
		tmp = t_0 + U;
	} else {
		tmp = (exp(l) - t_0) + U;
	}
	return tmp;
}

Fortran

real(8) function code(j, l, k, u)
    real(8), intent (in) :: j
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8), intent (in) :: u
    real(8) :: t_0
    real(8) :: tmp
    t_0 = exp(-l)
    if (j <= (-2.1d+34)) then
        tmp = t_0 + u
    else
        tmp = (exp(l) - t_0) + u
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = Math.exp(-l);
	double tmp;
	if (J <= -2.1e+34) {
		tmp = t_0 + U;
	} else {
		tmp = (Math.exp(l) - t_0) + U;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = math.exp(-l)
	tmp = 0
	if J <= -2.1e+34:
		tmp = t_0 + U
	else:
		tmp = (math.exp(l) - t_0) + U
	return tmp

Julia

function code(J, l, K, U)
	t_0 = exp(Float64(-l))
	tmp = 0.0
	if (J <= -2.1e+34)
		tmp = Float64(t_0 + U);
	else
		tmp = Float64(Float64(exp(l) - t_0) + U);
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = exp(-l);
	tmp = 0.0;
	if (J <= -2.1e+34)
		tmp = t_0 + U;
	else
		tmp = (exp(l) - t_0) + U;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[Exp[(-l)], $MachinePrecision]}, If[LessEqual[J, -2.1e+34], N[(t$95$0 + U), $MachinePrecision], N[(N[(N[Exp[l], $MachinePrecision] - t$95$0), $MachinePrecision] + U), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if J < -2.10000000000000017e34

   1. Initial program 68.9%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 56.9%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in l around 0

      \[\leadsto \ell \cdot \color{blue}{\left(\frac{1}{3} \cdot \left(J \cdot {\ell}^{2}\right) + 2 \cdot J\right)} + U \]

   8. Applied rewrites 38.6%

      \[\leadsto e^{-\ell} + U \]

   if -2.10000000000000017e34 < J

   1. Initial program 91.6%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 79.4%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in J around 0

      \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

   8. Applied rewrites 73.6%

      \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 7: 57.1% accurate, 1.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := e^{-\ell}\\ \mathbf{if}\;\ell \leq -1 \cdot 10^{+72}:\\ \;\;\;\;e^{\ell} - t\_0\\ \mathbf{elif}\;\ell \leq -20000:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;\ell \leq 4600000000000:\\ \;\;\;\;\left(-\ell\right) + U\\ \mathbf{else}:\\ \;\;\;\;e^{\ell} + U\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0 (exp (- l))))
   (if (<= l -1e+72)
     (- (exp l) t_0)
     (if (<= l -20000.0)
       t_0
       (if (<= l 4600000000000.0) (+ (- l) U) (+ (exp l) U))))))

C

double code(double J, double l, double K, double U) {
	double t_0 = exp(-l);
	double tmp;
	if (l <= -1e+72) {
		tmp = exp(l) - t_0;
	} else if (l <= -20000.0) {
		tmp = t_0;
	} else if (l <= 4600000000000.0) {
		tmp = -l + U;
	} else {
		tmp = exp(l) + U;
	}
	return tmp;
}

Fortran

real(8) function code(j, l, k, u)
    real(8), intent (in) :: j
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8), intent (in) :: u
    real(8) :: t_0
    real(8) :: tmp
    t_0 = exp(-l)
    if (l <= (-1d+72)) then
        tmp = exp(l) - t_0
    else if (l <= (-20000.0d0)) then
        tmp = t_0
    else if (l <= 4600000000000.0d0) then
        tmp = -l + u
    else
        tmp = exp(l) + u
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = Math.exp(-l);
	double tmp;
	if (l <= -1e+72) {
		tmp = Math.exp(l) - t_0;
	} else if (l <= -20000.0) {
		tmp = t_0;
	} else if (l <= 4600000000000.0) {
		tmp = -l + U;
	} else {
		tmp = Math.exp(l) + U;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = math.exp(-l)
	tmp = 0
	if l <= -1e+72:
		tmp = math.exp(l) - t_0
	elif l <= -20000.0:
		tmp = t_0
	elif l <= 4600000000000.0:
		tmp = -l + U
	else:
		tmp = math.exp(l) + U
	return tmp

Julia

function code(J, l, K, U)
	t_0 = exp(Float64(-l))
	tmp = 0.0
	if (l <= -1e+72)
		tmp = Float64(exp(l) - t_0);
	elseif (l <= -20000.0)
		tmp = t_0;
	elseif (l <= 4600000000000.0)
		tmp = Float64(Float64(-l) + U);
	else
		tmp = Float64(exp(l) + U);
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = exp(-l);
	tmp = 0.0;
	if (l <= -1e+72)
		tmp = exp(l) - t_0;
	elseif (l <= -20000.0)
		tmp = t_0;
	elseif (l <= 4600000000000.0)
		tmp = -l + U;
	else
		tmp = exp(l) + U;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[Exp[(-l)], $MachinePrecision]}, If[LessEqual[l, -1e+72], N[(N[Exp[l], $MachinePrecision] - t$95$0), $MachinePrecision], If[LessEqual[l, -20000.0], t$95$0, If[LessEqual[l, 4600000000000.0], N[((-l) + U), $MachinePrecision], N[(N[Exp[l], $MachinePrecision] + U), $MachinePrecision]]]]]

Derivation

1. Split input into 4 regimes

2. if l < -9.99999999999999944e71

   1. Initial program 100.0%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 77.8%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in J around 0

      \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

   8. Applied rewrites 64.4%

      \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]

   9. Taylor expanded in J around 0

      \[\leadsto \color{blue}{U + J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} \]

   11. Applied rewrites 64.4%

       \[\leadsto \color{blue}{e^{\ell} - e^{-\ell}} \]

   if -9.99999999999999944e71 < l < -2e4

   1. Initial program 100.0%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 81.8%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in J around 0

      \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

   8. Applied rewrites 18.2%

      \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]

   9. Taylor expanded in l around 0

      \[\leadsto \color{blue}{U + \ell \cdot \left(\frac{1}{3} \cdot \left(J \cdot \left({\ell}^{2} \cdot \cos \left(\frac{1}{2} \cdot K\right)\right)\right) + 2 \cdot \left(J \cdot \cos \left(\frac{1}{2} \cdot K\right)\right)\right)} \]

   11. Applied rewrites 81.8%

       \[\leadsto \color{blue}{e^{-\ell}} \]

   if -2e4 < l < 4.6e12

   1. Initial program 72.8%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 71.2%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in J around 0

      \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

   8. Applied rewrites 69.7%

      \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]

   9. Taylor expanded in l around 0

      \[\leadsto \ell \cdot \color{blue}{\left(2 \cdot J + {\ell}^{2} \cdot \left(\frac{1}{3} \cdot J + {\ell}^{2} \cdot \left(\frac{1}{2520} \cdot \left(J \cdot {\ell}^{2}\right) + \frac{1}{60} \cdot J\right)\right)\right)} + U \]

   11. Applied rewrites 61.7%

       \[\leadsto \left(-\ell\right) + U \]

   if 4.6e12 < l

   1. Initial program 100.0%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 74.2%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in J around 0

      \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

   8. Applied rewrites 54.5%

      \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]

   9. Taylor expanded in l around 0

      \[\leadsto \ell \cdot \color{blue}{\left(2 \cdot J + {\ell}^{2} \cdot \left(\frac{1}{60} \cdot \left(J \cdot {\ell}^{2}\right) + \frac{1}{3} \cdot J\right)\right)} + U \]

   11. Applied rewrites 54.5%

       \[\leadsto e^{\ell} + U \]
3. Recombined 4 regimes into one program.
4. Add Preprocessing

Alternative 8: 56.5% accurate, 2.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\ell \leq -20000:\\ \;\;\;\;e^{-\ell}\\ \mathbf{elif}\;\ell \leq 4600000000000:\\ \;\;\;\;\left(-\ell\right) + U\\ \mathbf{else}:\\ \;\;\;\;e^{\ell} + U\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (if (<= l -20000.0)
   (exp (- l))
   (if (<= l 4600000000000.0) (+ (- l) U) (+ (exp l) U))))

C

double code(double J, double l, double K, double U) {
	double tmp;
	if (l <= -20000.0) {
		tmp = exp(-l);
	} else if (l <= 4600000000000.0) {
		tmp = -l + U;
	} else {
		tmp = exp(l) + U;
	}
	return tmp;
}

Fortran

real(8) function code(j, l, k, u)
    real(8), intent (in) :: j
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8), intent (in) :: u
    real(8) :: tmp
    if (l <= (-20000.0d0)) then
        tmp = exp(-l)
    else if (l <= 4600000000000.0d0) then
        tmp = -l + u
    else
        tmp = exp(l) + u
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double tmp;
	if (l <= -20000.0) {
		tmp = Math.exp(-l);
	} else if (l <= 4600000000000.0) {
		tmp = -l + U;
	} else {
		tmp = Math.exp(l) + U;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	tmp = 0
	if l <= -20000.0:
		tmp = math.exp(-l)
	elif l <= 4600000000000.0:
		tmp = -l + U
	else:
		tmp = math.exp(l) + U
	return tmp

Julia

function code(J, l, K, U)
	tmp = 0.0
	if (l <= -20000.0)
		tmp = exp(Float64(-l));
	elseif (l <= 4600000000000.0)
		tmp = Float64(Float64(-l) + U);
	else
		tmp = Float64(exp(l) + U);
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	tmp = 0.0;
	if (l <= -20000.0)
		tmp = exp(-l);
	elseif (l <= 4600000000000.0)
		tmp = -l + U;
	else
		tmp = exp(l) + U;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := If[LessEqual[l, -20000.0], N[Exp[(-l)], $MachinePrecision], If[LessEqual[l, 4600000000000.0], N[((-l) + U), $MachinePrecision], N[(N[Exp[l], $MachinePrecision] + U), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if l < -2e4

   1. Initial program 100.0%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 78.6%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in J around 0

      \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

   8. Applied rewrites 55.4%

      \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]

   9. Taylor expanded in l around 0

      \[\leadsto \color{blue}{U + \ell \cdot \left(\frac{1}{3} \cdot \left(J \cdot \left({\ell}^{2} \cdot \cos \left(\frac{1}{2} \cdot K\right)\right)\right) + 2 \cdot \left(J \cdot \cos \left(\frac{1}{2} \cdot K\right)\right)\right)} \]

   11. Applied rewrites 44.6%

       \[\leadsto \color{blue}{e^{-\ell}} \]

   if -2e4 < l < 4.6e12

   1. Initial program 72.8%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 71.2%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in J around 0

      \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

   8. Applied rewrites 69.7%

      \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]

   9. Taylor expanded in l around 0

      \[\leadsto \ell \cdot \color{blue}{\left(2 \cdot J + {\ell}^{2} \cdot \left(\frac{1}{3} \cdot J + {\ell}^{2} \cdot \left(\frac{1}{2520} \cdot \left(J \cdot {\ell}^{2}\right) + \frac{1}{60} \cdot J\right)\right)\right)} + U \]

   11. Applied rewrites 61.7%

       \[\leadsto \left(-\ell\right) + U \]

   if 4.6e12 < l

   1. Initial program 100.0%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 74.2%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in J around 0

      \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

   8. Applied rewrites 54.5%

      \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]

   9. Taylor expanded in l around 0

      \[\leadsto \ell \cdot \color{blue}{\left(2 \cdot J + {\ell}^{2} \cdot \left(\frac{1}{60} \cdot \left(J \cdot {\ell}^{2}\right) + \frac{1}{3} \cdot J\right)\right)} + U \]

   11. Applied rewrites 54.5%

       \[\leadsto e^{\ell} + U \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 9: 56.5% accurate, 2.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\ell \leq -20000:\\ \;\;\;\;e^{-\ell}\\ \mathbf{elif}\;\ell \leq 4600000000000:\\ \;\;\;\;\left(-\ell\right) + U\\ \mathbf{else}:\\ \;\;\;\;e^{\ell}\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (if (<= l -20000.0)
   (exp (- l))
   (if (<= l 4600000000000.0) (+ (- l) U) (exp l))))

C

double code(double J, double l, double K, double U) {
	double tmp;
	if (l <= -20000.0) {
		tmp = exp(-l);
	} else if (l <= 4600000000000.0) {
		tmp = -l + U;
	} else {
		tmp = exp(l);
	}
	return tmp;
}

Fortran

real(8) function code(j, l, k, u)
    real(8), intent (in) :: j
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8), intent (in) :: u
    real(8) :: tmp
    if (l <= (-20000.0d0)) then
        tmp = exp(-l)
    else if (l <= 4600000000000.0d0) then
        tmp = -l + u
    else
        tmp = exp(l)
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double tmp;
	if (l <= -20000.0) {
		tmp = Math.exp(-l);
	} else if (l <= 4600000000000.0) {
		tmp = -l + U;
	} else {
		tmp = Math.exp(l);
	}
	return tmp;
}

Python

def code(J, l, K, U):
	tmp = 0
	if l <= -20000.0:
		tmp = math.exp(-l)
	elif l <= 4600000000000.0:
		tmp = -l + U
	else:
		tmp = math.exp(l)
	return tmp

Julia

function code(J, l, K, U)
	tmp = 0.0
	if (l <= -20000.0)
		tmp = exp(Float64(-l));
	elseif (l <= 4600000000000.0)
		tmp = Float64(Float64(-l) + U);
	else
		tmp = exp(l);
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	tmp = 0.0;
	if (l <= -20000.0)
		tmp = exp(-l);
	elseif (l <= 4600000000000.0)
		tmp = -l + U;
	else
		tmp = exp(l);
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := If[LessEqual[l, -20000.0], N[Exp[(-l)], $MachinePrecision], If[LessEqual[l, 4600000000000.0], N[((-l) + U), $MachinePrecision], N[Exp[l], $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if l < -2e4

   1. Initial program 100.0%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 78.6%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in J around 0

      \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

   8. Applied rewrites 55.4%

      \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]

   9. Taylor expanded in l around 0

      \[\leadsto \color{blue}{U + \ell \cdot \left(\frac{1}{3} \cdot \left(J \cdot \left({\ell}^{2} \cdot \cos \left(\frac{1}{2} \cdot K\right)\right)\right) + 2 \cdot \left(J \cdot \cos \left(\frac{1}{2} \cdot K\right)\right)\right)} \]

   11. Applied rewrites 44.6%

       \[\leadsto \color{blue}{e^{-\ell}} \]

   if -2e4 < l < 4.6e12

   1. Initial program 72.8%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around 0

      \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

   5. Applied rewrites 71.2%

      \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

   6. Taylor expanded in J around 0

      \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

   8. Applied rewrites 69.7%

      \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]

   9. Taylor expanded in l around 0

      \[\leadsto \ell \cdot \color{blue}{\left(2 \cdot J + {\ell}^{2} \cdot \left(\frac{1}{3} \cdot J + {\ell}^{2} \cdot \left(\frac{1}{2520} \cdot \left(J \cdot {\ell}^{2}\right) + \frac{1}{60} \cdot J\right)\right)\right)} + U \]

   11. Applied rewrites 61.7%

       \[\leadsto \left(-\ell\right) + U \]

   if 4.6e12 < l

   1. Initial program 100.0%

      \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
   2. Add Preprocessing

   3. Taylor expanded in J around -inf

      \[\leadsto \color{blue}{-1 \cdot \left(J \cdot \left(-1 \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right) + -1 \cdot \frac{U}{J}\right)\right)} \]

   5. Applied rewrites 54.5%

      \[\leadsto \color{blue}{e^{\ell}} \]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 10: 34.0% accurate, 55.0× speedup

Math

\[\begin{array}{l} \\ \left(-\ell\right) + U \end{array} \]

FPCore

(FPCore (J l K U) :precision binary64 (+ (- l) U))

C

double code(double J, double l, double K, double U) {
	return -l + U;
}

Fortran

real(8) function code(j, l, k, u)
    real(8), intent (in) :: j
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8), intent (in) :: u
    code = -l + u
end function

Java

public static double code(double J, double l, double K, double U) {
	return -l + U;
}

Python

def code(J, l, K, U):
	return -l + U

Julia

function code(J, l, K, U)
	return Float64(Float64(-l) + U)
end

MATLAB

function tmp = code(J, l, K, U)
	tmp = -l + U;
end

Wolfram

code[J_, l_, K_, U_] := N[((-l) + U), $MachinePrecision]

Derivation

1. Initial program 85.8%

   \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
2. Add Preprocessing

3. Taylor expanded in J around 0

   \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

5. Applied rewrites 73.6%

   \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

6. Taylor expanded in J around 0

   \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

8. Applied rewrites 62.7%

   \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]

9. Taylor expanded in l around 0

   \[\leadsto \ell \cdot \color{blue}{\left(2 \cdot J + {\ell}^{2} \cdot \left(\frac{1}{3} \cdot J + {\ell}^{2} \cdot \left(\frac{1}{2520} \cdot \left(J \cdot {\ell}^{2}\right) + \frac{1}{60} \cdot J\right)\right)\right)} + U \]

11. Applied rewrites 33.7%

    \[\leadsto \left(-\ell\right) + U \]
12. Add Preprocessing

Alternative 11: 3.1% accurate, 110.0× speedup

Math

\[\begin{array}{l} \\ -\ell \end{array} \]

FPCore

(FPCore (J l K U) :precision binary64 (- l))

C

double code(double J, double l, double K, double U) {
	return -l;
}

Fortran

real(8) function code(j, l, k, u)
    real(8), intent (in) :: j
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8), intent (in) :: u
    code = -l
end function

Java

public static double code(double J, double l, double K, double U) {
	return -l;
}

Python

def code(J, l, K, U):
	return -l

Julia

function code(J, l, K, U)
	return Float64(-l)
end

MATLAB

function tmp = code(J, l, K, U)
	tmp = -l;
end

Wolfram

code[J_, l_, K_, U_] := (-l)

Derivation

1. Initial program 85.8%

   \[\left(J \cdot \left(e^{\ell} - e^{-\ell}\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \]
2. Add Preprocessing

3. Taylor expanded in J around 0

   \[\leadsto \color{blue}{J \cdot \left(\cos \left(\frac{1}{2} \cdot K\right) \cdot \left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)\right)} + U \]

5. Applied rewrites 73.6%

   \[\leadsto \color{blue}{J \cdot \left(e^{\ell} - e^{-\ell}\right)} + U \]

6. Taylor expanded in J around 0

   \[\leadsto J \cdot \color{blue}{\left(e^{\ell} - e^{\mathsf{neg}\left(\ell\right)}\right)} + U \]

8. Applied rewrites 62.7%

   \[\leadsto \left(e^{\ell} - \color{blue}{e^{-\ell}}\right) + U \]

9. Taylor expanded in l around 0

   \[\leadsto \ell \cdot \color{blue}{\left(2 \cdot J + {\ell}^{2} \cdot \left(\frac{1}{60} \cdot \left(J \cdot {\ell}^{2}\right) + \frac{1}{3} \cdot J\right)\right)} + U \]

11. Applied rewrites 37.2%

    \[\leadsto e^{\ell} + U \]

12. Taylor expanded in l around 0

    \[\leadsto \color{blue}{U + \ell \cdot \left(\frac{1}{3} \cdot \left(J \cdot \left({\ell}^{2} \cdot \cos \left(\frac{1}{2} \cdot K\right)\right)\right) + 2 \cdot \left(J \cdot \cos \left(\frac{1}{2} \cdot K\right)\right)\right)} \]

14. Applied rewrites 3.0%

    \[\leadsto \color{blue}{-\ell} \]
15. Add Preprocessing

Reproduce

herbie shell --seed 2024321 
(FPCore (J l K U)
  :name "Maksimov and Kolovsky, Equation (4)"
  :precision binary64
  :pre (TRUE)
  (+ (* (* J (- (exp l) (exp (- l)))) (cos (/ K 2.0))) U))