Toniolo and Linder, Equation (10-)

Percentage Accurate: 35.1% → 83.2%

Time: 24.8s

Alternatives: 12

Speedup: 3.8×

• 35.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: 35.1% 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: 83.2% accurate, 0.4× speedup

Math

\[\begin{array}{l} t_m = \left|t\right| \\ t_s = \mathsf{copysign}\left(1, t\right) \\ t_s \cdot \begin{array}{l} \mathbf{if}\;\frac{2}{\left(\left(\frac{{t_m}^{3}}{\ell \cdot \ell} \cdot \sin k\right) \cdot \tan k\right) \cdot \left(\left(1 + {\left(\frac{k}{t_m}\right)}^{2}\right) + -1\right)} \leq 5 \cdot 10^{-84}:\\ \;\;\;\;\frac{2}{\frac{k}{t_m}} \cdot \frac{\frac{1}{\sin k \cdot \frac{{t_m}^{3}}{\frac{{\ell}^{2}}{\tan k}}}}{\frac{k}{t_m}}\\ \mathbf{else}:\\ \;\;\;\;\frac{1}{\frac{{k}^{2}}{\frac{2}{\frac{{\left(\sin k \cdot \frac{\sqrt{t_m}}{\ell}\right)}^{2}}{\cos k}}}}\\ \end{array} \end{array} \]

FPCore

t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
 :precision binary64
 (*
  t_s
  (if (<=
       (/
        2.0
        (*
         (* (* (/ (pow t_m 3.0) (* l l)) (sin k)) (tan k))
         (+ (+ 1.0 (pow (/ k t_m) 2.0)) -1.0)))
       5e-84)
    (*
     (/ 2.0 (/ k t_m))
     (/
      (/ 1.0 (* (sin k) (/ (pow t_m 3.0) (/ (pow l 2.0) (tan k)))))
      (/ k t_m)))
    (/
     1.0
     (/
      (pow k 2.0)
      (/ 2.0 (/ (pow (* (sin k) (/ (sqrt t_m) l)) 2.0) (cos k))))))))

C

t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
	double tmp;
	if ((2.0 / ((((pow(t_m, 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + pow((k / t_m), 2.0)) + -1.0))) <= 5e-84) {
		tmp = (2.0 / (k / t_m)) * ((1.0 / (sin(k) * (pow(t_m, 3.0) / (pow(l, 2.0) / tan(k))))) / (k / t_m));
	} else {
		tmp = 1.0 / (pow(k, 2.0) / (2.0 / (pow((sin(k) * (sqrt(t_m) / l)), 2.0) / cos(k))));
	}
	return t_s * tmp;
}

Fortran

t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: t_m
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8) :: tmp
    if ((2.0d0 / (((((t_m ** 3.0d0) / (l * l)) * sin(k)) * tan(k)) * ((1.0d0 + ((k / t_m) ** 2.0d0)) + (-1.0d0)))) <= 5d-84) then
        tmp = (2.0d0 / (k / t_m)) * ((1.0d0 / (sin(k) * ((t_m ** 3.0d0) / ((l ** 2.0d0) / tan(k))))) / (k / t_m))
    else
        tmp = 1.0d0 / ((k ** 2.0d0) / (2.0d0 / (((sin(k) * (sqrt(t_m) / l)) ** 2.0d0) / cos(k))))
    end if
    code = t_s * tmp
end function

Java

t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
	double tmp;
	if ((2.0 / ((((Math.pow(t_m, 3.0) / (l * l)) * Math.sin(k)) * Math.tan(k)) * ((1.0 + Math.pow((k / t_m), 2.0)) + -1.0))) <= 5e-84) {
		tmp = (2.0 / (k / t_m)) * ((1.0 / (Math.sin(k) * (Math.pow(t_m, 3.0) / (Math.pow(l, 2.0) / Math.tan(k))))) / (k / t_m));
	} else {
		tmp = 1.0 / (Math.pow(k, 2.0) / (2.0 / (Math.pow((Math.sin(k) * (Math.sqrt(t_m) / l)), 2.0) / Math.cos(k))));
	}
	return t_s * tmp;
}

Python

t_m = math.fabs(t)
t_s = math.copysign(1.0, t)
def code(t_s, t_m, l, k):
	tmp = 0
	if (2.0 / ((((math.pow(t_m, 3.0) / (l * l)) * math.sin(k)) * math.tan(k)) * ((1.0 + math.pow((k / t_m), 2.0)) + -1.0))) <= 5e-84:
		tmp = (2.0 / (k / t_m)) * ((1.0 / (math.sin(k) * (math.pow(t_m, 3.0) / (math.pow(l, 2.0) / math.tan(k))))) / (k / t_m))
	else:
		tmp = 1.0 / (math.pow(k, 2.0) / (2.0 / (math.pow((math.sin(k) * (math.sqrt(t_m) / l)), 2.0) / math.cos(k))))
	return t_s * tmp

Julia

t_m = abs(t)
t_s = copysign(1.0, t)
function code(t_s, t_m, l, k)
	tmp = 0.0
	if (Float64(2.0 / Float64(Float64(Float64(Float64((t_m ^ 3.0) / Float64(l * l)) * sin(k)) * tan(k)) * Float64(Float64(1.0 + (Float64(k / t_m) ^ 2.0)) + -1.0))) <= 5e-84)
		tmp = Float64(Float64(2.0 / Float64(k / t_m)) * Float64(Float64(1.0 / Float64(sin(k) * Float64((t_m ^ 3.0) / Float64((l ^ 2.0) / tan(k))))) / Float64(k / t_m)));
	else
		tmp = Float64(1.0 / Float64((k ^ 2.0) / Float64(2.0 / Float64((Float64(sin(k) * Float64(sqrt(t_m) / l)) ^ 2.0) / cos(k)))));
	end
	return Float64(t_s * tmp)
end

MATLAB

t_m = abs(t);
t_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, t_m, l, k)
	tmp = 0.0;
	if ((2.0 / (((((t_m ^ 3.0) / (l * l)) * sin(k)) * tan(k)) * ((1.0 + ((k / t_m) ^ 2.0)) + -1.0))) <= 5e-84)
		tmp = (2.0 / (k / t_m)) * ((1.0 / (sin(k) * ((t_m ^ 3.0) / ((l ^ 2.0) / tan(k))))) / (k / t_m));
	else
		tmp = 1.0 / ((k ^ 2.0) / (2.0 / (((sin(k) * (sqrt(t_m) / l)) ^ 2.0) / cos(k))));
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[N[(2.0 / N[(N[(N[(N[(N[Power[t$95$m, 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$95$m), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] + -1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 5e-84], N[(N[(2.0 / N[(k / t$95$m), $MachinePrecision]), $MachinePrecision] * N[(N[(1.0 / N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t$95$m, 3.0], $MachinePrecision] / N[(N[Power[l, 2.0], $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(k / t$95$m), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(1.0 / N[(N[Power[k, 2.0], $MachinePrecision] / N[(2.0 / N[(N[Power[N[(N[Sin[k], $MachinePrecision] * N[(N[Sqrt[t$95$m], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

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

Alternative 2: 81.8% accurate, 0.8× speedup

Math

\[\begin{array}{l} t_m = \left|t\right| \\ t_s = \mathsf{copysign}\left(1, t\right) \\ t_s \cdot \begin{array}{l} \mathbf{if}\;k \leq 2.05 \cdot 10^{-26} \lor \neg \left(k \leq 5 \cdot 10^{+160}\right):\\ \;\;\;\;2 \cdot {\left(\frac{\frac{\ell}{k}}{\sin k \cdot \sqrt{t_m}}\right)}^{2}\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \left(\frac{{\ell}^{2}}{t_m} \cdot \frac{\cos k \cdot {k}^{-2}}{{\sin k}^{2}}\right)\\ \end{array} \end{array} \]

FPCore

t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
 :precision binary64
 (*
  t_s
  (if (or (<= k 2.05e-26) (not (<= k 5e+160)))
    (* 2.0 (pow (/ (/ l k) (* (sin k) (sqrt t_m))) 2.0))
    (*
     2.0
     (* (/ (pow l 2.0) t_m) (/ (* (cos k) (pow k -2.0)) (pow (sin k) 2.0)))))))

C

t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
	double tmp;
	if ((k <= 2.05e-26) || !(k <= 5e+160)) {
		tmp = 2.0 * pow(((l / k) / (sin(k) * sqrt(t_m))), 2.0);
	} else {
		tmp = 2.0 * ((pow(l, 2.0) / t_m) * ((cos(k) * pow(k, -2.0)) / pow(sin(k), 2.0)));
	}
	return t_s * tmp;
}

Fortran

t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: t_m
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8) :: tmp
    if ((k <= 2.05d-26) .or. (.not. (k <= 5d+160))) then
        tmp = 2.0d0 * (((l / k) / (sin(k) * sqrt(t_m))) ** 2.0d0)
    else
        tmp = 2.0d0 * (((l ** 2.0d0) / t_m) * ((cos(k) * (k ** (-2.0d0))) / (sin(k) ** 2.0d0)))
    end if
    code = t_s * tmp
end function

Java

t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
	double tmp;
	if ((k <= 2.05e-26) || !(k <= 5e+160)) {
		tmp = 2.0 * Math.pow(((l / k) / (Math.sin(k) * Math.sqrt(t_m))), 2.0);
	} else {
		tmp = 2.0 * ((Math.pow(l, 2.0) / t_m) * ((Math.cos(k) * Math.pow(k, -2.0)) / Math.pow(Math.sin(k), 2.0)));
	}
	return t_s * tmp;
}

Python

t_m = math.fabs(t)
t_s = math.copysign(1.0, t)
def code(t_s, t_m, l, k):
	tmp = 0
	if (k <= 2.05e-26) or not (k <= 5e+160):
		tmp = 2.0 * math.pow(((l / k) / (math.sin(k) * math.sqrt(t_m))), 2.0)
	else:
		tmp = 2.0 * ((math.pow(l, 2.0) / t_m) * ((math.cos(k) * math.pow(k, -2.0)) / math.pow(math.sin(k), 2.0)))
	return t_s * tmp

Julia

t_m = abs(t)
t_s = copysign(1.0, t)
function code(t_s, t_m, l, k)
	tmp = 0.0
	if ((k <= 2.05e-26) || !(k <= 5e+160))
		tmp = Float64(2.0 * (Float64(Float64(l / k) / Float64(sin(k) * sqrt(t_m))) ^ 2.0));
	else
		tmp = Float64(2.0 * Float64(Float64((l ^ 2.0) / t_m) * Float64(Float64(cos(k) * (k ^ -2.0)) / (sin(k) ^ 2.0))));
	end
	return Float64(t_s * tmp)
end

MATLAB

t_m = abs(t);
t_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, t_m, l, k)
	tmp = 0.0;
	if ((k <= 2.05e-26) || ~((k <= 5e+160)))
		tmp = 2.0 * (((l / k) / (sin(k) * sqrt(t_m))) ^ 2.0);
	else
		tmp = 2.0 * (((l ^ 2.0) / t_m) * ((cos(k) * (k ^ -2.0)) / (sin(k) ^ 2.0)));
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[Or[LessEqual[k, 2.05e-26], N[Not[LessEqual[k, 5e+160]], $MachinePrecision]], N[(2.0 * N[Power[N[(N[(l / k), $MachinePrecision] / N[(N[Sin[k], $MachinePrecision] * N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[Power[l, 2.0], $MachinePrecision] / t$95$m), $MachinePrecision] * N[(N[(N[Cos[k], $MachinePrecision] * N[Power[k, -2.0], $MachinePrecision]), $MachinePrecision] / N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

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

Alternative 3: 80.2% accurate, 0.8× speedup

Math

\[\begin{array}{l} t_m = \left|t\right| \\ t_s = \mathsf{copysign}\left(1, t\right) \\ \begin{array}{l} t_2 := \sin k \cdot \sqrt{t_m}\\ t_s \cdot \begin{array}{l} \mathbf{if}\;k \leq 0.0086:\\ \;\;\;\;2 \cdot {\left(\frac{\frac{\ell \cdot \sqrt{\cos k}}{k}}{t_2}\right)}^{2}\\ \mathbf{elif}\;k \leq 2.6 \cdot 10^{+160}:\\ \;\;\;\;2 \cdot \left(\left({k}^{-2} \cdot \left({\ell}^{2} \cdot \cos k\right)\right) \cdot \frac{1}{t_m \cdot \left(0.5 - \frac{\cos \left(2 \cdot k\right)}{2}\right)}\right)\\ \mathbf{else}:\\ \;\;\;\;2 \cdot {\left(\frac{\frac{\ell}{k}}{t_2}\right)}^{2}\\ \end{array} \end{array} \end{array} \]

FPCore

t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
 :precision binary64
 (let* ((t_2 (* (sin k) (sqrt t_m))))
   (*
    t_s
    (if (<= k 0.0086)
      (* 2.0 (pow (/ (/ (* l (sqrt (cos k))) k) t_2) 2.0))
      (if (<= k 2.6e+160)
        (*
         2.0
         (*
          (* (pow k -2.0) (* (pow l 2.0) (cos k)))
          (/ 1.0 (* t_m (- 0.5 (/ (cos (* 2.0 k)) 2.0))))))
        (* 2.0 (pow (/ (/ l k) t_2) 2.0)))))))

C

t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
	double t_2 = sin(k) * sqrt(t_m);
	double tmp;
	if (k <= 0.0086) {
		tmp = 2.0 * pow((((l * sqrt(cos(k))) / k) / t_2), 2.0);
	} else if (k <= 2.6e+160) {
		tmp = 2.0 * ((pow(k, -2.0) * (pow(l, 2.0) * cos(k))) * (1.0 / (t_m * (0.5 - (cos((2.0 * k)) / 2.0)))));
	} else {
		tmp = 2.0 * pow(((l / k) / t_2), 2.0);
	}
	return t_s * tmp;
}

Fortran

t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: t_m
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8) :: t_2
    real(8) :: tmp
    t_2 = sin(k) * sqrt(t_m)
    if (k <= 0.0086d0) then
        tmp = 2.0d0 * ((((l * sqrt(cos(k))) / k) / t_2) ** 2.0d0)
    else if (k <= 2.6d+160) then
        tmp = 2.0d0 * (((k ** (-2.0d0)) * ((l ** 2.0d0) * cos(k))) * (1.0d0 / (t_m * (0.5d0 - (cos((2.0d0 * k)) / 2.0d0)))))
    else
        tmp = 2.0d0 * (((l / k) / t_2) ** 2.0d0)
    end if
    code = t_s * tmp
end function

Java

t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
	double t_2 = Math.sin(k) * Math.sqrt(t_m);
	double tmp;
	if (k <= 0.0086) {
		tmp = 2.0 * Math.pow((((l * Math.sqrt(Math.cos(k))) / k) / t_2), 2.0);
	} else if (k <= 2.6e+160) {
		tmp = 2.0 * ((Math.pow(k, -2.0) * (Math.pow(l, 2.0) * Math.cos(k))) * (1.0 / (t_m * (0.5 - (Math.cos((2.0 * k)) / 2.0)))));
	} else {
		tmp = 2.0 * Math.pow(((l / k) / t_2), 2.0);
	}
	return t_s * tmp;
}

Python

t_m = math.fabs(t)
t_s = math.copysign(1.0, t)
def code(t_s, t_m, l, k):
	t_2 = math.sin(k) * math.sqrt(t_m)
	tmp = 0
	if k <= 0.0086:
		tmp = 2.0 * math.pow((((l * math.sqrt(math.cos(k))) / k) / t_2), 2.0)
	elif k <= 2.6e+160:
		tmp = 2.0 * ((math.pow(k, -2.0) * (math.pow(l, 2.0) * math.cos(k))) * (1.0 / (t_m * (0.5 - (math.cos((2.0 * k)) / 2.0)))))
	else:
		tmp = 2.0 * math.pow(((l / k) / t_2), 2.0)
	return t_s * tmp

Julia

t_m = abs(t)
t_s = copysign(1.0, t)
function code(t_s, t_m, l, k)
	t_2 = Float64(sin(k) * sqrt(t_m))
	tmp = 0.0
	if (k <= 0.0086)
		tmp = Float64(2.0 * (Float64(Float64(Float64(l * sqrt(cos(k))) / k) / t_2) ^ 2.0));
	elseif (k <= 2.6e+160)
		tmp = Float64(2.0 * Float64(Float64((k ^ -2.0) * Float64((l ^ 2.0) * cos(k))) * Float64(1.0 / Float64(t_m * Float64(0.5 - Float64(cos(Float64(2.0 * k)) / 2.0))))));
	else
		tmp = Float64(2.0 * (Float64(Float64(l / k) / t_2) ^ 2.0));
	end
	return Float64(t_s * tmp)
end

MATLAB

t_m = abs(t);
t_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, t_m, l, k)
	t_2 = sin(k) * sqrt(t_m);
	tmp = 0.0;
	if (k <= 0.0086)
		tmp = 2.0 * ((((l * sqrt(cos(k))) / k) / t_2) ^ 2.0);
	elseif (k <= 2.6e+160)
		tmp = 2.0 * (((k ^ -2.0) * ((l ^ 2.0) * cos(k))) * (1.0 / (t_m * (0.5 - (cos((2.0 * k)) / 2.0)))));
	else
		tmp = 2.0 * (((l / k) / t_2) ^ 2.0);
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := Block[{t$95$2 = N[(N[Sin[k], $MachinePrecision] * N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision]}, N[(t$95$s * If[LessEqual[k, 0.0086], N[(2.0 * N[Power[N[(N[(N[(l * N[Sqrt[N[Cos[k], $MachinePrecision]], $MachinePrecision]), $MachinePrecision] / k), $MachinePrecision] / t$95$2), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 2.6e+160], N[(2.0 * N[(N[(N[Power[k, -2.0], $MachinePrecision] * N[(N[Power[l, 2.0], $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 / N[(t$95$m * N[(0.5 - N[(N[Cos[N[(2.0 * k), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[Power[N[(N[(l / k), $MachinePrecision] / t$95$2), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]]

Derivation

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

Alternative 4: 81.8% accurate, 1.0× speedup

Math

\[\begin{array}{l} t_m = \left|t\right| \\ t_s = \mathsf{copysign}\left(1, t\right) \\ t_s \cdot \begin{array}{l} \mathbf{if}\;k \leq 2.05 \cdot 10^{-26} \lor \neg \left(k \leq 2.5 \cdot 10^{+160}\right):\\ \;\;\;\;2 \cdot {\left(\frac{\frac{\ell}{k}}{\sin k \cdot \sqrt{t_m}}\right)}^{2}\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \frac{\frac{\left(\ell \cdot \ell\right) \cdot \cos k}{{k}^{2}}}{t_m \cdot {\sin k}^{2}}\\ \end{array} \end{array} \]

FPCore

t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
 :precision binary64
 (*
  t_s
  (if (or (<= k 2.05e-26) (not (<= k 2.5e+160)))
    (* 2.0 (pow (/ (/ l k) (* (sin k) (sqrt t_m))) 2.0))
    (*
     2.0
     (/ (/ (* (* l l) (cos k)) (pow k 2.0)) (* t_m (pow (sin k) 2.0)))))))

C

t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
	double tmp;
	if ((k <= 2.05e-26) || !(k <= 2.5e+160)) {
		tmp = 2.0 * pow(((l / k) / (sin(k) * sqrt(t_m))), 2.0);
	} else {
		tmp = 2.0 * ((((l * l) * cos(k)) / pow(k, 2.0)) / (t_m * pow(sin(k), 2.0)));
	}
	return t_s * tmp;
}

Fortran

t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: t_m
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8) :: tmp
    if ((k <= 2.05d-26) .or. (.not. (k <= 2.5d+160))) then
        tmp = 2.0d0 * (((l / k) / (sin(k) * sqrt(t_m))) ** 2.0d0)
    else
        tmp = 2.0d0 * ((((l * l) * cos(k)) / (k ** 2.0d0)) / (t_m * (sin(k) ** 2.0d0)))
    end if
    code = t_s * tmp
end function

Java

t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
	double tmp;
	if ((k <= 2.05e-26) || !(k <= 2.5e+160)) {
		tmp = 2.0 * Math.pow(((l / k) / (Math.sin(k) * Math.sqrt(t_m))), 2.0);
	} else {
		tmp = 2.0 * ((((l * l) * Math.cos(k)) / Math.pow(k, 2.0)) / (t_m * Math.pow(Math.sin(k), 2.0)));
	}
	return t_s * tmp;
}

Python

t_m = math.fabs(t)
t_s = math.copysign(1.0, t)
def code(t_s, t_m, l, k):
	tmp = 0
	if (k <= 2.05e-26) or not (k <= 2.5e+160):
		tmp = 2.0 * math.pow(((l / k) / (math.sin(k) * math.sqrt(t_m))), 2.0)
	else:
		tmp = 2.0 * ((((l * l) * math.cos(k)) / math.pow(k, 2.0)) / (t_m * math.pow(math.sin(k), 2.0)))
	return t_s * tmp

Julia

t_m = abs(t)
t_s = copysign(1.0, t)
function code(t_s, t_m, l, k)
	tmp = 0.0
	if ((k <= 2.05e-26) || !(k <= 2.5e+160))
		tmp = Float64(2.0 * (Float64(Float64(l / k) / Float64(sin(k) * sqrt(t_m))) ^ 2.0));
	else
		tmp = Float64(2.0 * Float64(Float64(Float64(Float64(l * l) * cos(k)) / (k ^ 2.0)) / Float64(t_m * (sin(k) ^ 2.0))));
	end
	return Float64(t_s * tmp)
end

MATLAB

t_m = abs(t);
t_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, t_m, l, k)
	tmp = 0.0;
	if ((k <= 2.05e-26) || ~((k <= 2.5e+160)))
		tmp = 2.0 * (((l / k) / (sin(k) * sqrt(t_m))) ^ 2.0);
	else
		tmp = 2.0 * ((((l * l) * cos(k)) / (k ^ 2.0)) / (t_m * (sin(k) ^ 2.0)));
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[Or[LessEqual[k, 2.05e-26], N[Not[LessEqual[k, 2.5e+160]], $MachinePrecision]], N[(2.0 * N[Power[N[(N[(l / k), $MachinePrecision] / N[(N[Sin[k], $MachinePrecision] * N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(N[(l * l), $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t$95$m * N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

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

Alternative 5: 81.7% accurate, 1.0× speedup

Math

\[\begin{array}{l} t_m = \left|t\right| \\ t_s = \mathsf{copysign}\left(1, t\right) \\ t_s \cdot \begin{array}{l} \mathbf{if}\;k \leq 8 \cdot 10^{-23} \lor \neg \left(k \leq 2.5 \cdot 10^{+160}\right):\\ \;\;\;\;2 \cdot {\left(\frac{\frac{\ell}{k}}{\sin k \cdot \sqrt{t_m}}\right)}^{2}\\ \mathbf{else}:\\ \;\;\;\;\frac{2}{\frac{{k}^{2} \cdot \left(t_m \cdot {\sin k}^{2}\right)}{\left(\ell \cdot \ell\right) \cdot \cos k}}\\ \end{array} \end{array} \]

FPCore

t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
 :precision binary64
 (*
  t_s
  (if (or (<= k 8e-23) (not (<= k 2.5e+160)))
    (* 2.0 (pow (/ (/ l k) (* (sin k) (sqrt t_m))) 2.0))
    (/
     2.0
     (/ (* (pow k 2.0) (* t_m (pow (sin k) 2.0))) (* (* l l) (cos k)))))))

C

t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
	double tmp;
	if ((k <= 8e-23) || !(k <= 2.5e+160)) {
		tmp = 2.0 * pow(((l / k) / (sin(k) * sqrt(t_m))), 2.0);
	} else {
		tmp = 2.0 / ((pow(k, 2.0) * (t_m * pow(sin(k), 2.0))) / ((l * l) * cos(k)));
	}
	return t_s * tmp;
}

Fortran

t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: t_m
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8) :: tmp
    if ((k <= 8d-23) .or. (.not. (k <= 2.5d+160))) then
        tmp = 2.0d0 * (((l / k) / (sin(k) * sqrt(t_m))) ** 2.0d0)
    else
        tmp = 2.0d0 / (((k ** 2.0d0) * (t_m * (sin(k) ** 2.0d0))) / ((l * l) * cos(k)))
    end if
    code = t_s * tmp
end function

Java

t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
	double tmp;
	if ((k <= 8e-23) || !(k <= 2.5e+160)) {
		tmp = 2.0 * Math.pow(((l / k) / (Math.sin(k) * Math.sqrt(t_m))), 2.0);
	} else {
		tmp = 2.0 / ((Math.pow(k, 2.0) * (t_m * Math.pow(Math.sin(k), 2.0))) / ((l * l) * Math.cos(k)));
	}
	return t_s * tmp;
}

Python

t_m = math.fabs(t)
t_s = math.copysign(1.0, t)
def code(t_s, t_m, l, k):
	tmp = 0
	if (k <= 8e-23) or not (k <= 2.5e+160):
		tmp = 2.0 * math.pow(((l / k) / (math.sin(k) * math.sqrt(t_m))), 2.0)
	else:
		tmp = 2.0 / ((math.pow(k, 2.0) * (t_m * math.pow(math.sin(k), 2.0))) / ((l * l) * math.cos(k)))
	return t_s * tmp

Julia

t_m = abs(t)
t_s = copysign(1.0, t)
function code(t_s, t_m, l, k)
	tmp = 0.0
	if ((k <= 8e-23) || !(k <= 2.5e+160))
		tmp = Float64(2.0 * (Float64(Float64(l / k) / Float64(sin(k) * sqrt(t_m))) ^ 2.0));
	else
		tmp = Float64(2.0 / Float64(Float64((k ^ 2.0) * Float64(t_m * (sin(k) ^ 2.0))) / Float64(Float64(l * l) * cos(k))));
	end
	return Float64(t_s * tmp)
end

MATLAB

t_m = abs(t);
t_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, t_m, l, k)
	tmp = 0.0;
	if ((k <= 8e-23) || ~((k <= 2.5e+160)))
		tmp = 2.0 * (((l / k) / (sin(k) * sqrt(t_m))) ^ 2.0);
	else
		tmp = 2.0 / (((k ^ 2.0) * (t_m * (sin(k) ^ 2.0))) / ((l * l) * cos(k)));
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[Or[LessEqual[k, 8e-23], N[Not[LessEqual[k, 2.5e+160]], $MachinePrecision]], N[(2.0 * N[Power[N[(N[(l / k), $MachinePrecision] / N[(N[Sin[k], $MachinePrecision] * N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(N[Power[k, 2.0], $MachinePrecision] * N[(t$95$m * N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(l * l), $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

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

Alternative 6: 80.1% accurate, 1.0× speedup

Math

\[\begin{array}{l} t_m = \left|t\right| \\ t_s = \mathsf{copysign}\left(1, t\right) \\ t_s \cdot \begin{array}{l} \mathbf{if}\;k \leq 0.0086:\\ \;\;\;\;2 \cdot {\left(\frac{\frac{\ell}{k}}{\sin k} \cdot \sqrt{\frac{\cos k}{t_m}}\right)}^{2}\\ \mathbf{elif}\;k \leq 2.5 \cdot 10^{+160}:\\ \;\;\;\;2 \cdot \frac{\frac{\left(\ell \cdot \ell\right) \cdot \cos k}{{k}^{2}}}{t_m \cdot \left(0.5 - \frac{\cos \left(2 \cdot k\right)}{2}\right)}\\ \mathbf{else}:\\ \;\;\;\;2 \cdot {\left(\frac{\frac{\ell}{k}}{\sin k \cdot \sqrt{t_m}}\right)}^{2}\\ \end{array} \end{array} \]

FPCore

t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
 :precision binary64
 (*
  t_s
  (if (<= k 0.0086)
    (* 2.0 (pow (* (/ (/ l k) (sin k)) (sqrt (/ (cos k) t_m))) 2.0))
    (if (<= k 2.5e+160)
      (*
       2.0
       (/
        (/ (* (* l l) (cos k)) (pow k 2.0))
        (* t_m (- 0.5 (/ (cos (* 2.0 k)) 2.0)))))
      (* 2.0 (pow (/ (/ l k) (* (sin k) (sqrt t_m))) 2.0))))))

C

t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
	double tmp;
	if (k <= 0.0086) {
		tmp = 2.0 * pow((((l / k) / sin(k)) * sqrt((cos(k) / t_m))), 2.0);
	} else if (k <= 2.5e+160) {
		tmp = 2.0 * ((((l * l) * cos(k)) / pow(k, 2.0)) / (t_m * (0.5 - (cos((2.0 * k)) / 2.0))));
	} else {
		tmp = 2.0 * pow(((l / k) / (sin(k) * sqrt(t_m))), 2.0);
	}
	return t_s * tmp;
}

Fortran

t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: t_m
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8) :: tmp
    if (k <= 0.0086d0) then
        tmp = 2.0d0 * ((((l / k) / sin(k)) * sqrt((cos(k) / t_m))) ** 2.0d0)
    else if (k <= 2.5d+160) then
        tmp = 2.0d0 * ((((l * l) * cos(k)) / (k ** 2.0d0)) / (t_m * (0.5d0 - (cos((2.0d0 * k)) / 2.0d0))))
    else
        tmp = 2.0d0 * (((l / k) / (sin(k) * sqrt(t_m))) ** 2.0d0)
    end if
    code = t_s * tmp
end function

Java

t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
	double tmp;
	if (k <= 0.0086) {
		tmp = 2.0 * Math.pow((((l / k) / Math.sin(k)) * Math.sqrt((Math.cos(k) / t_m))), 2.0);
	} else if (k <= 2.5e+160) {
		tmp = 2.0 * ((((l * l) * Math.cos(k)) / Math.pow(k, 2.0)) / (t_m * (0.5 - (Math.cos((2.0 * k)) / 2.0))));
	} else {
		tmp = 2.0 * Math.pow(((l / k) / (Math.sin(k) * Math.sqrt(t_m))), 2.0);
	}
	return t_s * tmp;
}

Python

t_m = math.fabs(t)
t_s = math.copysign(1.0, t)
def code(t_s, t_m, l, k):
	tmp = 0
	if k <= 0.0086:
		tmp = 2.0 * math.pow((((l / k) / math.sin(k)) * math.sqrt((math.cos(k) / t_m))), 2.0)
	elif k <= 2.5e+160:
		tmp = 2.0 * ((((l * l) * math.cos(k)) / math.pow(k, 2.0)) / (t_m * (0.5 - (math.cos((2.0 * k)) / 2.0))))
	else:
		tmp = 2.0 * math.pow(((l / k) / (math.sin(k) * math.sqrt(t_m))), 2.0)
	return t_s * tmp

Julia

t_m = abs(t)
t_s = copysign(1.0, t)
function code(t_s, t_m, l, k)
	tmp = 0.0
	if (k <= 0.0086)
		tmp = Float64(2.0 * (Float64(Float64(Float64(l / k) / sin(k)) * sqrt(Float64(cos(k) / t_m))) ^ 2.0));
	elseif (k <= 2.5e+160)
		tmp = Float64(2.0 * Float64(Float64(Float64(Float64(l * l) * cos(k)) / (k ^ 2.0)) / Float64(t_m * Float64(0.5 - Float64(cos(Float64(2.0 * k)) / 2.0)))));
	else
		tmp = Float64(2.0 * (Float64(Float64(l / k) / Float64(sin(k) * sqrt(t_m))) ^ 2.0));
	end
	return Float64(t_s * tmp)
end

MATLAB

t_m = abs(t);
t_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, t_m, l, k)
	tmp = 0.0;
	if (k <= 0.0086)
		tmp = 2.0 * ((((l / k) / sin(k)) * sqrt((cos(k) / t_m))) ^ 2.0);
	elseif (k <= 2.5e+160)
		tmp = 2.0 * ((((l * l) * cos(k)) / (k ^ 2.0)) / (t_m * (0.5 - (cos((2.0 * k)) / 2.0))));
	else
		tmp = 2.0 * (((l / k) / (sin(k) * sqrt(t_m))) ^ 2.0);
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[LessEqual[k, 0.0086], N[(2.0 * N[Power[N[(N[(N[(l / k), $MachinePrecision] / N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(N[Cos[k], $MachinePrecision] / t$95$m), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 2.5e+160], N[(2.0 * N[(N[(N[(N[(l * l), $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t$95$m * N[(0.5 - N[(N[Cos[N[(2.0 * k), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[Power[N[(N[(l / k), $MachinePrecision] / N[(N[Sin[k], $MachinePrecision] * N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]]]), $MachinePrecision]

Derivation

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

Alternative 7: 82.0% accurate, 1.3× speedup

Math

\[\begin{array}{l} t_m = \left|t\right| \\ t_s = \mathsf{copysign}\left(1, t\right) \\ t_s \cdot \begin{array}{l} \mathbf{if}\;k \leq 0.00013 \lor \neg \left(k \leq 2.45 \cdot 10^{+160}\right):\\ \;\;\;\;2 \cdot {\left(\frac{\frac{\ell}{k}}{\sin k \cdot \sqrt{t_m}}\right)}^{2}\\ \mathbf{else}:\\ \;\;\;\;2 \cdot \frac{\frac{\left(\ell \cdot \ell\right) \cdot \cos k}{{k}^{2}}}{t_m \cdot \left(0.5 - \frac{\cos \left(2 \cdot k\right)}{2}\right)}\\ \end{array} \end{array} \]

FPCore

t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
 :precision binary64
 (*
  t_s
  (if (or (<= k 0.00013) (not (<= k 2.45e+160)))
    (* 2.0 (pow (/ (/ l k) (* (sin k) (sqrt t_m))) 2.0))
    (*
     2.0
     (/
      (/ (* (* l l) (cos k)) (pow k 2.0))
      (* t_m (- 0.5 (/ (cos (* 2.0 k)) 2.0))))))))

C

t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
	double tmp;
	if ((k <= 0.00013) || !(k <= 2.45e+160)) {
		tmp = 2.0 * pow(((l / k) / (sin(k) * sqrt(t_m))), 2.0);
	} else {
		tmp = 2.0 * ((((l * l) * cos(k)) / pow(k, 2.0)) / (t_m * (0.5 - (cos((2.0 * k)) / 2.0))));
	}
	return t_s * tmp;
}

Fortran

t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: t_m
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    real(8) :: tmp
    if ((k <= 0.00013d0) .or. (.not. (k <= 2.45d+160))) then
        tmp = 2.0d0 * (((l / k) / (sin(k) * sqrt(t_m))) ** 2.0d0)
    else
        tmp = 2.0d0 * ((((l * l) * cos(k)) / (k ** 2.0d0)) / (t_m * (0.5d0 - (cos((2.0d0 * k)) / 2.0d0))))
    end if
    code = t_s * tmp
end function

Java

t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
	double tmp;
	if ((k <= 0.00013) || !(k <= 2.45e+160)) {
		tmp = 2.0 * Math.pow(((l / k) / (Math.sin(k) * Math.sqrt(t_m))), 2.0);
	} else {
		tmp = 2.0 * ((((l * l) * Math.cos(k)) / Math.pow(k, 2.0)) / (t_m * (0.5 - (Math.cos((2.0 * k)) / 2.0))));
	}
	return t_s * tmp;
}

Python

t_m = math.fabs(t)
t_s = math.copysign(1.0, t)
def code(t_s, t_m, l, k):
	tmp = 0
	if (k <= 0.00013) or not (k <= 2.45e+160):
		tmp = 2.0 * math.pow(((l / k) / (math.sin(k) * math.sqrt(t_m))), 2.0)
	else:
		tmp = 2.0 * ((((l * l) * math.cos(k)) / math.pow(k, 2.0)) / (t_m * (0.5 - (math.cos((2.0 * k)) / 2.0))))
	return t_s * tmp

Julia

t_m = abs(t)
t_s = copysign(1.0, t)
function code(t_s, t_m, l, k)
	tmp = 0.0
	if ((k <= 0.00013) || !(k <= 2.45e+160))
		tmp = Float64(2.0 * (Float64(Float64(l / k) / Float64(sin(k) * sqrt(t_m))) ^ 2.0));
	else
		tmp = Float64(2.0 * Float64(Float64(Float64(Float64(l * l) * cos(k)) / (k ^ 2.0)) / Float64(t_m * Float64(0.5 - Float64(cos(Float64(2.0 * k)) / 2.0)))));
	end
	return Float64(t_s * tmp)
end

MATLAB

t_m = abs(t);
t_s = sign(t) * abs(1.0);
function tmp_2 = code(t_s, t_m, l, k)
	tmp = 0.0;
	if ((k <= 0.00013) || ~((k <= 2.45e+160)))
		tmp = 2.0 * (((l / k) / (sin(k) * sqrt(t_m))) ^ 2.0);
	else
		tmp = 2.0 * ((((l * l) * cos(k)) / (k ^ 2.0)) / (t_m * (0.5 - (cos((2.0 * k)) / 2.0))));
	end
	tmp_2 = t_s * tmp;
end

Wolfram

t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * If[Or[LessEqual[k, 0.00013], N[Not[LessEqual[k, 2.45e+160]], $MachinePrecision]], N[(2.0 * N[Power[N[(N[(l / k), $MachinePrecision] / N[(N[Sin[k], $MachinePrecision] * N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(N[(l * l), $MachinePrecision] * N[Cos[k], $MachinePrecision]), $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[(t$95$m * N[(0.5 - N[(N[Cos[N[(2.0 * k), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]), $MachinePrecision]

Derivation

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

Alternative 8: 77.5% accurate, 1.4× speedup

Math

\[\begin{array}{l} t_m = \left|t\right| \\ t_s = \mathsf{copysign}\left(1, t\right) \\ t_s \cdot \left(2 \cdot {\left(\frac{\frac{\ell}{k}}{\sin k \cdot \sqrt{t_m}}\right)}^{2}\right) \end{array} \]

FPCore

t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
 :precision binary64
 (* t_s (* 2.0 (pow (/ (/ l k) (* (sin k) (sqrt t_m))) 2.0))))

C

t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
	return t_s * (2.0 * pow(((l / k) / (sin(k) * sqrt(t_m))), 2.0));
}

Fortran

t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: t_m
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    code = t_s * (2.0d0 * (((l / k) / (sin(k) * sqrt(t_m))) ** 2.0d0))
end function

Java

t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
	return t_s * (2.0 * Math.pow(((l / k) / (Math.sin(k) * Math.sqrt(t_m))), 2.0));
}

Python

t_m = math.fabs(t)
t_s = math.copysign(1.0, t)
def code(t_s, t_m, l, k):
	return t_s * (2.0 * math.pow(((l / k) / (math.sin(k) * math.sqrt(t_m))), 2.0))

Julia

t_m = abs(t)
t_s = copysign(1.0, t)
function code(t_s, t_m, l, k)
	return Float64(t_s * Float64(2.0 * (Float64(Float64(l / k) / Float64(sin(k) * sqrt(t_m))) ^ 2.0)))
end

MATLAB

t_m = abs(t);
t_s = sign(t) * abs(1.0);
function tmp = code(t_s, t_m, l, k)
	tmp = t_s * (2.0 * (((l / k) / (sin(k) * sqrt(t_m))) ^ 2.0));
end

Wolfram

t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * N[(2.0 * N[Power[N[(N[(l / k), $MachinePrecision] / N[(N[Sin[k], $MachinePrecision] * N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 9: 63.8% accurate, 1.4× speedup

Math

\[\begin{array}{l} t_m = \left|t\right| \\ t_s = \mathsf{copysign}\left(1, t\right) \\ t_s \cdot \left(2 \cdot \frac{{\left(\frac{\ell}{\sqrt{t_m}}\right)}^{2}}{{k}^{4}}\right) \end{array} \]

FPCore

t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
 :precision binary64
 (* t_s (* 2.0 (/ (pow (/ l (sqrt t_m)) 2.0) (pow k 4.0)))))

C

t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
	return t_s * (2.0 * (pow((l / sqrt(t_m)), 2.0) / pow(k, 4.0)));
}

Fortran

t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: t_m
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    code = t_s * (2.0d0 * (((l / sqrt(t_m)) ** 2.0d0) / (k ** 4.0d0)))
end function

Java

t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
	return t_s * (2.0 * (Math.pow((l / Math.sqrt(t_m)), 2.0) / Math.pow(k, 4.0)));
}

Python

t_m = math.fabs(t)
t_s = math.copysign(1.0, t)
def code(t_s, t_m, l, k):
	return t_s * (2.0 * (math.pow((l / math.sqrt(t_m)), 2.0) / math.pow(k, 4.0)))

Julia

t_m = abs(t)
t_s = copysign(1.0, t)
function code(t_s, t_m, l, k)
	return Float64(t_s * Float64(2.0 * Float64((Float64(l / sqrt(t_m)) ^ 2.0) / (k ^ 4.0))))
end

MATLAB

t_m = abs(t);
t_s = sign(t) * abs(1.0);
function tmp = code(t_s, t_m, l, k)
	tmp = t_s * (2.0 * (((l / sqrt(t_m)) ^ 2.0) / (k ^ 4.0)));
end

Wolfram

t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * N[(2.0 * N[(N[Power[N[(l / N[Sqrt[t$95$m], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 10: 67.4% accurate, 1.4× speedup

Math

\[\begin{array}{l} t_m = \left|t\right| \\ t_s = \mathsf{copysign}\left(1, t\right) \\ t_s \cdot \left(2 \cdot {\left(\frac{\ell}{\sqrt{t_m \cdot {k}^{4}}}\right)}^{2}\right) \end{array} \]

FPCore

t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
 :precision binary64
 (* t_s (* 2.0 (pow (/ l (sqrt (* t_m (pow k 4.0)))) 2.0))))

C

t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
	return t_s * (2.0 * pow((l / sqrt((t_m * pow(k, 4.0)))), 2.0));
}

Fortran

t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: t_m
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    code = t_s * (2.0d0 * ((l / sqrt((t_m * (k ** 4.0d0)))) ** 2.0d0))
end function

Java

t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
	return t_s * (2.0 * Math.pow((l / Math.sqrt((t_m * Math.pow(k, 4.0)))), 2.0));
}

Python

t_m = math.fabs(t)
t_s = math.copysign(1.0, t)
def code(t_s, t_m, l, k):
	return t_s * (2.0 * math.pow((l / math.sqrt((t_m * math.pow(k, 4.0)))), 2.0))

Julia

t_m = abs(t)
t_s = copysign(1.0, t)
function code(t_s, t_m, l, k)
	return Float64(t_s * Float64(2.0 * (Float64(l / sqrt(Float64(t_m * (k ^ 4.0)))) ^ 2.0)))
end

MATLAB

t_m = abs(t);
t_s = sign(t) * abs(1.0);
function tmp = code(t_s, t_m, l, k)
	tmp = t_s * (2.0 * ((l / sqrt((t_m * (k ^ 4.0)))) ^ 2.0));
end

Wolfram

t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * N[(2.0 * N[Power[N[(l / N[Sqrt[N[(t$95$m * N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 11: 63.8% accurate, 3.8× speedup

Math

\[\begin{array}{l} t_m = \left|t\right| \\ t_s = \mathsf{copysign}\left(1, t\right) \\ t_s \cdot \left(2 \cdot \frac{\ell \cdot \frac{1}{\frac{t_m}{\ell}}}{{k}^{4}}\right) \end{array} \]

FPCore

t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
 :precision binary64
 (* t_s (* 2.0 (/ (* l (/ 1.0 (/ t_m l))) (pow k 4.0)))))

C

t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
	return t_s * (2.0 * ((l * (1.0 / (t_m / l))) / pow(k, 4.0)));
}

Fortran

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

Java

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

Python

t_m = math.fabs(t)
t_s = math.copysign(1.0, t)
def code(t_s, t_m, l, k):
	return t_s * (2.0 * ((l * (1.0 / (t_m / l))) / math.pow(k, 4.0)))

Julia

t_m = abs(t)
t_s = copysign(1.0, t)
function code(t_s, t_m, l, k)
	return Float64(t_s * Float64(2.0 * Float64(Float64(l * Float64(1.0 / Float64(t_m / l))) / (k ^ 4.0))))
end

MATLAB

t_m = abs(t);
t_s = sign(t) * abs(1.0);
function tmp = code(t_s, t_m, l, k)
	tmp = t_s * (2.0 * ((l * (1.0 / (t_m / l))) / (k ^ 4.0)));
end

Wolfram

t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * N[(2.0 * N[(N[(l * N[(1.0 / N[(t$95$m / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Alternative 12: 63.8% accurate, 3.8× speedup

Math

\[\begin{array}{l} t_m = \left|t\right| \\ t_s = \mathsf{copysign}\left(1, t\right) \\ t_s \cdot \left(2 \cdot \left(\left(\ell \cdot \frac{\ell}{t_m}\right) \cdot {k}^{-4}\right)\right) \end{array} \]

FPCore

t_m = (fabs.f64 t)
t_s = (copysign.f64 1 t)
(FPCore (t_s t_m l k)
 :precision binary64
 (* t_s (* 2.0 (* (* l (/ l t_m)) (pow k -4.0)))))

C

t_m = fabs(t);
t_s = copysign(1.0, t);
double code(double t_s, double t_m, double l, double k) {
	return t_s * (2.0 * ((l * (l / t_m)) * pow(k, -4.0)));
}

Fortran

t_m = abs(t)
t_s = copysign(1.0d0, t)
real(8) function code(t_s, t_m, l, k)
    real(8), intent (in) :: t_s
    real(8), intent (in) :: t_m
    real(8), intent (in) :: l
    real(8), intent (in) :: k
    code = t_s * (2.0d0 * ((l * (l / t_m)) * (k ** (-4.0d0))))
end function

Java

t_m = Math.abs(t);
t_s = Math.copySign(1.0, t);
public static double code(double t_s, double t_m, double l, double k) {
	return t_s * (2.0 * ((l * (l / t_m)) * Math.pow(k, -4.0)));
}

Python

t_m = math.fabs(t)
t_s = math.copysign(1.0, t)
def code(t_s, t_m, l, k):
	return t_s * (2.0 * ((l * (l / t_m)) * math.pow(k, -4.0)))

Julia

t_m = abs(t)
t_s = copysign(1.0, t)
function code(t_s, t_m, l, k)
	return Float64(t_s * Float64(2.0 * Float64(Float64(l * Float64(l / t_m)) * (k ^ -4.0))))
end

MATLAB

t_m = abs(t);
t_s = sign(t) * abs(1.0);
function tmp = code(t_s, t_m, l, k)
	tmp = t_s * (2.0 * ((l * (l / t_m)) * (k ^ -4.0)));
end

Wolfram

t_m = N[Abs[t], $MachinePrecision]
t_s = N[With[{TMP1 = Abs[1.0], TMP2 = Sign[t]}, TMP1 * If[TMP2 == 0, 1, TMP2]], $MachinePrecision]
code[t$95$s_, t$95$m_, l_, k_] := N[(t$95$s * N[(2.0 * N[(N[(l * N[(l / t$95$m), $MachinePrecision]), $MachinePrecision] * N[Power[k, -4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]

Derivation

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

Reproduce

herbie shell --seed 2023340 
(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))))