Toniolo and Linder, Equation (10-)

Percentage Accurate: 34.2% → 92.9%

Time: 23.6s

Alternatives: 11

Speedup: 3.8×

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

• could not determine a ground truth

  1. t = 4.94066e-324
  2. l = -2
  3. k = 0.0

Specification

Math

\[\begin{array}{l} \\ \frac{2}{\left(\left(\frac{{t}^{3}}{\ell \cdot \ell} \cdot \sin k\right) \cdot \tan k\right) \cdot \left(\left(1 + {\left(\frac{k}{t}\right)}^{2}\right) - 1\right)} \end{array} \]

FPCore

(FPCore (t l k)
 :precision binary64
 (/
  2.0
  (*
   (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k))
   (- (+ 1.0 (pow (/ k t) 2.0)) 1.0))))

C

double code(double t, double l, double k) {
	return 2.0 / ((((pow(t, 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + pow((k / t), 2.0)) - 1.0));
}

Fortran

real(8) function code(t, l, k)
    real(8), intent (in) :: t
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    code = 2.0d0 / (((((t ** 3.0d0) / (l * l)) * sin(k)) * tan(k)) * ((1.0d0 + ((k / t) ** 2.0d0)) - 1.0d0))
end function

Java

public static double code(double t, double l, double k) {
	return 2.0 / ((((Math.pow(t, 3.0) / (l * l)) * Math.sin(k)) * Math.tan(k)) * ((1.0 + Math.pow((k / t), 2.0)) - 1.0));
}

Python

def code(t, l, k):
	return 2.0 / ((((math.pow(t, 3.0) / (l * l)) * math.sin(k)) * math.tan(k)) * ((1.0 + math.pow((k / t), 2.0)) - 1.0))

Julia

function code(t, l, k)
	return Float64(2.0 / Float64(Float64(Float64(Float64((t ^ 3.0) / Float64(l * l)) * sin(k)) * tan(k)) * Float64(Float64(1.0 + (Float64(k / t) ^ 2.0)) - 1.0)))
end

MATLAB

function tmp = code(t, l, k)
	tmp = 2.0 / (((((t ^ 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + ((k / t) ^ 2.0)) - 1.0));
end

Wolfram

code[t_, l_, k_] := N[(2.0 / N[(N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Initial Program: 34.2% accurate, 1.0× speedup

Math

\[\begin{array}{l} \\ \frac{2}{\left(\left(\frac{{t}^{3}}{\ell \cdot \ell} \cdot \sin k\right) \cdot \tan k\right) \cdot \left(\left(1 + {\left(\frac{k}{t}\right)}^{2}\right) - 1\right)} \end{array} \]

FPCore

(FPCore (t l k)
 :precision binary64
 (/
  2.0
  (*
   (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k))
   (- (+ 1.0 (pow (/ k t) 2.0)) 1.0))))

C

double code(double t, double l, double k) {
	return 2.0 / ((((pow(t, 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + pow((k / t), 2.0)) - 1.0));
}

Fortran

real(8) function code(t, l, k)
    real(8), intent (in) :: t
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    code = 2.0d0 / (((((t ** 3.0d0) / (l * l)) * sin(k)) * tan(k)) * ((1.0d0 + ((k / t) ** 2.0d0)) - 1.0d0))
end function

Java

public static double code(double t, double l, double k) {
	return 2.0 / ((((Math.pow(t, 3.0) / (l * l)) * Math.sin(k)) * Math.tan(k)) * ((1.0 + Math.pow((k / t), 2.0)) - 1.0));
}

Python

def code(t, l, k):
	return 2.0 / ((((math.pow(t, 3.0) / (l * l)) * math.sin(k)) * math.tan(k)) * ((1.0 + math.pow((k / t), 2.0)) - 1.0))

Julia

function code(t, l, k)
	return Float64(2.0 / Float64(Float64(Float64(Float64((t ^ 3.0) / Float64(l * l)) * sin(k)) * tan(k)) * Float64(Float64(1.0 + (Float64(k / t) ^ 2.0)) - 1.0)))
end

MATLAB

function tmp = code(t, l, k)
	tmp = 2.0 / (((((t ^ 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + ((k / t) ^ 2.0)) - 1.0));
end

Wolfram

code[t_, l_, k_] := N[(2.0 / N[(N[(N[(N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision] * N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] - 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Alternative 1: 92.9% accurate, 0.8× speedup

Math

\[\begin{array}{l} l_m = \left|\ell\right| \\ \begin{array}{l} \mathbf{if}\;l_m \leq 3.5 \cdot 10^{-175}:\\ \;\;\;\;2 \cdot {\left(\frac{{\left(\sqrt[3]{l_m}\right)}^{2}}{k \cdot \sqrt[3]{\sin k \cdot t}}\right)}^{3}\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \frac{{\left(l_m \cdot \left|\frac{1}{k}\right|\right)}^{2} \cdot \left(\cos k \cdot {\sin k}^{-2}\right)}{t}\\ \end{array} \end{array} \]

FPCore

l_m = (fabs.f64 l)
(FPCore (t l_m k)
 :precision binary64
 (if (<= l_m 3.5e-175)
   (* 2.0 (pow (/ (pow (cbrt l_m) 2.0) (* k (cbrt (* (sin k) t)))) 3.0))
   (*
    2.0
    (/
     (* (pow (* l_m (fabs (/ 1.0 k))) 2.0) (* (cos k) (pow (sin k) -2.0)))
     t))))

C

l_m = fabs(l);
double code(double t, double l_m, double k) {
	double tmp;
	if (l_m <= 3.5e-175) {
		tmp = 2.0 * pow((pow(cbrt(l_m), 2.0) / (k * cbrt((sin(k) * t)))), 3.0);
	} else {
		tmp = 2.0 * ((pow((l_m * fabs((1.0 / k))), 2.0) * (cos(k) * pow(sin(k), -2.0))) / t);
	}
	return tmp;
}

Java

l_m = Math.abs(l);
public static double code(double t, double l_m, double k) {
	double tmp;
	if (l_m <= 3.5e-175) {
		tmp = 2.0 * Math.pow((Math.pow(Math.cbrt(l_m), 2.0) / (k * Math.cbrt((Math.sin(k) * t)))), 3.0);
	} else {
		tmp = 2.0 * ((Math.pow((l_m * Math.abs((1.0 / k))), 2.0) * (Math.cos(k) * Math.pow(Math.sin(k), -2.0))) / t);
	}
	return tmp;
}

Julia

l_m = abs(l)
function code(t, l_m, k)
	tmp = 0.0
	if (l_m <= 3.5e-175)
		tmp = Float64(2.0 * (Float64((cbrt(l_m) ^ 2.0) / Float64(k * cbrt(Float64(sin(k) * t)))) ^ 3.0));
	else
		tmp = Float64(2.0 * Float64(Float64((Float64(l_m * abs(Float64(1.0 / k))) ^ 2.0) * Float64(cos(k) * (sin(k) ^ -2.0))) / t));
	end
	return tmp
end

Wolfram

l_m = N[Abs[l], $MachinePrecision]
code[t_, l$95$m_, k_] := If[LessEqual[l$95$m, 3.5e-175], N[(2.0 * N[Power[N[(N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / N[(k * N[Power[N[(N[Sin[k], $MachinePrecision] * t), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[Power[N[(l$95$m * N[Abs[N[(1.0 / k), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] * N[Power[N[Sin[k], $MachinePrecision], -2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 2: 78.0% accurate, 0.8× speedup

Math

\[\begin{array}{l} l_m = \left|\ell\right| \\ \begin{array}{l} \mathbf{if}\;l_m \leq 1.65 \cdot 10^{-160}:\\ \;\;\;\;2 \cdot {\left(\frac{{\left(\sqrt[3]{l_m}\right)}^{2}}{k \cdot \sqrt[3]{\sin k \cdot t}}\right)}^{3}\\ \mathbf{elif}\;l_m \leq 1.06 \cdot 10^{+148}:\\ \;\;\;\;2 \cdot \left(\left({l_m}^{2} \cdot {k}^{-2}\right) \cdot \frac{\cos k}{t \cdot {\sin k}^{2}}\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{2}{{\left(\frac{k \cdot \sin k}{l_m} \cdot \sqrt{\frac{t}{\cos k}}\right)}^{2}}\\ \end{array} \end{array} \]

FPCore

l_m = (fabs.f64 l)
(FPCore (t l_m k)
 :precision binary64
 (if (<= l_m 1.65e-160)
   (* 2.0 (pow (/ (pow (cbrt l_m) 2.0) (* k (cbrt (* (sin k) t)))) 3.0))
   (if (<= l_m 1.06e+148)
     (*
      2.0
      (* (* (pow l_m 2.0) (pow k -2.0)) (/ (cos k) (* t (pow (sin k) 2.0)))))
     (/ 2.0 (pow (* (/ (* k (sin k)) l_m) (sqrt (/ t (cos k)))) 2.0)))))

C

l_m = fabs(l);
double code(double t, double l_m, double k) {
	double tmp;
	if (l_m <= 1.65e-160) {
		tmp = 2.0 * pow((pow(cbrt(l_m), 2.0) / (k * cbrt((sin(k) * t)))), 3.0);
	} else if (l_m <= 1.06e+148) {
		tmp = 2.0 * ((pow(l_m, 2.0) * pow(k, -2.0)) * (cos(k) / (t * pow(sin(k), 2.0))));
	} else {
		tmp = 2.0 / pow((((k * sin(k)) / l_m) * sqrt((t / cos(k)))), 2.0);
	}
	return tmp;
}

Java

l_m = Math.abs(l);
public static double code(double t, double l_m, double k) {
	double tmp;
	if (l_m <= 1.65e-160) {
		tmp = 2.0 * Math.pow((Math.pow(Math.cbrt(l_m), 2.0) / (k * Math.cbrt((Math.sin(k) * t)))), 3.0);
	} else if (l_m <= 1.06e+148) {
		tmp = 2.0 * ((Math.pow(l_m, 2.0) * Math.pow(k, -2.0)) * (Math.cos(k) / (t * Math.pow(Math.sin(k), 2.0))));
	} else {
		tmp = 2.0 / Math.pow((((k * Math.sin(k)) / l_m) * Math.sqrt((t / Math.cos(k)))), 2.0);
	}
	return tmp;
}

Julia

l_m = abs(l)
function code(t, l_m, k)
	tmp = 0.0
	if (l_m <= 1.65e-160)
		tmp = Float64(2.0 * (Float64((cbrt(l_m) ^ 2.0) / Float64(k * cbrt(Float64(sin(k) * t)))) ^ 3.0));
	elseif (l_m <= 1.06e+148)
		tmp = Float64(2.0 * Float64(Float64((l_m ^ 2.0) * (k ^ -2.0)) * Float64(cos(k) / Float64(t * (sin(k) ^ 2.0)))));
	else
		tmp = Float64(2.0 / (Float64(Float64(Float64(k * sin(k)) / l_m) * sqrt(Float64(t / cos(k)))) ^ 2.0));
	end
	return tmp
end

Wolfram

l_m = N[Abs[l], $MachinePrecision]
code[t_, l$95$m_, k_] := If[LessEqual[l$95$m, 1.65e-160], N[(2.0 * N[Power[N[(N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / N[(k * N[Power[N[(N[Sin[k], $MachinePrecision] * t), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[l$95$m, 1.06e+148], N[(2.0 * N[(N[(N[Power[l$95$m, 2.0], $MachinePrecision] * N[Power[k, -2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / N[(t * N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[Power[N[(N[(N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision] / l$95$m), $MachinePrecision] * N[Sqrt[N[(t / N[Cos[k], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 3: 77.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} l_m = \left|\ell\right| \\ \begin{array}{l} \mathbf{if}\;l_m \cdot l_m \leq 5 \cdot 10^{-324}:\\ \;\;\;\;2 \cdot {\left(\frac{{\left(\sqrt[3]{l_m}\right)}^{2}}{k \cdot \sqrt[3]{\sin k \cdot t}}\right)}^{3}\\ \mathbf{elif}\;l_m \cdot l_m \leq 10^{+294}:\\ \;\;\;\;2 \cdot \left(\frac{\cos k}{t \cdot {\sin k}^{2}} \cdot \frac{l_m \cdot l_m}{{k}^{2}}\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{2}{{\left(\frac{k \cdot \sin k}{l_m} \cdot \sqrt{\frac{t}{\cos k}}\right)}^{2}}\\ \end{array} \end{array} \]

FPCore

l_m = (fabs.f64 l)
(FPCore (t l_m k)
 :precision binary64
 (if (<= (* l_m l_m) 5e-324)
   (* 2.0 (pow (/ (pow (cbrt l_m) 2.0) (* k (cbrt (* (sin k) t)))) 3.0))
   (if (<= (* l_m l_m) 1e+294)
     (*
      2.0
      (* (/ (cos k) (* t (pow (sin k) 2.0))) (/ (* l_m l_m) (pow k 2.0))))
     (/ 2.0 (pow (* (/ (* k (sin k)) l_m) (sqrt (/ t (cos k)))) 2.0)))))

C

l_m = fabs(l);
double code(double t, double l_m, double k) {
	double tmp;
	if ((l_m * l_m) <= 5e-324) {
		tmp = 2.0 * pow((pow(cbrt(l_m), 2.0) / (k * cbrt((sin(k) * t)))), 3.0);
	} else if ((l_m * l_m) <= 1e+294) {
		tmp = 2.0 * ((cos(k) / (t * pow(sin(k), 2.0))) * ((l_m * l_m) / pow(k, 2.0)));
	} else {
		tmp = 2.0 / pow((((k * sin(k)) / l_m) * sqrt((t / cos(k)))), 2.0);
	}
	return tmp;
}

Java

l_m = Math.abs(l);
public static double code(double t, double l_m, double k) {
	double tmp;
	if ((l_m * l_m) <= 5e-324) {
		tmp = 2.0 * Math.pow((Math.pow(Math.cbrt(l_m), 2.0) / (k * Math.cbrt((Math.sin(k) * t)))), 3.0);
	} else if ((l_m * l_m) <= 1e+294) {
		tmp = 2.0 * ((Math.cos(k) / (t * Math.pow(Math.sin(k), 2.0))) * ((l_m * l_m) / Math.pow(k, 2.0)));
	} else {
		tmp = 2.0 / Math.pow((((k * Math.sin(k)) / l_m) * Math.sqrt((t / Math.cos(k)))), 2.0);
	}
	return tmp;
}

Julia

l_m = abs(l)
function code(t, l_m, k)
	tmp = 0.0
	if (Float64(l_m * l_m) <= 5e-324)
		tmp = Float64(2.0 * (Float64((cbrt(l_m) ^ 2.0) / Float64(k * cbrt(Float64(sin(k) * t)))) ^ 3.0));
	elseif (Float64(l_m * l_m) <= 1e+294)
		tmp = Float64(2.0 * Float64(Float64(cos(k) / Float64(t * (sin(k) ^ 2.0))) * Float64(Float64(l_m * l_m) / (k ^ 2.0))));
	else
		tmp = Float64(2.0 / (Float64(Float64(Float64(k * sin(k)) / l_m) * sqrt(Float64(t / cos(k)))) ^ 2.0));
	end
	return tmp
end

Wolfram

l_m = N[Abs[l], $MachinePrecision]
code[t_, l$95$m_, k_] := If[LessEqual[N[(l$95$m * l$95$m), $MachinePrecision], 5e-324], N[(2.0 * N[Power[N[(N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / N[(k * N[Power[N[(N[Sin[k], $MachinePrecision] * t), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(l$95$m * l$95$m), $MachinePrecision], 1e+294], N[(2.0 * N[(N[(N[Cos[k], $MachinePrecision] / N[(t * N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(l$95$m * l$95$m), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[Power[N[(N[(N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision] / l$95$m), $MachinePrecision] * N[Sqrt[N[(t / N[Cos[k], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 4: 64.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} l_m = \left|\ell\right| \\ \begin{array}{l} \mathbf{if}\;l_m \cdot l_m \leq 5 \cdot 10^{-324}:\\ \;\;\;\;\frac{2}{{\left(\frac{{k}^{2} \cdot \sqrt{t}}{l_m}\right)}^{2}}\\ \mathbf{elif}\;l_m \cdot l_m \leq 10^{+294}:\\ \;\;\;\;2 \cdot \left(\frac{\cos k}{t \cdot {\sin k}^{2}} \cdot \frac{l_m \cdot l_m}{{k}^{2}}\right)\\ \mathbf{else}:\\ \;\;\;\;\frac{2}{{\left(\frac{k \cdot \sin k}{l_m} \cdot \sqrt{\frac{t}{\cos k}}\right)}^{2}}\\ \end{array} \end{array} \]

FPCore

l_m = (fabs.f64 l)
(FPCore (t l_m k)
 :precision binary64
 (if (<= (* l_m l_m) 5e-324)
   (/ 2.0 (pow (/ (* (pow k 2.0) (sqrt t)) l_m) 2.0))
   (if (<= (* l_m l_m) 1e+294)
     (*
      2.0
      (* (/ (cos k) (* t (pow (sin k) 2.0))) (/ (* l_m l_m) (pow k 2.0))))
     (/ 2.0 (pow (* (/ (* k (sin k)) l_m) (sqrt (/ t (cos k)))) 2.0)))))

C

l_m = fabs(l);
double code(double t, double l_m, double k) {
	double tmp;
	if ((l_m * l_m) <= 5e-324) {
		tmp = 2.0 / pow(((pow(k, 2.0) * sqrt(t)) / l_m), 2.0);
	} else if ((l_m * l_m) <= 1e+294) {
		tmp = 2.0 * ((cos(k) / (t * pow(sin(k), 2.0))) * ((l_m * l_m) / pow(k, 2.0)));
	} else {
		tmp = 2.0 / pow((((k * sin(k)) / l_m) * sqrt((t / cos(k)))), 2.0);
	}
	return tmp;
}

Fortran

l_m = abs(l)
real(8) function code(t, l_m, k)
    real(8), intent (in) :: t
    real(8), intent (in) :: l_m
    real(8), intent (in) :: k
    real(8) :: tmp
    if ((l_m * l_m) <= 5d-324) then
        tmp = 2.0d0 / ((((k ** 2.0d0) * sqrt(t)) / l_m) ** 2.0d0)
    else if ((l_m * l_m) <= 1d+294) then
        tmp = 2.0d0 * ((cos(k) / (t * (sin(k) ** 2.0d0))) * ((l_m * l_m) / (k ** 2.0d0)))
    else
        tmp = 2.0d0 / ((((k * sin(k)) / l_m) * sqrt((t / cos(k)))) ** 2.0d0)
    end if
    code = tmp
end function

Java

l_m = Math.abs(l);
public static double code(double t, double l_m, double k) {
	double tmp;
	if ((l_m * l_m) <= 5e-324) {
		tmp = 2.0 / Math.pow(((Math.pow(k, 2.0) * Math.sqrt(t)) / l_m), 2.0);
	} else if ((l_m * l_m) <= 1e+294) {
		tmp = 2.0 * ((Math.cos(k) / (t * Math.pow(Math.sin(k), 2.0))) * ((l_m * l_m) / Math.pow(k, 2.0)));
	} else {
		tmp = 2.0 / Math.pow((((k * Math.sin(k)) / l_m) * Math.sqrt((t / Math.cos(k)))), 2.0);
	}
	return tmp;
}

Python

l_m = math.fabs(l)
def code(t, l_m, k):
	tmp = 0
	if (l_m * l_m) <= 5e-324:
		tmp = 2.0 / math.pow(((math.pow(k, 2.0) * math.sqrt(t)) / l_m), 2.0)
	elif (l_m * l_m) <= 1e+294:
		tmp = 2.0 * ((math.cos(k) / (t * math.pow(math.sin(k), 2.0))) * ((l_m * l_m) / math.pow(k, 2.0)))
	else:
		tmp = 2.0 / math.pow((((k * math.sin(k)) / l_m) * math.sqrt((t / math.cos(k)))), 2.0)
	return tmp

Julia

l_m = abs(l)
function code(t, l_m, k)
	tmp = 0.0
	if (Float64(l_m * l_m) <= 5e-324)
		tmp = Float64(2.0 / (Float64(Float64((k ^ 2.0) * sqrt(t)) / l_m) ^ 2.0));
	elseif (Float64(l_m * l_m) <= 1e+294)
		tmp = Float64(2.0 * Float64(Float64(cos(k) / Float64(t * (sin(k) ^ 2.0))) * Float64(Float64(l_m * l_m) / (k ^ 2.0))));
	else
		tmp = Float64(2.0 / (Float64(Float64(Float64(k * sin(k)) / l_m) * sqrt(Float64(t / cos(k)))) ^ 2.0));
	end
	return tmp
end

MATLAB

l_m = abs(l);
function tmp_2 = code(t, l_m, k)
	tmp = 0.0;
	if ((l_m * l_m) <= 5e-324)
		tmp = 2.0 / ((((k ^ 2.0) * sqrt(t)) / l_m) ^ 2.0);
	elseif ((l_m * l_m) <= 1e+294)
		tmp = 2.0 * ((cos(k) / (t * (sin(k) ^ 2.0))) * ((l_m * l_m) / (k ^ 2.0)));
	else
		tmp = 2.0 / ((((k * sin(k)) / l_m) * sqrt((t / cos(k)))) ^ 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

l_m = N[Abs[l], $MachinePrecision]
code[t_, l$95$m_, k_] := If[LessEqual[N[(l$95$m * l$95$m), $MachinePrecision], 5e-324], N[(2.0 / N[Power[N[(N[(N[Power[k, 2.0], $MachinePrecision] * N[Sqrt[t], $MachinePrecision]), $MachinePrecision] / l$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[N[(l$95$m * l$95$m), $MachinePrecision], 1e+294], N[(2.0 * N[(N[(N[Cos[k], $MachinePrecision] / N[(t * N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(l$95$m * l$95$m), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[Power[N[(N[(N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision] / l$95$m), $MachinePrecision] * N[Sqrt[N[(t / N[Cos[k], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 5: 30.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} l_m = \left|\ell\right| \\ \begin{array}{l} \mathbf{if}\;t \leq 6 \cdot 10^{-105}:\\ \;\;\;\;\frac{2}{{\left(\sqrt{t} \cdot \frac{{k}^{2}}{l_m}\right)}^{2}}\\ \mathbf{elif}\;t \leq 1.9 \cdot 10^{+137}:\\ \;\;\;\;\frac{2}{\left(\left(\sin k \cdot \left(\frac{{t}^{2}}{l_m} \cdot \frac{t}{l_m}\right)\right) \cdot \tan k\right) \cdot \frac{\frac{k}{t}}{\frac{t}{k}}}\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \frac{{\left(\frac{{\left(\sqrt[3]{l_m}\right)}^{2}}{k}\right)}^{3}}{\sin k \cdot t}\\ \end{array} \end{array} \]

FPCore

l_m = (fabs.f64 l)
(FPCore (t l_m k)
 :precision binary64
 (if (<= t 6e-105)
   (/ 2.0 (pow (* (sqrt t) (/ (pow k 2.0) l_m)) 2.0))
   (if (<= t 1.9e+137)
     (/
      2.0
      (*
       (* (* (sin k) (* (/ (pow t 2.0) l_m) (/ t l_m))) (tan k))
       (/ (/ k t) (/ t k))))
     (* 2.0 (/ (pow (/ (pow (cbrt l_m) 2.0) k) 3.0) (* (sin k) t))))))

C

l_m = fabs(l);
double code(double t, double l_m, double k) {
	double tmp;
	if (t <= 6e-105) {
		tmp = 2.0 / pow((sqrt(t) * (pow(k, 2.0) / l_m)), 2.0);
	} else if (t <= 1.9e+137) {
		tmp = 2.0 / (((sin(k) * ((pow(t, 2.0) / l_m) * (t / l_m))) * tan(k)) * ((k / t) / (t / k)));
	} else {
		tmp = 2.0 * (pow((pow(cbrt(l_m), 2.0) / k), 3.0) / (sin(k) * t));
	}
	return tmp;
}

Java

l_m = Math.abs(l);
public static double code(double t, double l_m, double k) {
	double tmp;
	if (t <= 6e-105) {
		tmp = 2.0 / Math.pow((Math.sqrt(t) * (Math.pow(k, 2.0) / l_m)), 2.0);
	} else if (t <= 1.9e+137) {
		tmp = 2.0 / (((Math.sin(k) * ((Math.pow(t, 2.0) / l_m) * (t / l_m))) * Math.tan(k)) * ((k / t) / (t / k)));
	} else {
		tmp = 2.0 * (Math.pow((Math.pow(Math.cbrt(l_m), 2.0) / k), 3.0) / (Math.sin(k) * t));
	}
	return tmp;
}

Julia

l_m = abs(l)
function code(t, l_m, k)
	tmp = 0.0
	if (t <= 6e-105)
		tmp = Float64(2.0 / (Float64(sqrt(t) * Float64((k ^ 2.0) / l_m)) ^ 2.0));
	elseif (t <= 1.9e+137)
		tmp = Float64(2.0 / Float64(Float64(Float64(sin(k) * Float64(Float64((t ^ 2.0) / l_m) * Float64(t / l_m))) * tan(k)) * Float64(Float64(k / t) / Float64(t / k))));
	else
		tmp = Float64(2.0 * Float64((Float64((cbrt(l_m) ^ 2.0) / k) ^ 3.0) / Float64(sin(k) * t)));
	end
	return tmp
end

Wolfram

l_m = N[Abs[l], $MachinePrecision]
code[t_, l$95$m_, k_] := If[LessEqual[t, 6e-105], N[(2.0 / N[Power[N[(N[Sqrt[t], $MachinePrecision] * N[(N[Power[k, 2.0], $MachinePrecision] / l$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 1.9e+137], N[(2.0 / N[(N[(N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l$95$m), $MachinePrecision] * N[(t / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[Power[N[(N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / k), $MachinePrecision], 3.0], $MachinePrecision] / N[(N[Sin[k], $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 6: 45.3% accurate, 1.0× speedup

Math

\[\begin{array}{l} l_m = \left|\ell\right| \\ \begin{array}{l} \mathbf{if}\;t \leq 6.2 \cdot 10^{-6}:\\ \;\;\;\;\frac{2}{{\left(\frac{k \cdot \sin k}{l_m} \cdot \sqrt{\frac{t}{\cos k}}\right)}^{2}}\\ \mathbf{elif}\;t \leq 7.3 \cdot 10^{+140}:\\ \;\;\;\;\frac{2}{\left(\left(\sin k \cdot \left(\frac{{t}^{2}}{l_m} \cdot \frac{t}{l_m}\right)\right) \cdot \tan k\right) \cdot \frac{\frac{k}{t}}{\frac{t}{k}}}\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \frac{{\left(\frac{{\left(\sqrt[3]{l_m}\right)}^{2}}{k}\right)}^{3}}{\sin k \cdot t}\\ \end{array} \end{array} \]

FPCore

l_m = (fabs.f64 l)
(FPCore (t l_m k)
 :precision binary64
 (if (<= t 6.2e-6)
   (/ 2.0 (pow (* (/ (* k (sin k)) l_m) (sqrt (/ t (cos k)))) 2.0))
   (if (<= t 7.3e+140)
     (/
      2.0
      (*
       (* (* (sin k) (* (/ (pow t 2.0) l_m) (/ t l_m))) (tan k))
       (/ (/ k t) (/ t k))))
     (* 2.0 (/ (pow (/ (pow (cbrt l_m) 2.0) k) 3.0) (* (sin k) t))))))

C

l_m = fabs(l);
double code(double t, double l_m, double k) {
	double tmp;
	if (t <= 6.2e-6) {
		tmp = 2.0 / pow((((k * sin(k)) / l_m) * sqrt((t / cos(k)))), 2.0);
	} else if (t <= 7.3e+140) {
		tmp = 2.0 / (((sin(k) * ((pow(t, 2.0) / l_m) * (t / l_m))) * tan(k)) * ((k / t) / (t / k)));
	} else {
		tmp = 2.0 * (pow((pow(cbrt(l_m), 2.0) / k), 3.0) / (sin(k) * t));
	}
	return tmp;
}

Java

l_m = Math.abs(l);
public static double code(double t, double l_m, double k) {
	double tmp;
	if (t <= 6.2e-6) {
		tmp = 2.0 / Math.pow((((k * Math.sin(k)) / l_m) * Math.sqrt((t / Math.cos(k)))), 2.0);
	} else if (t <= 7.3e+140) {
		tmp = 2.0 / (((Math.sin(k) * ((Math.pow(t, 2.0) / l_m) * (t / l_m))) * Math.tan(k)) * ((k / t) / (t / k)));
	} else {
		tmp = 2.0 * (Math.pow((Math.pow(Math.cbrt(l_m), 2.0) / k), 3.0) / (Math.sin(k) * t));
	}
	return tmp;
}

Julia

l_m = abs(l)
function code(t, l_m, k)
	tmp = 0.0
	if (t <= 6.2e-6)
		tmp = Float64(2.0 / (Float64(Float64(Float64(k * sin(k)) / l_m) * sqrt(Float64(t / cos(k)))) ^ 2.0));
	elseif (t <= 7.3e+140)
		tmp = Float64(2.0 / Float64(Float64(Float64(sin(k) * Float64(Float64((t ^ 2.0) / l_m) * Float64(t / l_m))) * tan(k)) * Float64(Float64(k / t) / Float64(t / k))));
	else
		tmp = Float64(2.0 * Float64((Float64((cbrt(l_m) ^ 2.0) / k) ^ 3.0) / Float64(sin(k) * t)));
	end
	return tmp
end

Wolfram

l_m = N[Abs[l], $MachinePrecision]
code[t_, l$95$m_, k_] := If[LessEqual[t, 6.2e-6], N[(2.0 / N[Power[N[(N[(N[(k * N[Sin[k], $MachinePrecision]), $MachinePrecision] / l$95$m), $MachinePrecision] * N[Sqrt[N[(t / N[Cos[k], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 7.3e+140], N[(2.0 / N[(N[(N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l$95$m), $MachinePrecision] * N[(t / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[Power[N[(N[Power[N[Power[l$95$m, 1/3], $MachinePrecision], 2.0], $MachinePrecision] / k), $MachinePrecision], 3.0], $MachinePrecision] / N[(N[Sin[k], $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 7: 30.7% accurate, 1.3× speedup

Math

\[\begin{array}{l} l_m = \left|\ell\right| \\ \begin{array}{l} \mathbf{if}\;t \leq 1.65 \cdot 10^{-104} \lor \neg \left(t \leq 1.95 \cdot 10^{+133}\right):\\ \;\;\;\;\frac{2}{{\left(\sqrt{t} \cdot \frac{{k}^{2}}{l_m}\right)}^{2}}\\ \mathbf{else}:\\ \;\;\;\;\frac{2}{\left(\left(\sin k \cdot \left(\frac{{t}^{2}}{l_m} \cdot \frac{t}{l_m}\right)\right) \cdot \tan k\right) \cdot \frac{\frac{k}{t}}{\frac{t}{k}}}\\ \end{array} \end{array} \]

FPCore

l_m = (fabs.f64 l)
(FPCore (t l_m k)
 :precision binary64
 (if (or (<= t 1.65e-104) (not (<= t 1.95e+133)))
   (/ 2.0 (pow (* (sqrt t) (/ (pow k 2.0) l_m)) 2.0))
   (/
    2.0
    (*
     (* (* (sin k) (* (/ (pow t 2.0) l_m) (/ t l_m))) (tan k))
     (/ (/ k t) (/ t k))))))

C

l_m = fabs(l);
double code(double t, double l_m, double k) {
	double tmp;
	if ((t <= 1.65e-104) || !(t <= 1.95e+133)) {
		tmp = 2.0 / pow((sqrt(t) * (pow(k, 2.0) / l_m)), 2.0);
	} else {
		tmp = 2.0 / (((sin(k) * ((pow(t, 2.0) / l_m) * (t / l_m))) * tan(k)) * ((k / t) / (t / k)));
	}
	return tmp;
}

Fortran

l_m = abs(l)
real(8) function code(t, l_m, k)
    real(8), intent (in) :: t
    real(8), intent (in) :: l_m
    real(8), intent (in) :: k
    real(8) :: tmp
    if ((t <= 1.65d-104) .or. (.not. (t <= 1.95d+133))) then
        tmp = 2.0d0 / ((sqrt(t) * ((k ** 2.0d0) / l_m)) ** 2.0d0)
    else
        tmp = 2.0d0 / (((sin(k) * (((t ** 2.0d0) / l_m) * (t / l_m))) * tan(k)) * ((k / t) / (t / k)))
    end if
    code = tmp
end function

Java

l_m = Math.abs(l);
public static double code(double t, double l_m, double k) {
	double tmp;
	if ((t <= 1.65e-104) || !(t <= 1.95e+133)) {
		tmp = 2.0 / Math.pow((Math.sqrt(t) * (Math.pow(k, 2.0) / l_m)), 2.0);
	} else {
		tmp = 2.0 / (((Math.sin(k) * ((Math.pow(t, 2.0) / l_m) * (t / l_m))) * Math.tan(k)) * ((k / t) / (t / k)));
	}
	return tmp;
}

Python

l_m = math.fabs(l)
def code(t, l_m, k):
	tmp = 0
	if (t <= 1.65e-104) or not (t <= 1.95e+133):
		tmp = 2.0 / math.pow((math.sqrt(t) * (math.pow(k, 2.0) / l_m)), 2.0)
	else:
		tmp = 2.0 / (((math.sin(k) * ((math.pow(t, 2.0) / l_m) * (t / l_m))) * math.tan(k)) * ((k / t) / (t / k)))
	return tmp

Julia

l_m = abs(l)
function code(t, l_m, k)
	tmp = 0.0
	if ((t <= 1.65e-104) || !(t <= 1.95e+133))
		tmp = Float64(2.0 / (Float64(sqrt(t) * Float64((k ^ 2.0) / l_m)) ^ 2.0));
	else
		tmp = Float64(2.0 / Float64(Float64(Float64(sin(k) * Float64(Float64((t ^ 2.0) / l_m) * Float64(t / l_m))) * tan(k)) * Float64(Float64(k / t) / Float64(t / k))));
	end
	return tmp
end

MATLAB

l_m = abs(l);
function tmp_2 = code(t, l_m, k)
	tmp = 0.0;
	if ((t <= 1.65e-104) || ~((t <= 1.95e+133)))
		tmp = 2.0 / ((sqrt(t) * ((k ^ 2.0) / l_m)) ^ 2.0);
	else
		tmp = 2.0 / (((sin(k) * (((t ^ 2.0) / l_m) * (t / l_m))) * tan(k)) * ((k / t) / (t / k)));
	end
	tmp_2 = tmp;
end

Wolfram

l_m = N[Abs[l], $MachinePrecision]
code[t_, l$95$m_, k_] := If[Or[LessEqual[t, 1.65e-104], N[Not[LessEqual[t, 1.95e+133]], $MachinePrecision]], N[(2.0 / N[Power[N[(N[Sqrt[t], $MachinePrecision] * N[(N[Power[k, 2.0], $MachinePrecision] / l$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l$95$m), $MachinePrecision] * N[(t / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(k / t), $MachinePrecision] / N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 8: 68.5% accurate, 1.3× speedup

Math

\[\begin{array}{l} l_m = \left|\ell\right| \\ \begin{array}{l} \mathbf{if}\;t \leq 7.4 \cdot 10^{-141}:\\ \;\;\;\;2 \cdot \left(\frac{l_m}{{k}^{4}} \cdot \frac{l_m}{t}\right)\\ \mathbf{elif}\;t \leq 5.1 \cdot 10^{+131}:\\ \;\;\;\;\frac{2}{\left(\left(\sin k \cdot \left(\frac{{t}^{2}}{l_m} \cdot \frac{t}{l_m}\right)\right) \cdot \tan k\right) \cdot \frac{k}{t \cdot \frac{t}{k}}}\\ \mathbf{else}:\\ \;\;\;\;\frac{2}{{\left(\sqrt{t} \cdot \frac{{k}^{2}}{l_m}\right)}^{2}}\\ \end{array} \end{array} \]

FPCore

l_m = (fabs.f64 l)
(FPCore (t l_m k)
 :precision binary64
 (if (<= t 7.4e-141)
   (* 2.0 (* (/ l_m (pow k 4.0)) (/ l_m t)))
   (if (<= t 5.1e+131)
     (/
      2.0
      (*
       (* (* (sin k) (* (/ (pow t 2.0) l_m) (/ t l_m))) (tan k))
       (/ k (* t (/ t k)))))
     (/ 2.0 (pow (* (sqrt t) (/ (pow k 2.0) l_m)) 2.0)))))

C

l_m = fabs(l);
double code(double t, double l_m, double k) {
	double tmp;
	if (t <= 7.4e-141) {
		tmp = 2.0 * ((l_m / pow(k, 4.0)) * (l_m / t));
	} else if (t <= 5.1e+131) {
		tmp = 2.0 / (((sin(k) * ((pow(t, 2.0) / l_m) * (t / l_m))) * tan(k)) * (k / (t * (t / k))));
	} else {
		tmp = 2.0 / pow((sqrt(t) * (pow(k, 2.0) / l_m)), 2.0);
	}
	return tmp;
}

Fortran

l_m = abs(l)
real(8) function code(t, l_m, k)
    real(8), intent (in) :: t
    real(8), intent (in) :: l_m
    real(8), intent (in) :: k
    real(8) :: tmp
    if (t <= 7.4d-141) then
        tmp = 2.0d0 * ((l_m / (k ** 4.0d0)) * (l_m / t))
    else if (t <= 5.1d+131) then
        tmp = 2.0d0 / (((sin(k) * (((t ** 2.0d0) / l_m) * (t / l_m))) * tan(k)) * (k / (t * (t / k))))
    else
        tmp = 2.0d0 / ((sqrt(t) * ((k ** 2.0d0) / l_m)) ** 2.0d0)
    end if
    code = tmp
end function

Java

l_m = Math.abs(l);
public static double code(double t, double l_m, double k) {
	double tmp;
	if (t <= 7.4e-141) {
		tmp = 2.0 * ((l_m / Math.pow(k, 4.0)) * (l_m / t));
	} else if (t <= 5.1e+131) {
		tmp = 2.0 / (((Math.sin(k) * ((Math.pow(t, 2.0) / l_m) * (t / l_m))) * Math.tan(k)) * (k / (t * (t / k))));
	} else {
		tmp = 2.0 / Math.pow((Math.sqrt(t) * (Math.pow(k, 2.0) / l_m)), 2.0);
	}
	return tmp;
}

Python

l_m = math.fabs(l)
def code(t, l_m, k):
	tmp = 0
	if t <= 7.4e-141:
		tmp = 2.0 * ((l_m / math.pow(k, 4.0)) * (l_m / t))
	elif t <= 5.1e+131:
		tmp = 2.0 / (((math.sin(k) * ((math.pow(t, 2.0) / l_m) * (t / l_m))) * math.tan(k)) * (k / (t * (t / k))))
	else:
		tmp = 2.0 / math.pow((math.sqrt(t) * (math.pow(k, 2.0) / l_m)), 2.0)
	return tmp

Julia

l_m = abs(l)
function code(t, l_m, k)
	tmp = 0.0
	if (t <= 7.4e-141)
		tmp = Float64(2.0 * Float64(Float64(l_m / (k ^ 4.0)) * Float64(l_m / t)));
	elseif (t <= 5.1e+131)
		tmp = Float64(2.0 / Float64(Float64(Float64(sin(k) * Float64(Float64((t ^ 2.0) / l_m) * Float64(t / l_m))) * tan(k)) * Float64(k / Float64(t * Float64(t / k)))));
	else
		tmp = Float64(2.0 / (Float64(sqrt(t) * Float64((k ^ 2.0) / l_m)) ^ 2.0));
	end
	return tmp
end

MATLAB

l_m = abs(l);
function tmp_2 = code(t, l_m, k)
	tmp = 0.0;
	if (t <= 7.4e-141)
		tmp = 2.0 * ((l_m / (k ^ 4.0)) * (l_m / t));
	elseif (t <= 5.1e+131)
		tmp = 2.0 / (((sin(k) * (((t ^ 2.0) / l_m) * (t / l_m))) * tan(k)) * (k / (t * (t / k))));
	else
		tmp = 2.0 / ((sqrt(t) * ((k ^ 2.0) / l_m)) ^ 2.0);
	end
	tmp_2 = tmp;
end

Wolfram

l_m = N[Abs[l], $MachinePrecision]
code[t_, l$95$m_, k_] := If[LessEqual[t, 7.4e-141], N[(2.0 * N[(N[(l$95$m / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision] * N[(l$95$m / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.1e+131], N[(2.0 / N[(N[(N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l$95$m), $MachinePrecision] * N[(t / l$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(k / N[(t * N[(t / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[Power[N[(N[Sqrt[t], $MachinePrecision] * N[(N[Power[k, 2.0], $MachinePrecision] / l$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 9: 29.9% accurate, 1.4× speedup

Math

\[\begin{array}{l} l_m = \left|\ell\right| \\ \frac{2}{{\left(\sqrt{t} \cdot \frac{{k}^{2}}{l_m}\right)}^{2}} \end{array} \]

FPCore

l_m = (fabs.f64 l)
(FPCore (t l_m k)
 :precision binary64
 (/ 2.0 (pow (* (sqrt t) (/ (pow k 2.0) l_m)) 2.0)))

C

l_m = fabs(l);
double code(double t, double l_m, double k) {
	return 2.0 / pow((sqrt(t) * (pow(k, 2.0) / l_m)), 2.0);
}

Fortran

l_m = abs(l)
real(8) function code(t, l_m, k)
    real(8), intent (in) :: t
    real(8), intent (in) :: l_m
    real(8), intent (in) :: k
    code = 2.0d0 / ((sqrt(t) * ((k ** 2.0d0) / l_m)) ** 2.0d0)
end function

Java

l_m = Math.abs(l);
public static double code(double t, double l_m, double k) {
	return 2.0 / Math.pow((Math.sqrt(t) * (Math.pow(k, 2.0) / l_m)), 2.0);
}

Python

l_m = math.fabs(l)
def code(t, l_m, k):
	return 2.0 / math.pow((math.sqrt(t) * (math.pow(k, 2.0) / l_m)), 2.0)

Julia

l_m = abs(l)
function code(t, l_m, k)
	return Float64(2.0 / (Float64(sqrt(t) * Float64((k ^ 2.0) / l_m)) ^ 2.0))
end

MATLAB

l_m = abs(l);
function tmp = code(t, l_m, k)
	tmp = 2.0 / ((sqrt(t) * ((k ^ 2.0) / l_m)) ^ 2.0);
end

Wolfram

l_m = N[Abs[l], $MachinePrecision]
code[t_, l$95$m_, k_] := N[(2.0 / N[Power[N[(N[Sqrt[t], $MachinePrecision] * N[(N[Power[k, 2.0], $MachinePrecision] / l$95$m), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 10: 66.9% accurate, 3.8× speedup

Math

\[\begin{array}{l} l_m = \left|\ell\right| \\ \begin{array}{l} \mathbf{if}\;k \leq 4 \cdot 10^{-94}:\\ \;\;\;\;2 \cdot \frac{l_m \cdot \left(l_m \cdot {k}^{-4}\right)}{t}\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(\frac{l_m}{{k}^{4}} \cdot \frac{l_m}{t}\right)\\ \end{array} \end{array} \]

FPCore

l_m = (fabs.f64 l)
(FPCore (t l_m k)
 :precision binary64
 (if (<= k 4e-94)
   (* 2.0 (/ (* l_m (* l_m (pow k -4.0))) t))
   (* 2.0 (* (/ l_m (pow k 4.0)) (/ l_m t)))))

C

l_m = fabs(l);
double code(double t, double l_m, double k) {
	double tmp;
	if (k <= 4e-94) {
		tmp = 2.0 * ((l_m * (l_m * pow(k, -4.0))) / t);
	} else {
		tmp = 2.0 * ((l_m / pow(k, 4.0)) * (l_m / t));
	}
	return tmp;
}

Fortran

l_m = abs(l)
real(8) function code(t, l_m, k)
    real(8), intent (in) :: t
    real(8), intent (in) :: l_m
    real(8), intent (in) :: k
    real(8) :: tmp
    if (k <= 4d-94) then
        tmp = 2.0d0 * ((l_m * (l_m * (k ** (-4.0d0)))) / t)
    else
        tmp = 2.0d0 * ((l_m / (k ** 4.0d0)) * (l_m / t))
    end if
    code = tmp
end function

Java

l_m = Math.abs(l);
public static double code(double t, double l_m, double k) {
	double tmp;
	if (k <= 4e-94) {
		tmp = 2.0 * ((l_m * (l_m * Math.pow(k, -4.0))) / t);
	} else {
		tmp = 2.0 * ((l_m / Math.pow(k, 4.0)) * (l_m / t));
	}
	return tmp;
}

Python

l_m = math.fabs(l)
def code(t, l_m, k):
	tmp = 0
	if k <= 4e-94:
		tmp = 2.0 * ((l_m * (l_m * math.pow(k, -4.0))) / t)
	else:
		tmp = 2.0 * ((l_m / math.pow(k, 4.0)) * (l_m / t))
	return tmp

Julia

l_m = abs(l)
function code(t, l_m, k)
	tmp = 0.0
	if (k <= 4e-94)
		tmp = Float64(2.0 * Float64(Float64(l_m * Float64(l_m * (k ^ -4.0))) / t));
	else
		tmp = Float64(2.0 * Float64(Float64(l_m / (k ^ 4.0)) * Float64(l_m / t)));
	end
	return tmp
end

MATLAB

l_m = abs(l);
function tmp_2 = code(t, l_m, k)
	tmp = 0.0;
	if (k <= 4e-94)
		tmp = 2.0 * ((l_m * (l_m * (k ^ -4.0))) / t);
	else
		tmp = 2.0 * ((l_m / (k ^ 4.0)) * (l_m / t));
	end
	tmp_2 = tmp;
end

Wolfram

l_m = N[Abs[l], $MachinePrecision]
code[t_, l$95$m_, k_] := If[LessEqual[k, 4e-94], N[(2.0 * N[(N[(l$95$m * N[(l$95$m * N[Power[k, -4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(l$95$m / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision] * N[(l$95$m / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Alternative 11: 65.9% accurate, 3.8× speedup

Math

\[\begin{array}{l} l_m = \left|\ell\right| \\ 2 \cdot \left(\frac{l_m}{{k}^{4}} \cdot \frac{l_m}{t}\right) \end{array} \]

FPCore

l_m = (fabs.f64 l)
(FPCore (t l_m k)
 :precision binary64
 (* 2.0 (* (/ l_m (pow k 4.0)) (/ l_m t))))

C

l_m = fabs(l);
double code(double t, double l_m, double k) {
	return 2.0 * ((l_m / pow(k, 4.0)) * (l_m / t));
}

Fortran

l_m = abs(l)
real(8) function code(t, l_m, k)
    real(8), intent (in) :: t
    real(8), intent (in) :: l_m
    real(8), intent (in) :: k
    code = 2.0d0 * ((l_m / (k ** 4.0d0)) * (l_m / t))
end function

Java

l_m = Math.abs(l);
public static double code(double t, double l_m, double k) {
	return 2.0 * ((l_m / Math.pow(k, 4.0)) * (l_m / t));
}

Python

l_m = math.fabs(l)
def code(t, l_m, k):
	return 2.0 * ((l_m / math.pow(k, 4.0)) * (l_m / t))

Julia

l_m = abs(l)
function code(t, l_m, k)
	return Float64(2.0 * Float64(Float64(l_m / (k ^ 4.0)) * Float64(l_m / t)))
end

MATLAB

l_m = abs(l);
function tmp = code(t, l_m, k)
	tmp = 2.0 * ((l_m / (k ^ 4.0)) * (l_m / t));
end

Wolfram

l_m = N[Abs[l], $MachinePrecision]
code[t_, l$95$m_, k_] := N[(2.0 * N[(N[(l$95$m / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision] * N[(l$95$m / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

&prev;&pcontext;&pcontext2;&ctx;
1. Add Preprocessing

Reproduce

herbie shell --seed 2023350 
(FPCore (t l k)
  :name "Toniolo and Linder, Equation (10-)"
  :precision binary64
  (/ 2.0 (* (* (* (/ (pow t 3.0) (* l l)) (sin k)) (tan k)) (- (+ 1.0 (pow (/ k t) 2.0)) 1.0))))