Maksimov and Kolovsky, Equation (4)

Percentage Accurate: 86.4% → 99.9%

Time: 18.0s

Alternatives: 25

Speedup: 2.6×

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

Specification

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.4% 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: 99.9% accurate, 1.5× speedup

Math

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

FPCore

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

C

double code(double J, double l, double K, double U) {
	return (((2.0 * sinh(l)) * cos((K / 2.0))) * J) + 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 = (((2.0d0 * sinh(l)) * cos((k / 2.0d0))) * j) + u
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 87.0%

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

4. Applied egg-rr 0

   \[\leadsto expr\]
5. Add Preprocessing

Alternative 2: 96.3% accurate, 1.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \cos \left(0.5 \cdot K\right)\\ t_1 := 0.016666666666666666 + \ell \cdot \left(\ell \cdot 0.0003968253968253968\right)\\ t_2 := \left(\ell \cdot \ell\right) \cdot \left(0.3333333333333333 + \left(\ell \cdot \ell\right) \cdot t\_1\right)\\ \mathbf{if}\;\ell \leq -8.8 \cdot 10^{+51}:\\ \;\;\;\;\left(J \cdot \left(\left(\left(\ell \cdot \ell\right) \cdot \left(\ell \cdot \ell\right)\right) \cdot \left(0.016666666666666666 \cdot \ell\right)\right)\right) \cdot t\_0\\ \mathbf{elif}\;\ell \leq 1.65 \cdot 10^{+40}:\\ \;\;\;\;\frac{\left(\ell \cdot J\right) \cdot \left(4 - t\_2 \cdot t\_2\right)}{2 - t\_2} \cdot \cos \left(\frac{K}{2}\right) + U\\ \mathbf{else}:\\ \;\;\;\;J \cdot \left(t\_0 \cdot \left(\ell \cdot \left(2 + \ell \cdot \left(\ell \cdot \left(0.3333333333333333 + \ell \cdot \left(\ell \cdot t\_1\right)\right)\right)\right)\right)\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0 (cos (* 0.5 K)))
        (t_1 (+ 0.016666666666666666 (* l (* l 0.0003968253968253968))))
        (t_2 (* (* l l) (+ 0.3333333333333333 (* (* l l) t_1)))))
   (if (<= l -8.8e+51)
     (* (* J (* (* (* l l) (* l l)) (* 0.016666666666666666 l))) t_0)
     (if (<= l 1.65e+40)
       (+
        (* (/ (* (* l J) (- 4.0 (* t_2 t_2))) (- 2.0 t_2)) (cos (/ K 2.0)))
        U)
       (*
        J
        (*
         t_0
         (* l (+ 2.0 (* l (* l (+ 0.3333333333333333 (* l (* l t_1)))))))))))))

C

double code(double J, double l, double K, double U) {
	double t_0 = cos((0.5 * K));
	double t_1 = 0.016666666666666666 + (l * (l * 0.0003968253968253968));
	double t_2 = (l * l) * (0.3333333333333333 + ((l * l) * t_1));
	double tmp;
	if (l <= -8.8e+51) {
		tmp = (J * (((l * l) * (l * l)) * (0.016666666666666666 * l))) * t_0;
	} else if (l <= 1.65e+40) {
		tmp = ((((l * J) * (4.0 - (t_2 * t_2))) / (2.0 - t_2)) * cos((K / 2.0))) + U;
	} else {
		tmp = J * (t_0 * (l * (2.0 + (l * (l * (0.3333333333333333 + (l * (l * 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) :: t_2
    real(8) :: tmp
    t_0 = cos((0.5d0 * k))
    t_1 = 0.016666666666666666d0 + (l * (l * 0.0003968253968253968d0))
    t_2 = (l * l) * (0.3333333333333333d0 + ((l * l) * t_1))
    if (l <= (-8.8d+51)) then
        tmp = (j * (((l * l) * (l * l)) * (0.016666666666666666d0 * l))) * t_0
    else if (l <= 1.65d+40) then
        tmp = ((((l * j) * (4.0d0 - (t_2 * t_2))) / (2.0d0 - t_2)) * cos((k / 2.0d0))) + u
    else
        tmp = j * (t_0 * (l * (2.0d0 + (l * (l * (0.3333333333333333d0 + (l * (l * 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.cos((0.5 * K));
	double t_1 = 0.016666666666666666 + (l * (l * 0.0003968253968253968));
	double t_2 = (l * l) * (0.3333333333333333 + ((l * l) * t_1));
	double tmp;
	if (l <= -8.8e+51) {
		tmp = (J * (((l * l) * (l * l)) * (0.016666666666666666 * l))) * t_0;
	} else if (l <= 1.65e+40) {
		tmp = ((((l * J) * (4.0 - (t_2 * t_2))) / (2.0 - t_2)) * Math.cos((K / 2.0))) + U;
	} else {
		tmp = J * (t_0 * (l * (2.0 + (l * (l * (0.3333333333333333 + (l * (l * t_1))))))));
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = math.cos((0.5 * K))
	t_1 = 0.016666666666666666 + (l * (l * 0.0003968253968253968))
	t_2 = (l * l) * (0.3333333333333333 + ((l * l) * t_1))
	tmp = 0
	if l <= -8.8e+51:
		tmp = (J * (((l * l) * (l * l)) * (0.016666666666666666 * l))) * t_0
	elif l <= 1.65e+40:
		tmp = ((((l * J) * (4.0 - (t_2 * t_2))) / (2.0 - t_2)) * math.cos((K / 2.0))) + U
	else:
		tmp = J * (t_0 * (l * (2.0 + (l * (l * (0.3333333333333333 + (l * (l * t_1))))))))
	return tmp

Julia

function code(J, l, K, U)
	t_0 = cos(Float64(0.5 * K))
	t_1 = Float64(0.016666666666666666 + Float64(l * Float64(l * 0.0003968253968253968)))
	t_2 = Float64(Float64(l * l) * Float64(0.3333333333333333 + Float64(Float64(l * l) * t_1)))
	tmp = 0.0
	if (l <= -8.8e+51)
		tmp = Float64(Float64(J * Float64(Float64(Float64(l * l) * Float64(l * l)) * Float64(0.016666666666666666 * l))) * t_0);
	elseif (l <= 1.65e+40)
		tmp = Float64(Float64(Float64(Float64(Float64(l * J) * Float64(4.0 - Float64(t_2 * t_2))) / Float64(2.0 - t_2)) * cos(Float64(K / 2.0))) + U);
	else
		tmp = Float64(J * Float64(t_0 * Float64(l * Float64(2.0 + Float64(l * Float64(l * Float64(0.3333333333333333 + Float64(l * Float64(l * t_1)))))))));
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = cos((0.5 * K));
	t_1 = 0.016666666666666666 + (l * (l * 0.0003968253968253968));
	t_2 = (l * l) * (0.3333333333333333 + ((l * l) * t_1));
	tmp = 0.0;
	if (l <= -8.8e+51)
		tmp = (J * (((l * l) * (l * l)) * (0.016666666666666666 * l))) * t_0;
	elseif (l <= 1.65e+40)
		tmp = ((((l * J) * (4.0 - (t_2 * t_2))) / (2.0 - t_2)) * cos((K / 2.0))) + U;
	else
		tmp = J * (t_0 * (l * (2.0 + (l * (l * (0.3333333333333333 + (l * (l * t_1))))))));
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[Cos[N[(0.5 * K), $MachinePrecision]], $MachinePrecision]}, Block[{t$95$1 = N[(0.016666666666666666 + N[(l * N[(l * 0.0003968253968253968), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(l * l), $MachinePrecision] * N[(0.3333333333333333 + N[(N[(l * l), $MachinePrecision] * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, -8.8e+51], N[(N[(J * N[(N[(N[(l * l), $MachinePrecision] * N[(l * l), $MachinePrecision]), $MachinePrecision] * N[(0.016666666666666666 * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * t$95$0), $MachinePrecision], If[LessEqual[l, 1.65e+40], N[(N[(N[(N[(N[(l * J), $MachinePrecision] * N[(4.0 - N[(t$95$2 * t$95$2), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 - t$95$2), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(K / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision], N[(J * N[(t$95$0 * N[(l * N[(2.0 + N[(l * N[(l * N[(0.3333333333333333 + N[(l * N[(l * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]

Derivation

1. Split input into 3 regimes

2. if l < -8.79999999999999967e51

   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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in l around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in l around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -8.79999999999999967e51 < l < 1.6499999999999999e40

   1. Initial program 77.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   if 1.6499999999999999e40 < 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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in J around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 3: 89.3% accurate, 2.3× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(-0.125 \cdot \left(K \cdot K\right) + 1\right) \cdot \left(\left(J \cdot \left(\ell \cdot \left(\ell \cdot \ell\right)\right)\right) \cdot \left(0.3333333333333333 + \left(\ell \cdot \ell\right) \cdot \left(0.016666666666666666 + \left(\ell \cdot \ell\right) \cdot 0.0003968253968253968\right)\right) + 2 \cdot \left(J \cdot \ell\right)\right) + U\\ t_1 := \left(\cos \left(0.5 \cdot K\right) \cdot \left(J \cdot \left(\ell \cdot \ell\right)\right)\right) \cdot \left(\ell \cdot 0.3333333333333333\right)\\ \mathbf{if}\;\ell \leq -7.5 \cdot 10^{+157}:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;\ell \leq -170:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;\ell \leq 7.2 \cdot 10^{-7}:\\ \;\;\;\;\left(\left(2 \cdot \ell\right) \cdot \cos \left(\frac{K}{2}\right)\right) \cdot J + U\\ \mathbf{elif}\;\ell \leq 5.5 \cdot 10^{+150}:\\ \;\;\;\;t\_0\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0
         (+
          (*
           (+ (* -0.125 (* K K)) 1.0)
           (+
            (*
             (* J (* l (* l l)))
             (+
              0.3333333333333333
              (*
               (* l l)
               (+ 0.016666666666666666 (* (* l l) 0.0003968253968253968)))))
            (* 2.0 (* J l))))
          U))
        (t_1 (* (* (cos (* 0.5 K)) (* J (* l l))) (* l 0.3333333333333333))))
   (if (<= l -7.5e+157)
     t_1
     (if (<= l -170.0)
       t_0
       (if (<= l 7.2e-7)
         (+ (* (* (* 2.0 l) (cos (/ K 2.0))) J) U)
         (if (<= l 5.5e+150) t_0 t_1))))))

C

double code(double J, double l, double K, double U) {
	double t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U;
	double t_1 = (cos((0.5 * K)) * (J * (l * l))) * (l * 0.3333333333333333);
	double tmp;
	if (l <= -7.5e+157) {
		tmp = t_1;
	} else if (l <= -170.0) {
		tmp = t_0;
	} else if (l <= 7.2e-7) {
		tmp = (((2.0 * l) * cos((K / 2.0))) * J) + U;
	} else if (l <= 5.5e+150) {
		tmp = t_0;
	} 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 = ((((-0.125d0) * (k * k)) + 1.0d0) * (((j * (l * (l * l))) * (0.3333333333333333d0 + ((l * l) * (0.016666666666666666d0 + ((l * l) * 0.0003968253968253968d0))))) + (2.0d0 * (j * l)))) + u
    t_1 = (cos((0.5d0 * k)) * (j * (l * l))) * (l * 0.3333333333333333d0)
    if (l <= (-7.5d+157)) then
        tmp = t_1
    else if (l <= (-170.0d0)) then
        tmp = t_0
    else if (l <= 7.2d-7) then
        tmp = (((2.0d0 * l) * cos((k / 2.0d0))) * j) + u
    else if (l <= 5.5d+150) then
        tmp = t_0
    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 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U;
	double t_1 = (Math.cos((0.5 * K)) * (J * (l * l))) * (l * 0.3333333333333333);
	double tmp;
	if (l <= -7.5e+157) {
		tmp = t_1;
	} else if (l <= -170.0) {
		tmp = t_0;
	} else if (l <= 7.2e-7) {
		tmp = (((2.0 * l) * Math.cos((K / 2.0))) * J) + U;
	} else if (l <= 5.5e+150) {
		tmp = t_0;
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U
	t_1 = (math.cos((0.5 * K)) * (J * (l * l))) * (l * 0.3333333333333333)
	tmp = 0
	if l <= -7.5e+157:
		tmp = t_1
	elif l <= -170.0:
		tmp = t_0
	elif l <= 7.2e-7:
		tmp = (((2.0 * l) * math.cos((K / 2.0))) * J) + U
	elif l <= 5.5e+150:
		tmp = t_0
	else:
		tmp = t_1
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(Float64(Float64(Float64(-0.125 * Float64(K * K)) + 1.0) * Float64(Float64(Float64(J * Float64(l * Float64(l * l))) * Float64(0.3333333333333333 + Float64(Float64(l * l) * Float64(0.016666666666666666 + Float64(Float64(l * l) * 0.0003968253968253968))))) + Float64(2.0 * Float64(J * l)))) + U)
	t_1 = Float64(Float64(cos(Float64(0.5 * K)) * Float64(J * Float64(l * l))) * Float64(l * 0.3333333333333333))
	tmp = 0.0
	if (l <= -7.5e+157)
		tmp = t_1;
	elseif (l <= -170.0)
		tmp = t_0;
	elseif (l <= 7.2e-7)
		tmp = Float64(Float64(Float64(Float64(2.0 * l) * cos(Float64(K / 2.0))) * J) + U);
	elseif (l <= 5.5e+150)
		tmp = t_0;
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U;
	t_1 = (cos((0.5 * K)) * (J * (l * l))) * (l * 0.3333333333333333);
	tmp = 0.0;
	if (l <= -7.5e+157)
		tmp = t_1;
	elseif (l <= -170.0)
		tmp = t_0;
	elseif (l <= 7.2e-7)
		tmp = (((2.0 * l) * cos((K / 2.0))) * J) + U;
	elseif (l <= 5.5e+150)
		tmp = t_0;
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(N[(N[(N[(-0.125 * N[(K * K), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[(N[(J * N[(l * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.3333333333333333 + N[(N[(l * l), $MachinePrecision] * N[(0.016666666666666666 + N[(N[(l * l), $MachinePrecision] * 0.0003968253968253968), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(J * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]}, Block[{t$95$1 = N[(N[(N[Cos[N[(0.5 * K), $MachinePrecision]], $MachinePrecision] * N[(J * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(l * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, -7.5e+157], t$95$1, If[LessEqual[l, -170.0], t$95$0, If[LessEqual[l, 7.2e-7], N[(N[(N[(N[(2.0 * l), $MachinePrecision] * N[Cos[N[(K / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * J), $MachinePrecision] + U), $MachinePrecision], If[LessEqual[l, 5.5e+150], t$95$0, t$95$1]]]]]]

Derivation

1. Split input into 3 regimes

2. if l < -7.5e157 or 5.50000000000000017e150 < 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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in l around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if -7.5e157 < l < -170 or 7.19999999999999989e-7 < l < 5.50000000000000017e150

   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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -170 < l < 7.19999999999999989e-7

   1. Initial program 73.0%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in l around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 4: 92.3% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 2 + \ell \cdot \left(\ell \cdot 0.3333333333333333\right)\\ t_1 := \left(J \cdot \left(\left(\left(\ell \cdot \ell\right) \cdot \left(\ell \cdot \ell\right)\right) \cdot \left(0.016666666666666666 \cdot \ell\right)\right)\right) \cdot \cos \left(0.5 \cdot K\right)\\ \mathbf{if}\;\ell \leq -800:\\ \;\;\;\;t\_1\\ \mathbf{elif}\;\ell \leq 3.2 \cdot 10^{-8}:\\ \;\;\;\;\left(\left(2 \cdot \ell\right) \cdot \cos \left(\frac{K}{2}\right)\right) \cdot J + U\\ \mathbf{elif}\;\ell \leq 1.9 \cdot 10^{+40}:\\ \;\;\;\;\frac{\left(t\_0 \cdot t\_0\right) \cdot \left(\left(J \cdot \ell\right) \cdot \left(J \cdot \ell\right)\right) - U \cdot U}{J \cdot \left(t\_0 \cdot \ell\right) - U}\\ \mathbf{else}:\\ \;\;\;\;t\_1\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0 (+ 2.0 (* l (* l 0.3333333333333333))))
        (t_1
         (*
          (* J (* (* (* l l) (* l l)) (* 0.016666666666666666 l)))
          (cos (* 0.5 K)))))
   (if (<= l -800.0)
     t_1
     (if (<= l 3.2e-8)
       (+ (* (* (* 2.0 l) (cos (/ K 2.0))) J) U)
       (if (<= l 1.9e+40)
         (/
          (- (* (* t_0 t_0) (* (* J l) (* J l))) (* U U))
          (- (* J (* t_0 l)) U))
         t_1)))))

C

double code(double J, double l, double K, double U) {
	double t_0 = 2.0 + (l * (l * 0.3333333333333333));
	double t_1 = (J * (((l * l) * (l * l)) * (0.016666666666666666 * l))) * cos((0.5 * K));
	double tmp;
	if (l <= -800.0) {
		tmp = t_1;
	} else if (l <= 3.2e-8) {
		tmp = (((2.0 * l) * cos((K / 2.0))) * J) + U;
	} else if (l <= 1.9e+40) {
		tmp = (((t_0 * t_0) * ((J * l) * (J * l))) - (U * U)) / ((J * (t_0 * l)) - 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 = 2.0d0 + (l * (l * 0.3333333333333333d0))
    t_1 = (j * (((l * l) * (l * l)) * (0.016666666666666666d0 * l))) * cos((0.5d0 * k))
    if (l <= (-800.0d0)) then
        tmp = t_1
    else if (l <= 3.2d-8) then
        tmp = (((2.0d0 * l) * cos((k / 2.0d0))) * j) + u
    else if (l <= 1.9d+40) then
        tmp = (((t_0 * t_0) * ((j * l) * (j * l))) - (u * u)) / ((j * (t_0 * l)) - 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 = 2.0 + (l * (l * 0.3333333333333333));
	double t_1 = (J * (((l * l) * (l * l)) * (0.016666666666666666 * l))) * Math.cos((0.5 * K));
	double tmp;
	if (l <= -800.0) {
		tmp = t_1;
	} else if (l <= 3.2e-8) {
		tmp = (((2.0 * l) * Math.cos((K / 2.0))) * J) + U;
	} else if (l <= 1.9e+40) {
		tmp = (((t_0 * t_0) * ((J * l) * (J * l))) - (U * U)) / ((J * (t_0 * l)) - U);
	} else {
		tmp = t_1;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = 2.0 + (l * (l * 0.3333333333333333))
	t_1 = (J * (((l * l) * (l * l)) * (0.016666666666666666 * l))) * math.cos((0.5 * K))
	tmp = 0
	if l <= -800.0:
		tmp = t_1
	elif l <= 3.2e-8:
		tmp = (((2.0 * l) * math.cos((K / 2.0))) * J) + U
	elif l <= 1.9e+40:
		tmp = (((t_0 * t_0) * ((J * l) * (J * l))) - (U * U)) / ((J * (t_0 * l)) - U)
	else:
		tmp = t_1
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(2.0 + Float64(l * Float64(l * 0.3333333333333333)))
	t_1 = Float64(Float64(J * Float64(Float64(Float64(l * l) * Float64(l * l)) * Float64(0.016666666666666666 * l))) * cos(Float64(0.5 * K)))
	tmp = 0.0
	if (l <= -800.0)
		tmp = t_1;
	elseif (l <= 3.2e-8)
		tmp = Float64(Float64(Float64(Float64(2.0 * l) * cos(Float64(K / 2.0))) * J) + U);
	elseif (l <= 1.9e+40)
		tmp = Float64(Float64(Float64(Float64(t_0 * t_0) * Float64(Float64(J * l) * Float64(J * l))) - Float64(U * U)) / Float64(Float64(J * Float64(t_0 * l)) - U));
	else
		tmp = t_1;
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = 2.0 + (l * (l * 0.3333333333333333));
	t_1 = (J * (((l * l) * (l * l)) * (0.016666666666666666 * l))) * cos((0.5 * K));
	tmp = 0.0;
	if (l <= -800.0)
		tmp = t_1;
	elseif (l <= 3.2e-8)
		tmp = (((2.0 * l) * cos((K / 2.0))) * J) + U;
	elseif (l <= 1.9e+40)
		tmp = (((t_0 * t_0) * ((J * l) * (J * l))) - (U * U)) / ((J * (t_0 * l)) - U);
	else
		tmp = t_1;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(2.0 + N[(l * N[(l * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, Block[{t$95$1 = N[(N[(J * N[(N[(N[(l * l), $MachinePrecision] * N[(l * l), $MachinePrecision]), $MachinePrecision] * N[(0.016666666666666666 * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(0.5 * K), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, -800.0], t$95$1, If[LessEqual[l, 3.2e-8], N[(N[(N[(N[(2.0 * l), $MachinePrecision] * N[Cos[N[(K / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * J), $MachinePrecision] + U), $MachinePrecision], If[LessEqual[l, 1.9e+40], N[(N[(N[(N[(t$95$0 * t$95$0), $MachinePrecision] * N[(N[(J * l), $MachinePrecision] * N[(J * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(U * U), $MachinePrecision]), $MachinePrecision] / N[(N[(J * N[(t$95$0 * l), $MachinePrecision]), $MachinePrecision] - U), $MachinePrecision]), $MachinePrecision], t$95$1]]]]]

Derivation

1. Split input into 3 regimes

2. if l < -800 or 1.90000000000000002e40 < 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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in l around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in l around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -800 < l < 3.2000000000000002e-8

   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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in l around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]

   if 3.2000000000000002e-8 < l < 1.90000000000000002e40

   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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 5: 94.9% accurate, 2.4× speedup

Math

\[\begin{array}{l} \\ \left(J \cdot \left(\ell \cdot \left(2 + \left(\ell \cdot \ell\right) \cdot \left(0.3333333333333333 + \ell \cdot \left(\ell \cdot \left(0.016666666666666666 + \left(\ell \cdot \ell\right) \cdot 0.0003968253968253968\right)\right)\right)\right)\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (+
  (*
   (*
    J
    (*
     l
     (+
      2.0
      (*
       (* l l)
       (+
        0.3333333333333333
        (*
         l
         (* l (+ 0.016666666666666666 (* (* l l) 0.0003968253968253968)))))))))
   (cos (/ K 2.0)))
  U))

C

double code(double J, double l, double K, double U) {
	return ((J * (l * (2.0 + ((l * l) * (0.3333333333333333 + (l * (l * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))))))) * 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 * (l * (2.0d0 + ((l * l) * (0.3333333333333333d0 + (l * (l * (0.016666666666666666d0 + ((l * l) * 0.0003968253968253968d0))))))))) * cos((k / 2.0d0))) + u
end function

Java

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

Python

def code(J, l, K, U):
	return ((J * (l * (2.0 + ((l * l) * (0.3333333333333333 + (l * (l * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))))))) * math.cos((K / 2.0))) + U

Julia

function code(J, l, K, U)
	return Float64(Float64(Float64(J * Float64(l * Float64(2.0 + Float64(Float64(l * l) * Float64(0.3333333333333333 + Float64(l * Float64(l * Float64(0.016666666666666666 + Float64(Float64(l * l) * 0.0003968253968253968))))))))) * cos(Float64(K / 2.0))) + U)
end

MATLAB

function tmp = code(J, l, K, U)
	tmp = ((J * (l * (2.0 + ((l * l) * (0.3333333333333333 + (l * (l * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))))))) * cos((K / 2.0))) + U;
end

Wolfram

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

Derivation

1. Initial program 87.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 l around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]
6. Add Preprocessing

Alternative 6: 90.4% accurate, 2.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 2 + \ell \cdot \left(\ell \cdot 0.3333333333333333\right)\\ \mathbf{if}\;\ell \leq 1700000:\\ \;\;\;\;\left(J \cdot \left(\ell \cdot \left(2 + 0.3333333333333333 \cdot \left(\ell \cdot \ell\right)\right)\right)\right) \cdot \cos \left(\frac{K}{2}\right) + U\\ \mathbf{elif}\;\ell \leq 1.85 \cdot 10^{+40}:\\ \;\;\;\;\frac{\left(t\_0 \cdot t\_0\right) \cdot \left(\left(J \cdot \ell\right) \cdot \left(J \cdot \ell\right)\right) - U \cdot U}{J \cdot \left(t\_0 \cdot \ell\right) - U}\\ \mathbf{else}:\\ \;\;\;\;\left(J \cdot \left(\left(\left(\ell \cdot \ell\right) \cdot \left(\ell \cdot \ell\right)\right) \cdot \left(0.016666666666666666 \cdot \ell\right)\right)\right) \cdot \cos \left(0.5 \cdot K\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0 (+ 2.0 (* l (* l 0.3333333333333333)))))
   (if (<= l 1700000.0)
     (+
      (* (* J (* l (+ 2.0 (* 0.3333333333333333 (* l l))))) (cos (/ K 2.0)))
      U)
     (if (<= l 1.85e+40)
       (/
        (- (* (* t_0 t_0) (* (* J l) (* J l))) (* U U))
        (- (* J (* t_0 l)) U))
       (*
        (* J (* (* (* l l) (* l l)) (* 0.016666666666666666 l)))
        (cos (* 0.5 K)))))))

C

double code(double J, double l, double K, double U) {
	double t_0 = 2.0 + (l * (l * 0.3333333333333333));
	double tmp;
	if (l <= 1700000.0) {
		tmp = ((J * (l * (2.0 + (0.3333333333333333 * (l * l))))) * cos((K / 2.0))) + U;
	} else if (l <= 1.85e+40) {
		tmp = (((t_0 * t_0) * ((J * l) * (J * l))) - (U * U)) / ((J * (t_0 * l)) - U);
	} else {
		tmp = (J * (((l * l) * (l * l)) * (0.016666666666666666 * l))) * cos((0.5 * K));
	}
	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 = 2.0d0 + (l * (l * 0.3333333333333333d0))
    if (l <= 1700000.0d0) then
        tmp = ((j * (l * (2.0d0 + (0.3333333333333333d0 * (l * l))))) * cos((k / 2.0d0))) + u
    else if (l <= 1.85d+40) then
        tmp = (((t_0 * t_0) * ((j * l) * (j * l))) - (u * u)) / ((j * (t_0 * l)) - u)
    else
        tmp = (j * (((l * l) * (l * l)) * (0.016666666666666666d0 * l))) * cos((0.5d0 * k))
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = 2.0 + (l * (l * 0.3333333333333333));
	double tmp;
	if (l <= 1700000.0) {
		tmp = ((J * (l * (2.0 + (0.3333333333333333 * (l * l))))) * Math.cos((K / 2.0))) + U;
	} else if (l <= 1.85e+40) {
		tmp = (((t_0 * t_0) * ((J * l) * (J * l))) - (U * U)) / ((J * (t_0 * l)) - U);
	} else {
		tmp = (J * (((l * l) * (l * l)) * (0.016666666666666666 * l))) * Math.cos((0.5 * K));
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = 2.0 + (l * (l * 0.3333333333333333))
	tmp = 0
	if l <= 1700000.0:
		tmp = ((J * (l * (2.0 + (0.3333333333333333 * (l * l))))) * math.cos((K / 2.0))) + U
	elif l <= 1.85e+40:
		tmp = (((t_0 * t_0) * ((J * l) * (J * l))) - (U * U)) / ((J * (t_0 * l)) - U)
	else:
		tmp = (J * (((l * l) * (l * l)) * (0.016666666666666666 * l))) * math.cos((0.5 * K))
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(2.0 + Float64(l * Float64(l * 0.3333333333333333)))
	tmp = 0.0
	if (l <= 1700000.0)
		tmp = Float64(Float64(Float64(J * Float64(l * Float64(2.0 + Float64(0.3333333333333333 * Float64(l * l))))) * cos(Float64(K / 2.0))) + U);
	elseif (l <= 1.85e+40)
		tmp = Float64(Float64(Float64(Float64(t_0 * t_0) * Float64(Float64(J * l) * Float64(J * l))) - Float64(U * U)) / Float64(Float64(J * Float64(t_0 * l)) - U));
	else
		tmp = Float64(Float64(J * Float64(Float64(Float64(l * l) * Float64(l * l)) * Float64(0.016666666666666666 * l))) * cos(Float64(0.5 * K)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = 2.0 + (l * (l * 0.3333333333333333));
	tmp = 0.0;
	if (l <= 1700000.0)
		tmp = ((J * (l * (2.0 + (0.3333333333333333 * (l * l))))) * cos((K / 2.0))) + U;
	elseif (l <= 1.85e+40)
		tmp = (((t_0 * t_0) * ((J * l) * (J * l))) - (U * U)) / ((J * (t_0 * l)) - U);
	else
		tmp = (J * (((l * l) * (l * l)) * (0.016666666666666666 * l))) * cos((0.5 * K));
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(2.0 + N[(l * N[(l * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, 1700000.0], N[(N[(N[(J * N[(l * N[(2.0 + N[(0.3333333333333333 * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(K / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision], If[LessEqual[l, 1.85e+40], N[(N[(N[(N[(t$95$0 * t$95$0), $MachinePrecision] * N[(N[(J * l), $MachinePrecision] * N[(J * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] - N[(U * U), $MachinePrecision]), $MachinePrecision] / N[(N[(J * N[(t$95$0 * l), $MachinePrecision]), $MachinePrecision] - U), $MachinePrecision]), $MachinePrecision], N[(N[(J * N[(N[(N[(l * l), $MachinePrecision] * N[(l * l), $MachinePrecision]), $MachinePrecision] * N[(0.016666666666666666 * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Cos[N[(0.5 * K), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]]]]

Derivation

1. Split input into 3 regimes

2. if l < 1.7e6

   1. Initial program 83.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   if 1.7e6 < l < 1.85e40

   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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   if 1.85e40 < 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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in l around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in l around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 7: 92.8% accurate, 2.5× speedup

Math

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

FPCore

(FPCore (J l K U)
 :precision binary64
 (+
  (*
   (*
    J
    (*
     l
     (+
      2.0
      (* l (* l (+ 0.3333333333333333 (* (* l l) 0.016666666666666666)))))))
   (cos (/ K 2.0)))
  U))

C

double code(double J, double l, double K, double U) {
	return ((J * (l * (2.0 + (l * (l * (0.3333333333333333 + ((l * l) * 0.016666666666666666))))))) * 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 * (l * (2.0d0 + (l * (l * (0.3333333333333333d0 + ((l * l) * 0.016666666666666666d0))))))) * cos((k / 2.0d0))) + u
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 87.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 l around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]
6. Add Preprocessing

Alternative 8: 83.4% accurate, 2.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(-0.125 \cdot \left(K \cdot K\right) + 1\right) \cdot \left(\left(J \cdot \left(\ell \cdot \left(\ell \cdot \ell\right)\right)\right) \cdot \left(0.3333333333333333 + \left(\ell \cdot \ell\right) \cdot \left(0.016666666666666666 + \left(\ell \cdot \ell\right) \cdot 0.0003968253968253968\right)\right) + 2 \cdot \left(J \cdot \ell\right)\right) + U\\ \mathbf{if}\;\ell \leq -430:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;\ell \leq 7.2 \cdot 10^{-7}:\\ \;\;\;\;\left(\left(2 \cdot \ell\right) \cdot \cos \left(\frac{K}{2}\right)\right) \cdot J + U\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0
         (+
          (*
           (+ (* -0.125 (* K K)) 1.0)
           (+
            (*
             (* J (* l (* l l)))
             (+
              0.3333333333333333
              (*
               (* l l)
               (+ 0.016666666666666666 (* (* l l) 0.0003968253968253968)))))
            (* 2.0 (* J l))))
          U)))
   (if (<= l -430.0)
     t_0
     (if (<= l 7.2e-7) (+ (* (* (* 2.0 l) (cos (/ K 2.0))) J) U) t_0))))

C

double code(double J, double l, double K, double U) {
	double t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U;
	double tmp;
	if (l <= -430.0) {
		tmp = t_0;
	} else if (l <= 7.2e-7) {
		tmp = (((2.0 * l) * cos((K / 2.0))) * J) + U;
	} else {
		tmp = t_0;
	}
	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 = ((((-0.125d0) * (k * k)) + 1.0d0) * (((j * (l * (l * l))) * (0.3333333333333333d0 + ((l * l) * (0.016666666666666666d0 + ((l * l) * 0.0003968253968253968d0))))) + (2.0d0 * (j * l)))) + u
    if (l <= (-430.0d0)) then
        tmp = t_0
    else if (l <= 7.2d-7) then
        tmp = (((2.0d0 * l) * cos((k / 2.0d0))) * j) + u
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U;
	double tmp;
	if (l <= -430.0) {
		tmp = t_0;
	} else if (l <= 7.2e-7) {
		tmp = (((2.0 * l) * Math.cos((K / 2.0))) * J) + U;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U
	tmp = 0
	if l <= -430.0:
		tmp = t_0
	elif l <= 7.2e-7:
		tmp = (((2.0 * l) * math.cos((K / 2.0))) * J) + U
	else:
		tmp = t_0
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(Float64(Float64(Float64(-0.125 * Float64(K * K)) + 1.0) * Float64(Float64(Float64(J * Float64(l * Float64(l * l))) * Float64(0.3333333333333333 + Float64(Float64(l * l) * Float64(0.016666666666666666 + Float64(Float64(l * l) * 0.0003968253968253968))))) + Float64(2.0 * Float64(J * l)))) + U)
	tmp = 0.0
	if (l <= -430.0)
		tmp = t_0;
	elseif (l <= 7.2e-7)
		tmp = Float64(Float64(Float64(Float64(2.0 * l) * cos(Float64(K / 2.0))) * J) + U);
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U;
	tmp = 0.0;
	if (l <= -430.0)
		tmp = t_0;
	elseif (l <= 7.2e-7)
		tmp = (((2.0 * l) * cos((K / 2.0))) * J) + U;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(N[(N[(N[(-0.125 * N[(K * K), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[(N[(J * N[(l * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.3333333333333333 + N[(N[(l * l), $MachinePrecision] * N[(0.016666666666666666 + N[(N[(l * l), $MachinePrecision] * 0.0003968253968253968), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(J * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]}, If[LessEqual[l, -430.0], t$95$0, If[LessEqual[l, 7.2e-7], N[(N[(N[(N[(2.0 * l), $MachinePrecision] * N[Cos[N[(K / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] * J), $MachinePrecision] + U), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if l < -430 or 7.19999999999999989e-7 < 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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -430 < l < 7.19999999999999989e-7

   1. Initial program 73.0%

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

   4. Applied egg-rr 0

      \[\leadsto expr\]

   5. Taylor expanded in l around 0 0

      \[\leadsto expr\]

   7. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 9: 83.3% accurate, 2.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(-0.125 \cdot \left(K \cdot K\right) + 1\right) \cdot \left(\left(J \cdot \left(\ell \cdot \left(\ell \cdot \ell\right)\right)\right) \cdot \left(0.3333333333333333 + \left(\ell \cdot \ell\right) \cdot \left(0.016666666666666666 + \left(\ell \cdot \ell\right) \cdot 0.0003968253968253968\right)\right) + 2 \cdot \left(J \cdot \ell\right)\right) + U\\ \mathbf{if}\;\ell \leq -0.000118:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;\ell \leq 7.2 \cdot 10^{-7}:\\ \;\;\;\;\left(\left(2 \cdot \ell\right) \cdot J\right) \cdot \cos \left(\frac{K}{2}\right) + U\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0
         (+
          (*
           (+ (* -0.125 (* K K)) 1.0)
           (+
            (*
             (* J (* l (* l l)))
             (+
              0.3333333333333333
              (*
               (* l l)
               (+ 0.016666666666666666 (* (* l l) 0.0003968253968253968)))))
            (* 2.0 (* J l))))
          U)))
   (if (<= l -0.000118)
     t_0
     (if (<= l 7.2e-7) (+ (* (* (* 2.0 l) J) (cos (/ K 2.0))) U) t_0))))

C

double code(double J, double l, double K, double U) {
	double t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U;
	double tmp;
	if (l <= -0.000118) {
		tmp = t_0;
	} else if (l <= 7.2e-7) {
		tmp = (((2.0 * l) * J) * cos((K / 2.0))) + U;
	} else {
		tmp = t_0;
	}
	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 = ((((-0.125d0) * (k * k)) + 1.0d0) * (((j * (l * (l * l))) * (0.3333333333333333d0 + ((l * l) * (0.016666666666666666d0 + ((l * l) * 0.0003968253968253968d0))))) + (2.0d0 * (j * l)))) + u
    if (l <= (-0.000118d0)) then
        tmp = t_0
    else if (l <= 7.2d-7) then
        tmp = (((2.0d0 * l) * j) * cos((k / 2.0d0))) + u
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U;
	double tmp;
	if (l <= -0.000118) {
		tmp = t_0;
	} else if (l <= 7.2e-7) {
		tmp = (((2.0 * l) * J) * Math.cos((K / 2.0))) + U;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U
	tmp = 0
	if l <= -0.000118:
		tmp = t_0
	elif l <= 7.2e-7:
		tmp = (((2.0 * l) * J) * math.cos((K / 2.0))) + U
	else:
		tmp = t_0
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(Float64(Float64(Float64(-0.125 * Float64(K * K)) + 1.0) * Float64(Float64(Float64(J * Float64(l * Float64(l * l))) * Float64(0.3333333333333333 + Float64(Float64(l * l) * Float64(0.016666666666666666 + Float64(Float64(l * l) * 0.0003968253968253968))))) + Float64(2.0 * Float64(J * l)))) + U)
	tmp = 0.0
	if (l <= -0.000118)
		tmp = t_0;
	elseif (l <= 7.2e-7)
		tmp = Float64(Float64(Float64(Float64(2.0 * l) * J) * cos(Float64(K / 2.0))) + U);
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U;
	tmp = 0.0;
	if (l <= -0.000118)
		tmp = t_0;
	elseif (l <= 7.2e-7)
		tmp = (((2.0 * l) * J) * cos((K / 2.0))) + U;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(N[(N[(N[(-0.125 * N[(K * K), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[(N[(J * N[(l * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.3333333333333333 + N[(N[(l * l), $MachinePrecision] * N[(0.016666666666666666 + N[(N[(l * l), $MachinePrecision] * 0.0003968253968253968), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(J * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]}, If[LessEqual[l, -0.000118], t$95$0, If[LessEqual[l, 7.2e-7], N[(N[(N[(N[(2.0 * l), $MachinePrecision] * J), $MachinePrecision] * N[Cos[N[(K / 2.0), $MachinePrecision]], $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if l < -1.18e-4 or 7.19999999999999989e-7 < 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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -1.18e-4 < l < 7.19999999999999989e-7

   1. Initial program 73.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 10: 83.3% accurate, 2.6× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(-0.125 \cdot \left(K \cdot K\right) + 1\right) \cdot \left(\left(J \cdot \left(\ell \cdot \left(\ell \cdot \ell\right)\right)\right) \cdot \left(0.3333333333333333 + \left(\ell \cdot \ell\right) \cdot \left(0.016666666666666666 + \left(\ell \cdot \ell\right) \cdot 0.0003968253968253968\right)\right) + 2 \cdot \left(J \cdot \ell\right)\right) + U\\ \mathbf{if}\;\ell \leq -225:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;\ell \leq 7.2 \cdot 10^{-7}:\\ \;\;\;\;\ell \cdot \left(\cos \left(0.5 \cdot K\right) \cdot \left(2 \cdot J\right)\right) + U\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0
         (+
          (*
           (+ (* -0.125 (* K K)) 1.0)
           (+
            (*
             (* J (* l (* l l)))
             (+
              0.3333333333333333
              (*
               (* l l)
               (+ 0.016666666666666666 (* (* l l) 0.0003968253968253968)))))
            (* 2.0 (* J l))))
          U)))
   (if (<= l -225.0)
     t_0
     (if (<= l 7.2e-7) (+ (* l (* (cos (* 0.5 K)) (* 2.0 J))) U) t_0))))

C

double code(double J, double l, double K, double U) {
	double t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U;
	double tmp;
	if (l <= -225.0) {
		tmp = t_0;
	} else if (l <= 7.2e-7) {
		tmp = (l * (cos((0.5 * K)) * (2.0 * J))) + U;
	} else {
		tmp = t_0;
	}
	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 = ((((-0.125d0) * (k * k)) + 1.0d0) * (((j * (l * (l * l))) * (0.3333333333333333d0 + ((l * l) * (0.016666666666666666d0 + ((l * l) * 0.0003968253968253968d0))))) + (2.0d0 * (j * l)))) + u
    if (l <= (-225.0d0)) then
        tmp = t_0
    else if (l <= 7.2d-7) then
        tmp = (l * (cos((0.5d0 * k)) * (2.0d0 * j))) + u
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U;
	double tmp;
	if (l <= -225.0) {
		tmp = t_0;
	} else if (l <= 7.2e-7) {
		tmp = (l * (Math.cos((0.5 * K)) * (2.0 * J))) + U;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U
	tmp = 0
	if l <= -225.0:
		tmp = t_0
	elif l <= 7.2e-7:
		tmp = (l * (math.cos((0.5 * K)) * (2.0 * J))) + U
	else:
		tmp = t_0
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(Float64(Float64(Float64(-0.125 * Float64(K * K)) + 1.0) * Float64(Float64(Float64(J * Float64(l * Float64(l * l))) * Float64(0.3333333333333333 + Float64(Float64(l * l) * Float64(0.016666666666666666 + Float64(Float64(l * l) * 0.0003968253968253968))))) + Float64(2.0 * Float64(J * l)))) + U)
	tmp = 0.0
	if (l <= -225.0)
		tmp = t_0;
	elseif (l <= 7.2e-7)
		tmp = Float64(Float64(l * Float64(cos(Float64(0.5 * K)) * Float64(2.0 * J))) + U);
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = (((-0.125 * (K * K)) + 1.0) * (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l)))) + U;
	tmp = 0.0;
	if (l <= -225.0)
		tmp = t_0;
	elseif (l <= 7.2e-7)
		tmp = (l * (cos((0.5 * K)) * (2.0 * J))) + U;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(N[(N[(N[(-0.125 * N[(K * K), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] * N[(N[(N[(J * N[(l * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.3333333333333333 + N[(N[(l * l), $MachinePrecision] * N[(0.016666666666666666 + N[(N[(l * l), $MachinePrecision] * 0.0003968253968253968), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(J * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]}, If[LessEqual[l, -225.0], t$95$0, If[LessEqual[l, 7.2e-7], N[(N[(l * N[(N[Cos[N[(0.5 * K), $MachinePrecision]], $MachinePrecision] * N[(2.0 * J), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if l < -225 or 7.19999999999999989e-7 < 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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if -225 < l < 7.19999999999999989e-7

   1. Initial program 73.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in l around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 11: 92.6% accurate, 2.6× speedup

Math

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

FPCore

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

C

double code(double J, double l, double K, double U) {
	return ((J * (l * (2.0 + (l * (l * ((l * l) * 0.016666666666666666)))))) * 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 * (l * (2.0d0 + (l * (l * ((l * l) * 0.016666666666666666d0)))))) * cos((k / 2.0d0))) + u
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 87.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 l around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]

6. Taylor expanded in l around inf 0

   \[\leadsto expr\]

8. Simplified 0

   \[\leadsto expr\]
9. Add Preprocessing

Alternative 12: 70.4% accurate, 7.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(J \cdot \left(\ell \cdot \left(\ell \cdot \ell\right)\right)\right) \cdot \left(0.3333333333333333 + \left(\ell \cdot \ell\right) \cdot \left(0.016666666666666666 + \left(\ell \cdot \ell\right) \cdot 0.0003968253968253968\right)\right) + 2 \cdot \left(J \cdot \ell\right)\\ \mathbf{if}\;K \leq 2.5 \cdot 10^{+97}:\\ \;\;\;\;\left(-0.125 \cdot \left(K \cdot K\right) + 1\right) \cdot t\_0 + U\\ \mathbf{else}:\\ \;\;\;\;t\_0 + U\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0
         (+
          (*
           (* J (* l (* l l)))
           (+
            0.3333333333333333
            (*
             (* l l)
             (+ 0.016666666666666666 (* (* l l) 0.0003968253968253968)))))
          (* 2.0 (* J l)))))
   (if (<= K 2.5e+97) (+ (* (+ (* -0.125 (* K K)) 1.0) t_0) U) (+ t_0 U))))

C

double code(double J, double l, double K, double U) {
	double t_0 = ((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l));
	double tmp;
	if (K <= 2.5e+97) {
		tmp = (((-0.125 * (K * K)) + 1.0) * t_0) + U;
	} else {
		tmp = 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 = ((j * (l * (l * l))) * (0.3333333333333333d0 + ((l * l) * (0.016666666666666666d0 + ((l * l) * 0.0003968253968253968d0))))) + (2.0d0 * (j * l))
    if (k <= 2.5d+97) then
        tmp = ((((-0.125d0) * (k * k)) + 1.0d0) * t_0) + u
    else
        tmp = 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 = ((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l));
	double tmp;
	if (K <= 2.5e+97) {
		tmp = (((-0.125 * (K * K)) + 1.0) * t_0) + U;
	} else {
		tmp = t_0 + U;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = ((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l))
	tmp = 0
	if K <= 2.5e+97:
		tmp = (((-0.125 * (K * K)) + 1.0) * t_0) + U
	else:
		tmp = t_0 + U
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(Float64(Float64(J * Float64(l * Float64(l * l))) * Float64(0.3333333333333333 + Float64(Float64(l * l) * Float64(0.016666666666666666 + Float64(Float64(l * l) * 0.0003968253968253968))))) + Float64(2.0 * Float64(J * l)))
	tmp = 0.0
	if (K <= 2.5e+97)
		tmp = Float64(Float64(Float64(Float64(-0.125 * Float64(K * K)) + 1.0) * t_0) + U);
	else
		tmp = Float64(t_0 + U);
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = ((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l));
	tmp = 0.0;
	if (K <= 2.5e+97)
		tmp = (((-0.125 * (K * K)) + 1.0) * t_0) + U;
	else
		tmp = t_0 + U;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(N[(N[(J * N[(l * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.3333333333333333 + N[(N[(l * l), $MachinePrecision] * N[(0.016666666666666666 + N[(N[(l * l), $MachinePrecision] * 0.0003968253968253968), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(J * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[K, 2.5e+97], N[(N[(N[(N[(-0.125 * N[(K * K), $MachinePrecision]), $MachinePrecision] + 1.0), $MachinePrecision] * t$95$0), $MachinePrecision] + U), $MachinePrecision], N[(t$95$0 + U), $MachinePrecision]]]

Derivation

1. Split input into 2 regimes

2. if K < 2.49999999999999999e97

   1. Initial program 88.4%

      \[\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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 2.49999999999999999e97 < K

   1. Initial program 78.7%

      \[\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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 13: 75.4% accurate, 8.0× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(\left(J \cdot \left(\ell \cdot \left(\ell \cdot \ell\right)\right)\right) \cdot \left(0.3333333333333333 + \left(\ell \cdot \ell\right) \cdot \left(0.016666666666666666 + \left(\ell \cdot \ell\right) \cdot 0.0003968253968253968\right)\right) + 2 \cdot \left(J \cdot \ell\right)\right) + U\\ \mathbf{if}\;K \leq 3.1:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;K \leq 2.5 \cdot 10^{+97}:\\ \;\;\;\;\ell \cdot \left(\left(J \cdot \left(K \cdot K\right)\right) \cdot \left(\left(\ell \cdot \ell\right) \cdot -0.041666666666666664 + -0.25\right)\right) + U\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0
         (+
          (+
           (*
            (* J (* l (* l l)))
            (+
             0.3333333333333333
             (*
              (* l l)
              (+ 0.016666666666666666 (* (* l l) 0.0003968253968253968)))))
           (* 2.0 (* J l)))
          U)))
   (if (<= K 3.1)
     t_0
     (if (<= K 2.5e+97)
       (+
        (* l (* (* J (* K K)) (+ (* (* l l) -0.041666666666666664) -0.25)))
        U)
       t_0))))

C

double code(double J, double l, double K, double U) {
	double t_0 = (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l))) + U;
	double tmp;
	if (K <= 3.1) {
		tmp = t_0;
	} else if (K <= 2.5e+97) {
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U;
	} else {
		tmp = t_0;
	}
	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 = (((j * (l * (l * l))) * (0.3333333333333333d0 + ((l * l) * (0.016666666666666666d0 + ((l * l) * 0.0003968253968253968d0))))) + (2.0d0 * (j * l))) + u
    if (k <= 3.1d0) then
        tmp = t_0
    else if (k <= 2.5d+97) then
        tmp = (l * ((j * (k * k)) * (((l * l) * (-0.041666666666666664d0)) + (-0.25d0)))) + u
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l))) + U;
	double tmp;
	if (K <= 3.1) {
		tmp = t_0;
	} else if (K <= 2.5e+97) {
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l))) + U
	tmp = 0
	if K <= 3.1:
		tmp = t_0
	elif K <= 2.5e+97:
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U
	else:
		tmp = t_0
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(Float64(Float64(Float64(J * Float64(l * Float64(l * l))) * Float64(0.3333333333333333 + Float64(Float64(l * l) * Float64(0.016666666666666666 + Float64(Float64(l * l) * 0.0003968253968253968))))) + Float64(2.0 * Float64(J * l))) + U)
	tmp = 0.0
	if (K <= 3.1)
		tmp = t_0;
	elseif (K <= 2.5e+97)
		tmp = Float64(Float64(l * Float64(Float64(J * Float64(K * K)) * Float64(Float64(Float64(l * l) * -0.041666666666666664) + -0.25))) + U);
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = (((J * (l * (l * l))) * (0.3333333333333333 + ((l * l) * (0.016666666666666666 + ((l * l) * 0.0003968253968253968))))) + (2.0 * (J * l))) + U;
	tmp = 0.0;
	if (K <= 3.1)
		tmp = t_0;
	elseif (K <= 2.5e+97)
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(N[(N[(N[(J * N[(l * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(0.3333333333333333 + N[(N[(l * l), $MachinePrecision] * N[(0.016666666666666666 + N[(N[(l * l), $MachinePrecision] * 0.0003968253968253968), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(2.0 * N[(J * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]}, If[LessEqual[K, 3.1], t$95$0, If[LessEqual[K, 2.5e+97], N[(N[(l * N[(N[(J * N[(K * K), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(l * l), $MachinePrecision] * -0.041666666666666664), $MachinePrecision] + -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if K < 3.10000000000000009 or 2.49999999999999999e97 < K

   1. Initial program 87.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   7. Applied egg-rr 0

      \[\leadsto expr\]

   8. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   10. Simplified 0

       \[\leadsto expr\]

   if 3.10000000000000009 < K < 2.49999999999999999e97

   1. Initial program 87.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   12. Taylor expanded in K around inf 0

       \[\leadsto expr\]

   14. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 14: 76.4% accurate, 8.9× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \left(J \cdot \ell\right) \cdot \left(2 + \ell \cdot \left(\ell \cdot \left(0.3333333333333333 + \ell \cdot \left(\ell \cdot \left(0.016666666666666666 + \ell \cdot \left(\ell \cdot 0.0003968253968253968\right)\right)\right)\right)\right)\right) + U\\ \mathbf{if}\;K \leq 3.1:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;K \leq 2.5 \cdot 10^{+97}:\\ \;\;\;\;\ell \cdot \left(\left(J \cdot \left(K \cdot K\right)\right) \cdot \left(\left(\ell \cdot \ell\right) \cdot -0.041666666666666664 + -0.25\right)\right) + U\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0
         (+
          (*
           (* J l)
           (+
            2.0
            (*
             l
             (*
              l
              (+
               0.3333333333333333
               (*
                l
                (*
                 l
                 (+
                  0.016666666666666666
                  (* l (* l 0.0003968253968253968))))))))))
          U)))
   (if (<= K 3.1)
     t_0
     (if (<= K 2.5e+97)
       (+
        (* l (* (* J (* K K)) (+ (* (* l l) -0.041666666666666664) -0.25)))
        U)
       t_0))))

C

double code(double J, double l, double K, double U) {
	double t_0 = ((J * l) * (2.0 + (l * (l * (0.3333333333333333 + (l * (l * (0.016666666666666666 + (l * (l * 0.0003968253968253968)))))))))) + U;
	double tmp;
	if (K <= 3.1) {
		tmp = t_0;
	} else if (K <= 2.5e+97) {
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U;
	} else {
		tmp = t_0;
	}
	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 = ((j * l) * (2.0d0 + (l * (l * (0.3333333333333333d0 + (l * (l * (0.016666666666666666d0 + (l * (l * 0.0003968253968253968d0)))))))))) + u
    if (k <= 3.1d0) then
        tmp = t_0
    else if (k <= 2.5d+97) then
        tmp = (l * ((j * (k * k)) * (((l * l) * (-0.041666666666666664d0)) + (-0.25d0)))) + u
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = ((J * l) * (2.0 + (l * (l * (0.3333333333333333 + (l * (l * (0.016666666666666666 + (l * (l * 0.0003968253968253968)))))))))) + U;
	double tmp;
	if (K <= 3.1) {
		tmp = t_0;
	} else if (K <= 2.5e+97) {
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = ((J * l) * (2.0 + (l * (l * (0.3333333333333333 + (l * (l * (0.016666666666666666 + (l * (l * 0.0003968253968253968)))))))))) + U
	tmp = 0
	if K <= 3.1:
		tmp = t_0
	elif K <= 2.5e+97:
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U
	else:
		tmp = t_0
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(Float64(Float64(J * l) * Float64(2.0 + Float64(l * Float64(l * Float64(0.3333333333333333 + Float64(l * Float64(l * Float64(0.016666666666666666 + Float64(l * Float64(l * 0.0003968253968253968)))))))))) + U)
	tmp = 0.0
	if (K <= 3.1)
		tmp = t_0;
	elseif (K <= 2.5e+97)
		tmp = Float64(Float64(l * Float64(Float64(J * Float64(K * K)) * Float64(Float64(Float64(l * l) * -0.041666666666666664) + -0.25))) + U);
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = ((J * l) * (2.0 + (l * (l * (0.3333333333333333 + (l * (l * (0.016666666666666666 + (l * (l * 0.0003968253968253968)))))))))) + U;
	tmp = 0.0;
	if (K <= 3.1)
		tmp = t_0;
	elseif (K <= 2.5e+97)
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(N[(N[(J * l), $MachinePrecision] * N[(2.0 + N[(l * N[(l * N[(0.3333333333333333 + N[(l * N[(l * N[(0.016666666666666666 + N[(l * N[(l * 0.0003968253968253968), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]}, If[LessEqual[K, 3.1], t$95$0, If[LessEqual[K, 2.5e+97], N[(N[(l * N[(N[(J * N[(K * K), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(l * l), $MachinePrecision] * -0.041666666666666664), $MachinePrecision] + -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if K < 3.10000000000000009 or 2.49999999999999999e97 < K

   1. Initial program 87.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 3.10000000000000009 < K < 2.49999999999999999e97

   1. Initial program 87.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   12. Taylor expanded in K around inf 0

       \[\leadsto expr\]

   14. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 15: 75.0% accurate, 10.7× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;K \leq 3.1:\\ \;\;\;\;J \cdot \left(\ell \cdot \left(2 + 0.016666666666666666 \cdot \left(\left(\ell \cdot \ell\right) \cdot \left(\ell \cdot \ell\right)\right)\right)\right) + U\\ \mathbf{elif}\;K \leq 2.5 \cdot 10^{+97}:\\ \;\;\;\;\ell \cdot \left(\left(J \cdot \left(K \cdot K\right)\right) \cdot \left(\left(\ell \cdot \ell\right) \cdot -0.041666666666666664 + -0.25\right)\right) + U\\ \mathbf{else}:\\ \;\;\;\;\left(2 + \left(\ell \cdot \ell\right) \cdot \left(0.3333333333333333 + \left(\ell \cdot \ell\right) \cdot 0.016666666666666666\right)\right) \cdot \left(J \cdot \ell\right) + U\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (if (<= K 3.1)
   (+ (* J (* l (+ 2.0 (* 0.016666666666666666 (* (* l l) (* l l)))))) U)
   (if (<= K 2.5e+97)
     (+ (* l (* (* J (* K K)) (+ (* (* l l) -0.041666666666666664) -0.25))) U)
     (+
      (*
       (+
        2.0
        (* (* l l) (+ 0.3333333333333333 (* (* l l) 0.016666666666666666))))
       (* J l))
      U))))

C

double code(double J, double l, double K, double U) {
	double tmp;
	if (K <= 3.1) {
		tmp = (J * (l * (2.0 + (0.016666666666666666 * ((l * l) * (l * l)))))) + U;
	} else if (K <= 2.5e+97) {
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U;
	} else {
		tmp = ((2.0 + ((l * l) * (0.3333333333333333 + ((l * l) * 0.016666666666666666)))) * (J * 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 (k <= 3.1d0) then
        tmp = (j * (l * (2.0d0 + (0.016666666666666666d0 * ((l * l) * (l * l)))))) + u
    else if (k <= 2.5d+97) then
        tmp = (l * ((j * (k * k)) * (((l * l) * (-0.041666666666666664d0)) + (-0.25d0)))) + u
    else
        tmp = ((2.0d0 + ((l * l) * (0.3333333333333333d0 + ((l * l) * 0.016666666666666666d0)))) * (j * l)) + u
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double tmp;
	if (K <= 3.1) {
		tmp = (J * (l * (2.0 + (0.016666666666666666 * ((l * l) * (l * l)))))) + U;
	} else if (K <= 2.5e+97) {
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U;
	} else {
		tmp = ((2.0 + ((l * l) * (0.3333333333333333 + ((l * l) * 0.016666666666666666)))) * (J * l)) + U;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	tmp = 0
	if K <= 3.1:
		tmp = (J * (l * (2.0 + (0.016666666666666666 * ((l * l) * (l * l)))))) + U
	elif K <= 2.5e+97:
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U
	else:
		tmp = ((2.0 + ((l * l) * (0.3333333333333333 + ((l * l) * 0.016666666666666666)))) * (J * l)) + U
	return tmp

Julia

function code(J, l, K, U)
	tmp = 0.0
	if (K <= 3.1)
		tmp = Float64(Float64(J * Float64(l * Float64(2.0 + Float64(0.016666666666666666 * Float64(Float64(l * l) * Float64(l * l)))))) + U);
	elseif (K <= 2.5e+97)
		tmp = Float64(Float64(l * Float64(Float64(J * Float64(K * K)) * Float64(Float64(Float64(l * l) * -0.041666666666666664) + -0.25))) + U);
	else
		tmp = Float64(Float64(Float64(2.0 + Float64(Float64(l * l) * Float64(0.3333333333333333 + Float64(Float64(l * l) * 0.016666666666666666)))) * Float64(J * l)) + U);
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	tmp = 0.0;
	if (K <= 3.1)
		tmp = (J * (l * (2.0 + (0.016666666666666666 * ((l * l) * (l * l)))))) + U;
	elseif (K <= 2.5e+97)
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U;
	else
		tmp = ((2.0 + ((l * l) * (0.3333333333333333 + ((l * l) * 0.016666666666666666)))) * (J * l)) + U;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := If[LessEqual[K, 3.1], N[(N[(J * N[(l * N[(2.0 + N[(0.016666666666666666 * N[(N[(l * l), $MachinePrecision] * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision], If[LessEqual[K, 2.5e+97], N[(N[(l * N[(N[(J * N[(K * K), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(l * l), $MachinePrecision] * -0.041666666666666664), $MachinePrecision] + -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision], N[(N[(N[(2.0 + N[(N[(l * l), $MachinePrecision] * N[(0.3333333333333333 + N[(N[(l * l), $MachinePrecision] * 0.016666666666666666), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(J * l), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if K < 3.10000000000000009

   1. Initial program 88.5%

      \[\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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in l around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if 3.10000000000000009 < K < 2.49999999999999999e97

   1. Initial program 87.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   12. Taylor expanded in K around inf 0

       \[\leadsto expr\]

   14. Simplified 0

       \[\leadsto expr\]

   if 2.49999999999999999e97 < K

   1. Initial program 78.7%

      \[\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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 16: 75.1% accurate, 11.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := J \cdot \left(\ell \cdot \left(2 + 0.016666666666666666 \cdot \left(\left(\ell \cdot \ell\right) \cdot \left(\ell \cdot \ell\right)\right)\right)\right) + U\\ \mathbf{if}\;K \leq 3.1:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;K \leq 2.5 \cdot 10^{+97}:\\ \;\;\;\;\ell \cdot \left(\left(J \cdot \left(K \cdot K\right)\right) \cdot \left(\left(\ell \cdot \ell\right) \cdot -0.041666666666666664 + -0.25\right)\right) + U\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0
         (+
          (* J (* l (+ 2.0 (* 0.016666666666666666 (* (* l l) (* l l))))))
          U)))
   (if (<= K 3.1)
     t_0
     (if (<= K 2.5e+97)
       (+
        (* l (* (* J (* K K)) (+ (* (* l l) -0.041666666666666664) -0.25)))
        U)
       t_0))))

C

double code(double J, double l, double K, double U) {
	double t_0 = (J * (l * (2.0 + (0.016666666666666666 * ((l * l) * (l * l)))))) + U;
	double tmp;
	if (K <= 3.1) {
		tmp = t_0;
	} else if (K <= 2.5e+97) {
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U;
	} else {
		tmp = t_0;
	}
	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 = (j * (l * (2.0d0 + (0.016666666666666666d0 * ((l * l) * (l * l)))))) + u
    if (k <= 3.1d0) then
        tmp = t_0
    else if (k <= 2.5d+97) then
        tmp = (l * ((j * (k * k)) * (((l * l) * (-0.041666666666666664d0)) + (-0.25d0)))) + u
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = (J * (l * (2.0 + (0.016666666666666666 * ((l * l) * (l * l)))))) + U;
	double tmp;
	if (K <= 3.1) {
		tmp = t_0;
	} else if (K <= 2.5e+97) {
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = (J * (l * (2.0 + (0.016666666666666666 * ((l * l) * (l * l)))))) + U
	tmp = 0
	if K <= 3.1:
		tmp = t_0
	elif K <= 2.5e+97:
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U
	else:
		tmp = t_0
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(Float64(J * Float64(l * Float64(2.0 + Float64(0.016666666666666666 * Float64(Float64(l * l) * Float64(l * l)))))) + U)
	tmp = 0.0
	if (K <= 3.1)
		tmp = t_0;
	elseif (K <= 2.5e+97)
		tmp = Float64(Float64(l * Float64(Float64(J * Float64(K * K)) * Float64(Float64(Float64(l * l) * -0.041666666666666664) + -0.25))) + U);
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = (J * (l * (2.0 + (0.016666666666666666 * ((l * l) * (l * l)))))) + U;
	tmp = 0.0;
	if (K <= 3.1)
		tmp = t_0;
	elseif (K <= 2.5e+97)
		tmp = (l * ((J * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))) + U;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(N[(J * N[(l * N[(2.0 + N[(0.016666666666666666 * N[(N[(l * l), $MachinePrecision] * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]}, If[LessEqual[K, 3.1], t$95$0, If[LessEqual[K, 2.5e+97], N[(N[(l * N[(N[(J * N[(K * K), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(l * l), $MachinePrecision] * -0.041666666666666664), $MachinePrecision] + -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if K < 3.10000000000000009 or 2.49999999999999999e97 < K

   1. Initial program 87.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in l around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if 3.10000000000000009 < K < 2.49999999999999999e97

   1. Initial program 87.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   12. Taylor expanded in K around inf 0

       \[\leadsto expr\]

   14. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 17: 74.0% accurate, 11.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := J \cdot \left(\ell \cdot \left(2 + 0.016666666666666666 \cdot \left(\left(\ell \cdot \ell\right) \cdot \left(\ell \cdot \ell\right)\right)\right)\right) + U\\ \mathbf{if}\;K \leq 1.65 \cdot 10^{+31}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;K \leq 2.5 \cdot 10^{+97}:\\ \;\;\;\;J \cdot \left(\left(\ell \cdot \left(K \cdot K\right)\right) \cdot \left(\left(\ell \cdot \ell\right) \cdot -0.041666666666666664 + -0.25\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0
         (+
          (* J (* l (+ 2.0 (* 0.016666666666666666 (* (* l l) (* l l))))))
          U)))
   (if (<= K 1.65e+31)
     t_0
     (if (<= K 2.5e+97)
       (* J (* (* l (* K K)) (+ (* (* l l) -0.041666666666666664) -0.25)))
       t_0))))

C

double code(double J, double l, double K, double U) {
	double t_0 = (J * (l * (2.0 + (0.016666666666666666 * ((l * l) * (l * l)))))) + U;
	double tmp;
	if (K <= 1.65e+31) {
		tmp = t_0;
	} else if (K <= 2.5e+97) {
		tmp = J * ((l * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25));
	} else {
		tmp = t_0;
	}
	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 = (j * (l * (2.0d0 + (0.016666666666666666d0 * ((l * l) * (l * l)))))) + u
    if (k <= 1.65d+31) then
        tmp = t_0
    else if (k <= 2.5d+97) then
        tmp = j * ((l * (k * k)) * (((l * l) * (-0.041666666666666664d0)) + (-0.25d0)))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = (J * (l * (2.0 + (0.016666666666666666 * ((l * l) * (l * l)))))) + U;
	double tmp;
	if (K <= 1.65e+31) {
		tmp = t_0;
	} else if (K <= 2.5e+97) {
		tmp = J * ((l * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = (J * (l * (2.0 + (0.016666666666666666 * ((l * l) * (l * l)))))) + U
	tmp = 0
	if K <= 1.65e+31:
		tmp = t_0
	elif K <= 2.5e+97:
		tmp = J * ((l * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))
	else:
		tmp = t_0
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(Float64(J * Float64(l * Float64(2.0 + Float64(0.016666666666666666 * Float64(Float64(l * l) * Float64(l * l)))))) + U)
	tmp = 0.0
	if (K <= 1.65e+31)
		tmp = t_0;
	elseif (K <= 2.5e+97)
		tmp = Float64(J * Float64(Float64(l * Float64(K * K)) * Float64(Float64(Float64(l * l) * -0.041666666666666664) + -0.25)));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = (J * (l * (2.0 + (0.016666666666666666 * ((l * l) * (l * l)))))) + U;
	tmp = 0.0;
	if (K <= 1.65e+31)
		tmp = t_0;
	elseif (K <= 2.5e+97)
		tmp = J * ((l * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(N[(J * N[(l * N[(2.0 + N[(0.016666666666666666 * N[(N[(l * l), $MachinePrecision] * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]}, If[LessEqual[K, 1.65e+31], t$95$0, If[LessEqual[K, 2.5e+97], N[(J * N[(N[(l * N[(K * K), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(l * l), $MachinePrecision] * -0.041666666666666664), $MachinePrecision] + -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if K < 1.64999999999999996e31 or 2.49999999999999999e97 < K

   1. Initial program 86.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in l around inf 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if 1.64999999999999996e31 < K < 2.49999999999999999e97

   1. Initial program 89.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   12. Taylor expanded in K around inf 0

       \[\leadsto expr\]

   14. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 18: 71.3% accurate, 11.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\ell \leq -1.15 \cdot 10^{+103}:\\ \;\;\;\;0.3333333333333333 \cdot \left(J \cdot \left(\ell \cdot \left(\ell \cdot \ell\right)\right)\right)\\ \mathbf{elif}\;\ell \leq -1700:\\ \;\;\;\;\ell \cdot \left(J \cdot 2 + J \cdot \left(\left(K \cdot K\right) \cdot -0.25\right)\right) + U\\ \mathbf{else}:\\ \;\;\;\;U \cdot \left(1 + \frac{\left(J \cdot \ell\right) \cdot \left(2 + \ell \cdot \left(\ell \cdot 0.3333333333333333\right)\right)}{U}\right)\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (if (<= l -1.15e+103)
   (* 0.3333333333333333 (* J (* l (* l l))))
   (if (<= l -1700.0)
     (+ (* l (+ (* J 2.0) (* J (* (* K K) -0.25)))) U)
     (* U (+ 1.0 (/ (* (* J l) (+ 2.0 (* l (* l 0.3333333333333333)))) U))))))

C

double code(double J, double l, double K, double U) {
	double tmp;
	if (l <= -1.15e+103) {
		tmp = 0.3333333333333333 * (J * (l * (l * l)));
	} else if (l <= -1700.0) {
		tmp = (l * ((J * 2.0) + (J * ((K * K) * -0.25)))) + U;
	} else {
		tmp = U * (1.0 + (((J * l) * (2.0 + (l * (l * 0.3333333333333333)))) / 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 <= (-1.15d+103)) then
        tmp = 0.3333333333333333d0 * (j * (l * (l * l)))
    else if (l <= (-1700.0d0)) then
        tmp = (l * ((j * 2.0d0) + (j * ((k * k) * (-0.25d0))))) + u
    else
        tmp = u * (1.0d0 + (((j * l) * (2.0d0 + (l * (l * 0.3333333333333333d0)))) / u))
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double tmp;
	if (l <= -1.15e+103) {
		tmp = 0.3333333333333333 * (J * (l * (l * l)));
	} else if (l <= -1700.0) {
		tmp = (l * ((J * 2.0) + (J * ((K * K) * -0.25)))) + U;
	} else {
		tmp = U * (1.0 + (((J * l) * (2.0 + (l * (l * 0.3333333333333333)))) / U));
	}
	return tmp;
}

Python

def code(J, l, K, U):
	tmp = 0
	if l <= -1.15e+103:
		tmp = 0.3333333333333333 * (J * (l * (l * l)))
	elif l <= -1700.0:
		tmp = (l * ((J * 2.0) + (J * ((K * K) * -0.25)))) + U
	else:
		tmp = U * (1.0 + (((J * l) * (2.0 + (l * (l * 0.3333333333333333)))) / U))
	return tmp

Julia

function code(J, l, K, U)
	tmp = 0.0
	if (l <= -1.15e+103)
		tmp = Float64(0.3333333333333333 * Float64(J * Float64(l * Float64(l * l))));
	elseif (l <= -1700.0)
		tmp = Float64(Float64(l * Float64(Float64(J * 2.0) + Float64(J * Float64(Float64(K * K) * -0.25)))) + U);
	else
		tmp = Float64(U * Float64(1.0 + Float64(Float64(Float64(J * l) * Float64(2.0 + Float64(l * Float64(l * 0.3333333333333333)))) / U)));
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	tmp = 0.0;
	if (l <= -1.15e+103)
		tmp = 0.3333333333333333 * (J * (l * (l * l)));
	elseif (l <= -1700.0)
		tmp = (l * ((J * 2.0) + (J * ((K * K) * -0.25)))) + U;
	else
		tmp = U * (1.0 + (((J * l) * (2.0 + (l * (l * 0.3333333333333333)))) / U));
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := If[LessEqual[l, -1.15e+103], N[(0.3333333333333333 * N[(J * N[(l * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[l, -1700.0], N[(N[(l * N[(N[(J * 2.0), $MachinePrecision] + N[(J * N[(N[(K * K), $MachinePrecision] * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision], N[(U * N[(1.0 + N[(N[(N[(J * l), $MachinePrecision] * N[(2.0 + N[(l * N[(l * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / U), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if l < -1.15000000000000004e103

   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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   11. Taylor expanded in l around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -1.15000000000000004e103 < l < -1700

   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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in l around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -1700 < l

   1. Initial program 82.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in U around inf 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 19: 71.4% accurate, 12.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} \mathbf{if}\;\ell \leq -1.15 \cdot 10^{+103}:\\ \;\;\;\;0.3333333333333333 \cdot \left(J \cdot \left(\ell \cdot \left(\ell \cdot \ell\right)\right)\right)\\ \mathbf{elif}\;\ell \leq -900:\\ \;\;\;\;\ell \cdot \left(J \cdot 2 + J \cdot \left(\left(K \cdot K\right) \cdot -0.25\right)\right) + U\\ \mathbf{else}:\\ \;\;\;\;\ell \cdot \left(J \cdot \left(2 + \ell \cdot \left(\ell \cdot 0.3333333333333333\right)\right)\right) + U\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (if (<= l -1.15e+103)
   (* 0.3333333333333333 (* J (* l (* l l))))
   (if (<= l -900.0)
     (+ (* l (+ (* J 2.0) (* J (* (* K K) -0.25)))) U)
     (+ (* l (* J (+ 2.0 (* l (* l 0.3333333333333333))))) U))))

C

double code(double J, double l, double K, double U) {
	double tmp;
	if (l <= -1.15e+103) {
		tmp = 0.3333333333333333 * (J * (l * (l * l)));
	} else if (l <= -900.0) {
		tmp = (l * ((J * 2.0) + (J * ((K * K) * -0.25)))) + U;
	} else {
		tmp = (l * (J * (2.0 + (l * (l * 0.3333333333333333))))) + 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 <= (-1.15d+103)) then
        tmp = 0.3333333333333333d0 * (j * (l * (l * l)))
    else if (l <= (-900.0d0)) then
        tmp = (l * ((j * 2.0d0) + (j * ((k * k) * (-0.25d0))))) + u
    else
        tmp = (l * (j * (2.0d0 + (l * (l * 0.3333333333333333d0))))) + u
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double tmp;
	if (l <= -1.15e+103) {
		tmp = 0.3333333333333333 * (J * (l * (l * l)));
	} else if (l <= -900.0) {
		tmp = (l * ((J * 2.0) + (J * ((K * K) * -0.25)))) + U;
	} else {
		tmp = (l * (J * (2.0 + (l * (l * 0.3333333333333333))))) + U;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	tmp = 0
	if l <= -1.15e+103:
		tmp = 0.3333333333333333 * (J * (l * (l * l)))
	elif l <= -900.0:
		tmp = (l * ((J * 2.0) + (J * ((K * K) * -0.25)))) + U
	else:
		tmp = (l * (J * (2.0 + (l * (l * 0.3333333333333333))))) + U
	return tmp

Julia

function code(J, l, K, U)
	tmp = 0.0
	if (l <= -1.15e+103)
		tmp = Float64(0.3333333333333333 * Float64(J * Float64(l * Float64(l * l))));
	elseif (l <= -900.0)
		tmp = Float64(Float64(l * Float64(Float64(J * 2.0) + Float64(J * Float64(Float64(K * K) * -0.25)))) + U);
	else
		tmp = Float64(Float64(l * Float64(J * Float64(2.0 + Float64(l * Float64(l * 0.3333333333333333))))) + U);
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	tmp = 0.0;
	if (l <= -1.15e+103)
		tmp = 0.3333333333333333 * (J * (l * (l * l)));
	elseif (l <= -900.0)
		tmp = (l * ((J * 2.0) + (J * ((K * K) * -0.25)))) + U;
	else
		tmp = (l * (J * (2.0 + (l * (l * 0.3333333333333333))))) + U;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := If[LessEqual[l, -1.15e+103], N[(0.3333333333333333 * N[(J * N[(l * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[l, -900.0], N[(N[(l * N[(N[(J * 2.0), $MachinePrecision] + N[(J * N[(N[(K * K), $MachinePrecision] * -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision], N[(N[(l * N[(J * N[(2.0 + N[(l * N[(l * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]]]

Derivation

1. Split input into 3 regimes

2. if l < -1.15000000000000004e103

   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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   11. Taylor expanded in l around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -1.15000000000000004e103 < l < -900

   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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in l around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   if -900 < l

   1. Initial program 82.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]
3. Recombined 3 regimes into one program.
4. Add Preprocessing

Alternative 20: 68.8% accurate, 12.5× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := \ell \cdot \left(J \cdot \left(2 + \ell \cdot \left(\ell \cdot 0.3333333333333333\right)\right)\right) + U\\ \mathbf{if}\;K \leq 1.65 \cdot 10^{+31}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;K \leq 2.5 \cdot 10^{+97}:\\ \;\;\;\;J \cdot \left(\left(\ell \cdot \left(K \cdot K\right)\right) \cdot \left(\left(\ell \cdot \ell\right) \cdot -0.041666666666666664 + -0.25\right)\right)\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0 (+ (* l (* J (+ 2.0 (* l (* l 0.3333333333333333))))) U)))
   (if (<= K 1.65e+31)
     t_0
     (if (<= K 2.5e+97)
       (* J (* (* l (* K K)) (+ (* (* l l) -0.041666666666666664) -0.25)))
       t_0))))

C

double code(double J, double l, double K, double U) {
	double t_0 = (l * (J * (2.0 + (l * (l * 0.3333333333333333))))) + U;
	double tmp;
	if (K <= 1.65e+31) {
		tmp = t_0;
	} else if (K <= 2.5e+97) {
		tmp = J * ((l * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25));
	} else {
		tmp = t_0;
	}
	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 = (l * (j * (2.0d0 + (l * (l * 0.3333333333333333d0))))) + u
    if (k <= 1.65d+31) then
        tmp = t_0
    else if (k <= 2.5d+97) then
        tmp = j * ((l * (k * k)) * (((l * l) * (-0.041666666666666664d0)) + (-0.25d0)))
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = (l * (J * (2.0 + (l * (l * 0.3333333333333333))))) + U;
	double tmp;
	if (K <= 1.65e+31) {
		tmp = t_0;
	} else if (K <= 2.5e+97) {
		tmp = J * ((l * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25));
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = (l * (J * (2.0 + (l * (l * 0.3333333333333333))))) + U
	tmp = 0
	if K <= 1.65e+31:
		tmp = t_0
	elif K <= 2.5e+97:
		tmp = J * ((l * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25))
	else:
		tmp = t_0
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(Float64(l * Float64(J * Float64(2.0 + Float64(l * Float64(l * 0.3333333333333333))))) + U)
	tmp = 0.0
	if (K <= 1.65e+31)
		tmp = t_0;
	elseif (K <= 2.5e+97)
		tmp = Float64(J * Float64(Float64(l * Float64(K * K)) * Float64(Float64(Float64(l * l) * -0.041666666666666664) + -0.25)));
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = (l * (J * (2.0 + (l * (l * 0.3333333333333333))))) + U;
	tmp = 0.0;
	if (K <= 1.65e+31)
		tmp = t_0;
	elseif (K <= 2.5e+97)
		tmp = J * ((l * (K * K)) * (((l * l) * -0.041666666666666664) + -0.25));
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(N[(l * N[(J * N[(2.0 + N[(l * N[(l * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]}, If[LessEqual[K, 1.65e+31], t$95$0, If[LessEqual[K, 2.5e+97], N[(J * N[(N[(l * N[(K * K), $MachinePrecision]), $MachinePrecision] * N[(N[(N[(l * l), $MachinePrecision] * -0.041666666666666664), $MachinePrecision] + -0.25), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if K < 1.64999999999999996e31 or 2.49999999999999999e97 < K

   1. Initial program 86.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   if 1.64999999999999996e31 < K < 2.49999999999999999e97

   1. Initial program 89.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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   12. Taylor expanded in K around inf 0

       \[\leadsto expr\]

   14. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 21: 72.1% accurate, 16.4× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 0.3333333333333333 \cdot \left(J \cdot \left(\ell \cdot \left(\ell \cdot \ell\right)\right)\right)\\ \mathbf{if}\;\ell \leq -800:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;\ell \leq 8.5 \cdot 10^{+23}:\\ \;\;\;\;\ell \cdot \left(J \cdot 2\right) + U\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0 (* 0.3333333333333333 (* J (* l (* l l))))))
   (if (<= l -800.0) t_0 (if (<= l 8.5e+23) (+ (* l (* J 2.0)) U) t_0))))

C

double code(double J, double l, double K, double U) {
	double t_0 = 0.3333333333333333 * (J * (l * (l * l)));
	double tmp;
	if (l <= -800.0) {
		tmp = t_0;
	} else if (l <= 8.5e+23) {
		tmp = (l * (J * 2.0)) + U;
	} else {
		tmp = t_0;
	}
	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 = 0.3333333333333333d0 * (j * (l * (l * l)))
    if (l <= (-800.0d0)) then
        tmp = t_0
    else if (l <= 8.5d+23) then
        tmp = (l * (j * 2.0d0)) + u
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = 0.3333333333333333 * (J * (l * (l * l)));
	double tmp;
	if (l <= -800.0) {
		tmp = t_0;
	} else if (l <= 8.5e+23) {
		tmp = (l * (J * 2.0)) + U;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = 0.3333333333333333 * (J * (l * (l * l)))
	tmp = 0
	if l <= -800.0:
		tmp = t_0
	elif l <= 8.5e+23:
		tmp = (l * (J * 2.0)) + U
	else:
		tmp = t_0
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(0.3333333333333333 * Float64(J * Float64(l * Float64(l * l))))
	tmp = 0.0
	if (l <= -800.0)
		tmp = t_0;
	elseif (l <= 8.5e+23)
		tmp = Float64(Float64(l * Float64(J * 2.0)) + U);
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = 0.3333333333333333 * (J * (l * (l * l)));
	tmp = 0.0;
	if (l <= -800.0)
		tmp = t_0;
	elseif (l <= 8.5e+23)
		tmp = (l * (J * 2.0)) + U;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(0.3333333333333333 * N[(J * N[(l * N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, -800.0], t$95$0, If[LessEqual[l, 8.5e+23], N[(N[(l * N[(J * 2.0), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision], t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if l < -800 or 8.5000000000000001e23 < 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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   10. Applied egg-rr 0

       \[\leadsto expr\]

   11. Taylor expanded in l around inf 0

       \[\leadsto expr\]

   13. Simplified 0

       \[\leadsto expr\]

   if -800 < l < 8.5000000000000001e23

   1. Initial program 74.4%

      \[\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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in l around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 22: 46.2% accurate, 20.8× speedup

Math

\[\begin{array}{l} \\ \begin{array}{l} t_0 := 2 \cdot \left(J \cdot \ell\right)\\ \mathbf{if}\;\ell \leq -2.2 \cdot 10^{-25}:\\ \;\;\;\;t\_0\\ \mathbf{elif}\;\ell \leq 0.5:\\ \;\;\;\;U\\ \mathbf{else}:\\ \;\;\;\;t\_0\\ \end{array} \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (let* ((t_0 (* 2.0 (* J l)))) (if (<= l -2.2e-25) t_0 (if (<= l 0.5) U t_0))))

C

double code(double J, double l, double K, double U) {
	double t_0 = 2.0 * (J * l);
	double tmp;
	if (l <= -2.2e-25) {
		tmp = t_0;
	} else if (l <= 0.5) {
		tmp = U;
	} else {
		tmp = t_0;
	}
	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 = 2.0d0 * (j * l)
    if (l <= (-2.2d-25)) then
        tmp = t_0
    else if (l <= 0.5d0) then
        tmp = u
    else
        tmp = t_0
    end if
    code = tmp
end function

Java

public static double code(double J, double l, double K, double U) {
	double t_0 = 2.0 * (J * l);
	double tmp;
	if (l <= -2.2e-25) {
		tmp = t_0;
	} else if (l <= 0.5) {
		tmp = U;
	} else {
		tmp = t_0;
	}
	return tmp;
}

Python

def code(J, l, K, U):
	t_0 = 2.0 * (J * l)
	tmp = 0
	if l <= -2.2e-25:
		tmp = t_0
	elif l <= 0.5:
		tmp = U
	else:
		tmp = t_0
	return tmp

Julia

function code(J, l, K, U)
	t_0 = Float64(2.0 * Float64(J * l))
	tmp = 0.0
	if (l <= -2.2e-25)
		tmp = t_0;
	elseif (l <= 0.5)
		tmp = U;
	else
		tmp = t_0;
	end
	return tmp
end

MATLAB

function tmp_2 = code(J, l, K, U)
	t_0 = 2.0 * (J * l);
	tmp = 0.0;
	if (l <= -2.2e-25)
		tmp = t_0;
	elseif (l <= 0.5)
		tmp = U;
	else
		tmp = t_0;
	end
	tmp_2 = tmp;
end

Wolfram

code[J_, l_, K_, U_] := Block[{t$95$0 = N[(2.0 * N[(J * l), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[l, -2.2e-25], t$95$0, If[LessEqual[l, 0.5], U, t$95$0]]]

Derivation

1. Split input into 2 regimes

2. if l < -2.2000000000000002e-25 or 0.5 < l

   1. Initial program 97.7%

      \[\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 l around 0 0

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]

   6. Taylor expanded in K around 0 0

      \[\leadsto expr\]

   8. Simplified 0

      \[\leadsto expr\]

   9. Taylor expanded in l around 0 0

      \[\leadsto expr\]

   11. Simplified 0

       \[\leadsto expr\]

   12. Taylor expanded in l around inf 0

       \[\leadsto expr\]

   14. Simplified 0

       \[\leadsto expr\]

   if -2.2000000000000002e-25 < l < 0.5

   1. Initial program 74.7%

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

      \[\leadsto expr\]

   5. Simplified 0

      \[\leadsto expr\]
3. Recombined 2 regimes into one program.
4. Add Preprocessing

Alternative 23: 70.1% accurate, 24.0× speedup

Math

\[\begin{array}{l} \\ \ell \cdot \left(J \cdot \left(2 + \ell \cdot \left(\ell \cdot 0.3333333333333333\right)\right)\right) + U \end{array} \]

FPCore

(FPCore (J l K U)
 :precision binary64
 (+ (* l (* J (+ 2.0 (* l (* l 0.3333333333333333))))) U))

C

double code(double J, double l, double K, double U) {
	return (l * (J * (2.0 + (l * (l * 0.3333333333333333))))) + 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 * (j * (2.0d0 + (l * (l * 0.3333333333333333d0))))) + u
end function

Java

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

Python

def code(J, l, K, U):
	return (l * (J * (2.0 + (l * (l * 0.3333333333333333))))) + U

Julia

function code(J, l, K, U)
	return Float64(Float64(l * Float64(J * Float64(2.0 + Float64(l * Float64(l * 0.3333333333333333))))) + U)
end

MATLAB

function tmp = code(J, l, K, U)
	tmp = (l * (J * (2.0 + (l * (l * 0.3333333333333333))))) + U;
end

Wolfram

code[J_, l_, K_, U_] := N[(N[(l * N[(J * N[(2.0 + N[(l * N[(l * 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + U), $MachinePrecision]

Derivation

1. Initial program 87.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 l around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]

6. Taylor expanded in K around 0 0

   \[\leadsto expr\]

8. Simplified 0

   \[\leadsto expr\]
9. Add Preprocessing

Alternative 24: 54.5% accurate, 44.6× speedup

Math

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

FPCore

(FPCore (J l K U) :precision binary64 (+ (* l (* J 2.0)) U))

C

double code(double J, double l, double K, double U) {
	return (l * (J * 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 = (l * (j * 2.0d0)) + u
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

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

Derivation

1. Initial program 87.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 l around 0 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]

6. Taylor expanded in K around 0 0

   \[\leadsto expr\]

8. Simplified 0

   \[\leadsto expr\]

9. Taylor expanded in l around 0 0

   \[\leadsto expr\]

11. Simplified 0

    \[\leadsto expr\]
12. Add Preprocessing

Alternative 25: 37.0% accurate, 312.0× speedup

Math

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

FPCore

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

C

double code(double J, double l, double K, double U) {
	return 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 = u
end function

Java

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

Python

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

Julia

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

MATLAB

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

Wolfram

code[J_, l_, K_, U_] := U

Derivation

1. Initial program 87.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 0

   \[\leadsto expr\]

5. Simplified 0

   \[\leadsto expr\]
6. Add Preprocessing

Reproduce

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