
(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))))
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));
}
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
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));
}
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))
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
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
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]
\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}
Sampling outcomes in binary64 precision:
Herbie found 9 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(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))))
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));
}
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
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));
}
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))
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
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
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]
\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}
NOTE: k should be positive before calling this function
(FPCore (t l k)
:precision binary64
(let* ((t_1 (/ l (tan k))) (t_2 (/ l (sin k))))
(if (<= k 5e-22)
(* (/ 2.0 k) (* (/ t_2 t) (/ (/ l k) k)))
(if (<= k 1.3e+149)
(* (/ l (* (sin k) t)) (* (/ 2.0 k) (/ t_1 k)))
(if (<= k 1.9e+184)
(* t_1 (* t_2 (/ 2.0 (* k (* k t)))))
(* (/ 2.0 k) (* (/ l k) (/ (/ (/ l t) (sin k)) (tan k)))))))))k = abs(k);
double code(double t, double l, double k) {
double t_1 = l / tan(k);
double t_2 = l / sin(k);
double tmp;
if (k <= 5e-22) {
tmp = (2.0 / k) * ((t_2 / t) * ((l / k) / k));
} else if (k <= 1.3e+149) {
tmp = (l / (sin(k) * t)) * ((2.0 / k) * (t_1 / k));
} else if (k <= 1.9e+184) {
tmp = t_1 * (t_2 * (2.0 / (k * (k * t))));
} else {
tmp = (2.0 / k) * ((l / k) * (((l / t) / sin(k)) / tan(k)));
}
return tmp;
}
NOTE: k should be positive before calling this function
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = l / tan(k)
t_2 = l / sin(k)
if (k <= 5d-22) then
tmp = (2.0d0 / k) * ((t_2 / t) * ((l / k) / k))
else if (k <= 1.3d+149) then
tmp = (l / (sin(k) * t)) * ((2.0d0 / k) * (t_1 / k))
else if (k <= 1.9d+184) then
tmp = t_1 * (t_2 * (2.0d0 / (k * (k * t))))
else
tmp = (2.0d0 / k) * ((l / k) * (((l / t) / sin(k)) / tan(k)))
end if
code = tmp
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
double t_1 = l / Math.tan(k);
double t_2 = l / Math.sin(k);
double tmp;
if (k <= 5e-22) {
tmp = (2.0 / k) * ((t_2 / t) * ((l / k) / k));
} else if (k <= 1.3e+149) {
tmp = (l / (Math.sin(k) * t)) * ((2.0 / k) * (t_1 / k));
} else if (k <= 1.9e+184) {
tmp = t_1 * (t_2 * (2.0 / (k * (k * t))));
} else {
tmp = (2.0 / k) * ((l / k) * (((l / t) / Math.sin(k)) / Math.tan(k)));
}
return tmp;
}
k = abs(k) def code(t, l, k): t_1 = l / math.tan(k) t_2 = l / math.sin(k) tmp = 0 if k <= 5e-22: tmp = (2.0 / k) * ((t_2 / t) * ((l / k) / k)) elif k <= 1.3e+149: tmp = (l / (math.sin(k) * t)) * ((2.0 / k) * (t_1 / k)) elif k <= 1.9e+184: tmp = t_1 * (t_2 * (2.0 / (k * (k * t)))) else: tmp = (2.0 / k) * ((l / k) * (((l / t) / math.sin(k)) / math.tan(k))) return tmp
k = abs(k) function code(t, l, k) t_1 = Float64(l / tan(k)) t_2 = Float64(l / sin(k)) tmp = 0.0 if (k <= 5e-22) tmp = Float64(Float64(2.0 / k) * Float64(Float64(t_2 / t) * Float64(Float64(l / k) / k))); elseif (k <= 1.3e+149) tmp = Float64(Float64(l / Float64(sin(k) * t)) * Float64(Float64(2.0 / k) * Float64(t_1 / k))); elseif (k <= 1.9e+184) tmp = Float64(t_1 * Float64(t_2 * Float64(2.0 / Float64(k * Float64(k * t))))); else tmp = Float64(Float64(2.0 / k) * Float64(Float64(l / k) * Float64(Float64(Float64(l / t) / sin(k)) / tan(k)))); end return tmp end
k = abs(k) function tmp_2 = code(t, l, k) t_1 = l / tan(k); t_2 = l / sin(k); tmp = 0.0; if (k <= 5e-22) tmp = (2.0 / k) * ((t_2 / t) * ((l / k) / k)); elseif (k <= 1.3e+149) tmp = (l / (sin(k) * t)) * ((2.0 / k) * (t_1 / k)); elseif (k <= 1.9e+184) tmp = t_1 * (t_2 * (2.0 / (k * (k * t)))); else tmp = (2.0 / k) * ((l / k) * (((l / t) / sin(k)) / tan(k))); end tmp_2 = tmp; end
NOTE: k should be positive before calling this function
code[t_, l_, k_] := Block[{t$95$1 = N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, 5e-22], N[(N[(2.0 / k), $MachinePrecision] * N[(N[(t$95$2 / t), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 1.3e+149], N[(N[(l / N[(N[Sin[k], $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 / k), $MachinePrecision] * N[(t$95$1 / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 1.9e+184], N[(t$95$1 * N[(t$95$2 * N[(2.0 / N[(k * N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 / k), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] * N[(N[(N[(l / t), $MachinePrecision] / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]]
\begin{array}{l}
k = |k|\\
\\
\begin{array}{l}
t_1 := \frac{\ell}{\tan k}\\
t_2 := \frac{\ell}{\sin k}\\
\mathbf{if}\;k \leq 5 \cdot 10^{-22}:\\
\;\;\;\;\frac{2}{k} \cdot \left(\frac{t_2}{t} \cdot \frac{\frac{\ell}{k}}{k}\right)\\
\mathbf{elif}\;k \leq 1.3 \cdot 10^{+149}:\\
\;\;\;\;\frac{\ell}{\sin k \cdot t} \cdot \left(\frac{2}{k} \cdot \frac{t_1}{k}\right)\\
\mathbf{elif}\;k \leq 1.9 \cdot 10^{+184}:\\
\;\;\;\;t_1 \cdot \left(t_2 \cdot \frac{2}{k \cdot \left(k \cdot t\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{k} \cdot \left(\frac{\ell}{k} \cdot \frac{\frac{\frac{\ell}{t}}{\sin k}}{\tan k}\right)\\
\end{array}
\end{array}
if k < 4.99999999999999954e-22Initial program 42.2%
associate-*l*42.2%
associate-*l*42.2%
associate-/r*42.0%
associate-/r/42.0%
*-commutative42.0%
times-frac43.7%
+-commutative43.7%
associate--l+47.1%
metadata-eval47.1%
+-rgt-identity47.1%
times-frac53.2%
Simplified53.2%
Taylor expanded in t around 0 83.1%
unpow283.1%
Simplified83.1%
associate-*l/83.1%
associate-*l*87.5%
Applied egg-rr87.5%
times-frac91.1%
*-commutative91.1%
times-frac96.1%
Simplified96.1%
Taylor expanded in k around 0 78.2%
unpow278.2%
associate-/r*82.4%
Simplified82.4%
if 4.99999999999999954e-22 < k < 1.29999999999999989e149Initial program 28.4%
associate-*l*28.4%
associate-*l*28.4%
associate-/r*28.4%
associate-/r/28.4%
*-commutative28.4%
times-frac31.0%
+-commutative31.0%
associate--l+41.7%
metadata-eval41.7%
+-rgt-identity41.7%
times-frac41.7%
Simplified41.7%
Taylor expanded in t around 0 86.4%
unpow286.4%
Simplified86.4%
associate-*l/86.5%
associate-*l*86.5%
Applied egg-rr86.5%
times-frac84.1%
*-commutative84.1%
frac-times92.1%
associate-*r*97.2%
associate-/l/97.2%
Applied egg-rr97.2%
if 1.29999999999999989e149 < k < 1.9000000000000001e184Initial program 40.0%
associate-*l*40.0%
associate-*l*40.0%
associate-/r*40.0%
associate-/r/40.0%
*-commutative40.0%
times-frac40.0%
+-commutative40.0%
associate--l+60.0%
metadata-eval60.0%
+-rgt-identity60.0%
times-frac60.0%
Simplified60.0%
Taylor expanded in t around 0 71.1%
unpow271.1%
Simplified71.1%
associate-*l/71.1%
associate-*l*91.0%
Applied egg-rr91.0%
associate-*l/90.8%
associate-*r*99.7%
Simplified99.7%
if 1.9000000000000001e184 < k Initial program 26.7%
associate-*l*26.7%
associate-*l*26.7%
associate-/r*26.7%
associate-/r/26.6%
*-commutative26.6%
times-frac23.7%
+-commutative23.7%
associate--l+40.4%
metadata-eval40.4%
+-rgt-identity40.4%
times-frac40.4%
Simplified40.4%
Taylor expanded in t around 0 56.8%
unpow256.8%
Simplified56.8%
associate-*l/56.8%
associate-*l*63.2%
Applied egg-rr63.2%
times-frac80.1%
*-commutative80.1%
times-frac90.0%
Simplified90.0%
div-inv90.0%
Applied egg-rr90.0%
associate-*l/90.1%
associate-*r/90.2%
*-rgt-identity90.2%
Simplified90.2%
expm1-log1p-u69.8%
expm1-udef62.6%
associate-/l/62.6%
associate-/l/62.6%
Applied egg-rr62.6%
expm1-def69.9%
expm1-log1p90.1%
associate-*l/73.9%
*-commutative73.9%
times-frac90.2%
associate-/r*90.2%
Simplified90.2%
Final simplification86.1%
NOTE: k should be positive before calling this function
(FPCore (t l k)
:precision binary64
(let* ((t_1 (/ l (tan k))) (t_2 (/ l (sin k))))
(if (<= k 5e-22)
(* (/ 2.0 k) (* (/ t_2 t) (/ (/ l k) k)))
(if (<= k 2.2e+149)
(* (/ l (* (sin k) t)) (* (/ 2.0 k) (/ t_1 k)))
(* t_1 (* t_2 (/ 2.0 (* k (* k t)))))))))k = abs(k);
double code(double t, double l, double k) {
double t_1 = l / tan(k);
double t_2 = l / sin(k);
double tmp;
if (k <= 5e-22) {
tmp = (2.0 / k) * ((t_2 / t) * ((l / k) / k));
} else if (k <= 2.2e+149) {
tmp = (l / (sin(k) * t)) * ((2.0 / k) * (t_1 / k));
} else {
tmp = t_1 * (t_2 * (2.0 / (k * (k * t))));
}
return tmp;
}
NOTE: k should be positive before calling this function
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: t_1
real(8) :: t_2
real(8) :: tmp
t_1 = l / tan(k)
t_2 = l / sin(k)
if (k <= 5d-22) then
tmp = (2.0d0 / k) * ((t_2 / t) * ((l / k) / k))
else if (k <= 2.2d+149) then
tmp = (l / (sin(k) * t)) * ((2.0d0 / k) * (t_1 / k))
else
tmp = t_1 * (t_2 * (2.0d0 / (k * (k * t))))
end if
code = tmp
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
double t_1 = l / Math.tan(k);
double t_2 = l / Math.sin(k);
double tmp;
if (k <= 5e-22) {
tmp = (2.0 / k) * ((t_2 / t) * ((l / k) / k));
} else if (k <= 2.2e+149) {
tmp = (l / (Math.sin(k) * t)) * ((2.0 / k) * (t_1 / k));
} else {
tmp = t_1 * (t_2 * (2.0 / (k * (k * t))));
}
return tmp;
}
k = abs(k) def code(t, l, k): t_1 = l / math.tan(k) t_2 = l / math.sin(k) tmp = 0 if k <= 5e-22: tmp = (2.0 / k) * ((t_2 / t) * ((l / k) / k)) elif k <= 2.2e+149: tmp = (l / (math.sin(k) * t)) * ((2.0 / k) * (t_1 / k)) else: tmp = t_1 * (t_2 * (2.0 / (k * (k * t)))) return tmp
k = abs(k) function code(t, l, k) t_1 = Float64(l / tan(k)) t_2 = Float64(l / sin(k)) tmp = 0.0 if (k <= 5e-22) tmp = Float64(Float64(2.0 / k) * Float64(Float64(t_2 / t) * Float64(Float64(l / k) / k))); elseif (k <= 2.2e+149) tmp = Float64(Float64(l / Float64(sin(k) * t)) * Float64(Float64(2.0 / k) * Float64(t_1 / k))); else tmp = Float64(t_1 * Float64(t_2 * Float64(2.0 / Float64(k * Float64(k * t))))); end return tmp end
k = abs(k) function tmp_2 = code(t, l, k) t_1 = l / tan(k); t_2 = l / sin(k); tmp = 0.0; if (k <= 5e-22) tmp = (2.0 / k) * ((t_2 / t) * ((l / k) / k)); elseif (k <= 2.2e+149) tmp = (l / (sin(k) * t)) * ((2.0 / k) * (t_1 / k)); else tmp = t_1 * (t_2 * (2.0 / (k * (k * t)))); end tmp_2 = tmp; end
NOTE: k should be positive before calling this function
code[t_, l_, k_] := Block[{t$95$1 = N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, 5e-22], N[(N[(2.0 / k), $MachinePrecision] * N[(N[(t$95$2 / t), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 2.2e+149], N[(N[(l / N[(N[Sin[k], $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 / k), $MachinePrecision] * N[(t$95$1 / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[(t$95$2 * N[(2.0 / N[(k * N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]]
\begin{array}{l}
k = |k|\\
\\
\begin{array}{l}
t_1 := \frac{\ell}{\tan k}\\
t_2 := \frac{\ell}{\sin k}\\
\mathbf{if}\;k \leq 5 \cdot 10^{-22}:\\
\;\;\;\;\frac{2}{k} \cdot \left(\frac{t_2}{t} \cdot \frac{\frac{\ell}{k}}{k}\right)\\
\mathbf{elif}\;k \leq 2.2 \cdot 10^{+149}:\\
\;\;\;\;\frac{\ell}{\sin k \cdot t} \cdot \left(\frac{2}{k} \cdot \frac{t_1}{k}\right)\\
\mathbf{else}:\\
\;\;\;\;t_1 \cdot \left(t_2 \cdot \frac{2}{k \cdot \left(k \cdot t\right)}\right)\\
\end{array}
\end{array}
if k < 4.99999999999999954e-22Initial program 42.2%
associate-*l*42.2%
associate-*l*42.2%
associate-/r*42.0%
associate-/r/42.0%
*-commutative42.0%
times-frac43.7%
+-commutative43.7%
associate--l+47.1%
metadata-eval47.1%
+-rgt-identity47.1%
times-frac53.2%
Simplified53.2%
Taylor expanded in t around 0 83.1%
unpow283.1%
Simplified83.1%
associate-*l/83.1%
associate-*l*87.5%
Applied egg-rr87.5%
times-frac91.1%
*-commutative91.1%
times-frac96.1%
Simplified96.1%
Taylor expanded in k around 0 78.2%
unpow278.2%
associate-/r*82.4%
Simplified82.4%
if 4.99999999999999954e-22 < k < 2.2e149Initial program 28.4%
associate-*l*28.4%
associate-*l*28.4%
associate-/r*28.4%
associate-/r/28.4%
*-commutative28.4%
times-frac31.0%
+-commutative31.0%
associate--l+41.7%
metadata-eval41.7%
+-rgt-identity41.7%
times-frac41.7%
Simplified41.7%
Taylor expanded in t around 0 86.4%
unpow286.4%
Simplified86.4%
associate-*l/86.5%
associate-*l*86.5%
Applied egg-rr86.5%
times-frac84.1%
*-commutative84.1%
frac-times92.1%
associate-*r*97.2%
associate-/l/97.2%
Applied egg-rr97.2%
if 2.2e149 < k Initial program 30.0%
associate-*l*30.0%
associate-*l*30.0%
associate-/r*30.0%
associate-/r/30.0%
*-commutative30.0%
times-frac27.8%
+-commutative27.8%
associate--l+45.3%
metadata-eval45.3%
+-rgt-identity45.3%
times-frac45.3%
Simplified45.3%
Taylor expanded in t around 0 60.4%
unpow260.4%
Simplified60.4%
associate-*l/60.4%
associate-*l*70.2%
Applied egg-rr70.2%
associate-*l/70.1%
associate-*r*77.7%
Simplified77.7%
Final simplification83.8%
NOTE: k should be positive before calling this function (FPCore (t l k) :precision binary64 (if (<= (* l l) 0.0) (* (/ 2.0 k) (* (/ (/ l (sin k)) t) (/ (/ l k) k))) (* (/ 2.0 k) (* (/ l (* k (tan k))) (/ l (* (sin k) t))))))
k = abs(k);
double code(double t, double l, double k) {
double tmp;
if ((l * l) <= 0.0) {
tmp = (2.0 / k) * (((l / sin(k)) / t) * ((l / k) / k));
} else {
tmp = (2.0 / k) * ((l / (k * tan(k))) * (l / (sin(k) * t)));
}
return tmp;
}
NOTE: k should be positive before calling this function
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if ((l * l) <= 0.0d0) then
tmp = (2.0d0 / k) * (((l / sin(k)) / t) * ((l / k) / k))
else
tmp = (2.0d0 / k) * ((l / (k * tan(k))) * (l / (sin(k) * t)))
end if
code = tmp
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
double tmp;
if ((l * l) <= 0.0) {
tmp = (2.0 / k) * (((l / Math.sin(k)) / t) * ((l / k) / k));
} else {
tmp = (2.0 / k) * ((l / (k * Math.tan(k))) * (l / (Math.sin(k) * t)));
}
return tmp;
}
k = abs(k) def code(t, l, k): tmp = 0 if (l * l) <= 0.0: tmp = (2.0 / k) * (((l / math.sin(k)) / t) * ((l / k) / k)) else: tmp = (2.0 / k) * ((l / (k * math.tan(k))) * (l / (math.sin(k) * t))) return tmp
k = abs(k) function code(t, l, k) tmp = 0.0 if (Float64(l * l) <= 0.0) tmp = Float64(Float64(2.0 / k) * Float64(Float64(Float64(l / sin(k)) / t) * Float64(Float64(l / k) / k))); else tmp = Float64(Float64(2.0 / k) * Float64(Float64(l / Float64(k * tan(k))) * Float64(l / Float64(sin(k) * t)))); end return tmp end
k = abs(k) function tmp_2 = code(t, l, k) tmp = 0.0; if ((l * l) <= 0.0) tmp = (2.0 / k) * (((l / sin(k)) / t) * ((l / k) / k)); else tmp = (2.0 / k) * ((l / (k * tan(k))) * (l / (sin(k) * t))); end tmp_2 = tmp; end
NOTE: k should be positive before calling this function code[t_, l_, k_] := If[LessEqual[N[(l * l), $MachinePrecision], 0.0], N[(N[(2.0 / k), $MachinePrecision] * N[(N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 / k), $MachinePrecision] * N[(N[(l / N[(k * N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(l / N[(N[Sin[k], $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k = |k|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \cdot \ell \leq 0:\\
\;\;\;\;\frac{2}{k} \cdot \left(\frac{\frac{\ell}{\sin k}}{t} \cdot \frac{\frac{\ell}{k}}{k}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{k} \cdot \left(\frac{\ell}{k \cdot \tan k} \cdot \frac{\ell}{\sin k \cdot t}\right)\\
\end{array}
\end{array}
if (*.f64 l l) < 0.0Initial program 28.9%
associate-*l*28.9%
associate-*l*28.9%
associate-/r*28.9%
associate-/r/28.8%
*-commutative28.8%
times-frac28.8%
+-commutative28.8%
associate--l+41.0%
metadata-eval41.0%
+-rgt-identity41.0%
times-frac57.9%
Simplified57.9%
Taylor expanded in t around 0 83.5%
unpow283.5%
Simplified83.5%
associate-*l/83.5%
associate-*l*89.4%
Applied egg-rr89.4%
times-frac90.8%
*-commutative90.8%
times-frac95.5%
Simplified95.5%
Taylor expanded in k around 0 88.4%
unpow288.4%
associate-/r*95.5%
Simplified95.5%
if 0.0 < (*.f64 l l) Initial program 41.6%
associate-*l*41.6%
associate-*l*41.6%
associate-/r*41.5%
associate-/r/41.5%
*-commutative41.5%
times-frac43.1%
+-commutative43.1%
associate--l+47.8%
metadata-eval47.8%
+-rgt-identity47.8%
times-frac47.8%
Simplified47.8%
Taylor expanded in t around 0 78.8%
unpow278.8%
Simplified78.8%
associate-*l/78.8%
associate-*l*83.0%
Applied egg-rr83.0%
times-frac88.2%
*-commutative88.2%
times-frac94.3%
Simplified94.3%
frac-times88.2%
Applied egg-rr88.2%
times-frac94.3%
associate-/l/94.3%
associate-/r*94.3%
*-commutative94.3%
Simplified94.3%
Final simplification94.6%
NOTE: k should be positive before calling this function (FPCore (t l k) :precision binary64 (if (<= k 3.8e-21) (* (/ 2.0 k) (* (/ (/ l (sin k)) t) (/ (/ l k) k))) (* (/ l (* (sin k) t)) (* (/ 2.0 k) (/ (/ l (tan k)) k)))))
k = abs(k);
double code(double t, double l, double k) {
double tmp;
if (k <= 3.8e-21) {
tmp = (2.0 / k) * (((l / sin(k)) / t) * ((l / k) / k));
} else {
tmp = (l / (sin(k) * t)) * ((2.0 / k) * ((l / tan(k)) / k));
}
return tmp;
}
NOTE: k should be positive before calling this function
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (k <= 3.8d-21) then
tmp = (2.0d0 / k) * (((l / sin(k)) / t) * ((l / k) / k))
else
tmp = (l / (sin(k) * t)) * ((2.0d0 / k) * ((l / tan(k)) / k))
end if
code = tmp
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
double tmp;
if (k <= 3.8e-21) {
tmp = (2.0 / k) * (((l / Math.sin(k)) / t) * ((l / k) / k));
} else {
tmp = (l / (Math.sin(k) * t)) * ((2.0 / k) * ((l / Math.tan(k)) / k));
}
return tmp;
}
k = abs(k) def code(t, l, k): tmp = 0 if k <= 3.8e-21: tmp = (2.0 / k) * (((l / math.sin(k)) / t) * ((l / k) / k)) else: tmp = (l / (math.sin(k) * t)) * ((2.0 / k) * ((l / math.tan(k)) / k)) return tmp
k = abs(k) function code(t, l, k) tmp = 0.0 if (k <= 3.8e-21) tmp = Float64(Float64(2.0 / k) * Float64(Float64(Float64(l / sin(k)) / t) * Float64(Float64(l / k) / k))); else tmp = Float64(Float64(l / Float64(sin(k) * t)) * Float64(Float64(2.0 / k) * Float64(Float64(l / tan(k)) / k))); end return tmp end
k = abs(k) function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 3.8e-21) tmp = (2.0 / k) * (((l / sin(k)) / t) * ((l / k) / k)); else tmp = (l / (sin(k) * t)) * ((2.0 / k) * ((l / tan(k)) / k)); end tmp_2 = tmp; end
NOTE: k should be positive before calling this function code[t_, l_, k_] := If[LessEqual[k, 3.8e-21], N[(N[(2.0 / k), $MachinePrecision] * N[(N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(l / N[(N[Sin[k], $MachinePrecision] * t), $MachinePrecision]), $MachinePrecision] * N[(N[(2.0 / k), $MachinePrecision] * N[(N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k = |k|\\
\\
\begin{array}{l}
\mathbf{if}\;k \leq 3.8 \cdot 10^{-21}:\\
\;\;\;\;\frac{2}{k} \cdot \left(\frac{\frac{\ell}{\sin k}}{t} \cdot \frac{\frac{\ell}{k}}{k}\right)\\
\mathbf{else}:\\
\;\;\;\;\frac{\ell}{\sin k \cdot t} \cdot \left(\frac{2}{k} \cdot \frac{\frac{\ell}{\tan k}}{k}\right)\\
\end{array}
\end{array}
if k < 3.7999999999999998e-21Initial program 42.2%
associate-*l*42.2%
associate-*l*42.2%
associate-/r*42.0%
associate-/r/42.0%
*-commutative42.0%
times-frac43.7%
+-commutative43.7%
associate--l+47.1%
metadata-eval47.1%
+-rgt-identity47.1%
times-frac53.2%
Simplified53.2%
Taylor expanded in t around 0 83.1%
unpow283.1%
Simplified83.1%
associate-*l/83.1%
associate-*l*87.5%
Applied egg-rr87.5%
times-frac91.1%
*-commutative91.1%
times-frac96.1%
Simplified96.1%
Taylor expanded in k around 0 78.2%
unpow278.2%
associate-/r*82.4%
Simplified82.4%
if 3.7999999999999998e-21 < k Initial program 29.2%
associate-*l*29.2%
associate-*l*29.2%
associate-/r*29.2%
associate-/r/29.2%
*-commutative29.2%
times-frac29.3%
+-commutative29.3%
associate--l+43.6%
metadata-eval43.6%
+-rgt-identity43.6%
times-frac43.6%
Simplified43.6%
Taylor expanded in t around 0 72.7%
unpow272.7%
Simplified72.7%
associate-*l/72.7%
associate-*l*77.9%
Applied egg-rr77.9%
times-frac83.4%
*-commutative83.4%
frac-times91.1%
associate-*r*84.0%
associate-/l/84.0%
Applied egg-rr84.0%
Final simplification82.9%
NOTE: k should be positive before calling this function (FPCore (t l k) :precision binary64 (* (/ 2.0 k) (* (/ (/ l k) (tan k)) (/ (/ l (sin k)) t))))
k = abs(k);
double code(double t, double l, double k) {
return (2.0 / k) * (((l / k) / tan(k)) * ((l / sin(k)) / t));
}
NOTE: k should be positive before calling this function
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 / k) * (((l / k) / tan(k)) * ((l / sin(k)) / t))
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
return (2.0 / k) * (((l / k) / Math.tan(k)) * ((l / Math.sin(k)) / t));
}
k = abs(k) def code(t, l, k): return (2.0 / k) * (((l / k) / math.tan(k)) * ((l / math.sin(k)) / t))
k = abs(k) function code(t, l, k) return Float64(Float64(2.0 / k) * Float64(Float64(Float64(l / k) / tan(k)) * Float64(Float64(l / sin(k)) / t))) end
k = abs(k) function tmp = code(t, l, k) tmp = (2.0 / k) * (((l / k) / tan(k)) * ((l / sin(k)) / t)); end
NOTE: k should be positive before calling this function code[t_, l_, k_] := N[(N[(2.0 / k), $MachinePrecision] * N[(N[(N[(l / k), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k = |k|\\
\\
\frac{2}{k} \cdot \left(\frac{\frac{\ell}{k}}{\tan k} \cdot \frac{\frac{\ell}{\sin k}}{t}\right)
\end{array}
Initial program 38.4%
associate-*l*38.4%
associate-*l*38.3%
associate-/r*38.2%
associate-/r/38.2%
*-commutative38.2%
times-frac39.4%
+-commutative39.4%
associate--l+46.0%
metadata-eval46.0%
+-rgt-identity46.0%
times-frac50.4%
Simplified50.4%
Taylor expanded in t around 0 80.0%
unpow280.0%
Simplified80.0%
associate-*l/80.0%
associate-*l*84.7%
Applied egg-rr84.7%
times-frac88.8%
*-commutative88.8%
times-frac94.6%
Simplified94.6%
div-inv94.5%
Applied egg-rr94.5%
associate-*l/94.5%
associate-*r/94.6%
*-rgt-identity94.6%
Simplified94.6%
Final simplification94.6%
NOTE: k should be positive before calling this function (FPCore (t l k) :precision binary64 (if (<= k 2.2e-155) (/ (/ (* 2.0 l) (/ k (/ l k))) (* k (* k t))) (* (/ 2.0 k) (* (/ (/ l (sin k)) t) (/ l (* k k))))))
k = abs(k);
double code(double t, double l, double k) {
double tmp;
if (k <= 2.2e-155) {
tmp = ((2.0 * l) / (k / (l / k))) / (k * (k * t));
} else {
tmp = (2.0 / k) * (((l / sin(k)) / t) * (l / (k * k)));
}
return tmp;
}
NOTE: k should be positive before calling this function
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
real(8) :: tmp
if (k <= 2.2d-155) then
tmp = ((2.0d0 * l) / (k / (l / k))) / (k * (k * t))
else
tmp = (2.0d0 / k) * (((l / sin(k)) / t) * (l / (k * k)))
end if
code = tmp
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
double tmp;
if (k <= 2.2e-155) {
tmp = ((2.0 * l) / (k / (l / k))) / (k * (k * t));
} else {
tmp = (2.0 / k) * (((l / Math.sin(k)) / t) * (l / (k * k)));
}
return tmp;
}
k = abs(k) def code(t, l, k): tmp = 0 if k <= 2.2e-155: tmp = ((2.0 * l) / (k / (l / k))) / (k * (k * t)) else: tmp = (2.0 / k) * (((l / math.sin(k)) / t) * (l / (k * k))) return tmp
k = abs(k) function code(t, l, k) tmp = 0.0 if (k <= 2.2e-155) tmp = Float64(Float64(Float64(2.0 * l) / Float64(k / Float64(l / k))) / Float64(k * Float64(k * t))); else tmp = Float64(Float64(2.0 / k) * Float64(Float64(Float64(l / sin(k)) / t) * Float64(l / Float64(k * k)))); end return tmp end
k = abs(k) function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 2.2e-155) tmp = ((2.0 * l) / (k / (l / k))) / (k * (k * t)); else tmp = (2.0 / k) * (((l / sin(k)) / t) * (l / (k * k))); end tmp_2 = tmp; end
NOTE: k should be positive before calling this function code[t_, l_, k_] := If[LessEqual[k, 2.2e-155], N[(N[(N[(2.0 * l), $MachinePrecision] / N[(k / N[(l / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(k * N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(2.0 / k), $MachinePrecision] * N[(N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision] * N[(l / N[(k * k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k = |k|\\
\\
\begin{array}{l}
\mathbf{if}\;k \leq 2.2 \cdot 10^{-155}:\\
\;\;\;\;\frac{\frac{2 \cdot \ell}{\frac{k}{\frac{\ell}{k}}}}{k \cdot \left(k \cdot t\right)}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{k} \cdot \left(\frac{\frac{\ell}{\sin k}}{t} \cdot \frac{\ell}{k \cdot k}\right)\\
\end{array}
\end{array}
if k < 2.1999999999999999e-155Initial program 38.8%
associate-*l*38.8%
associate-*l*38.8%
associate-/r*38.6%
associate-/r/38.6%
*-commutative38.6%
times-frac40.7%
+-commutative40.7%
associate--l+44.7%
metadata-eval44.7%
+-rgt-identity44.7%
times-frac51.5%
Simplified51.5%
Taylor expanded in t around 0 82.3%
unpow282.3%
Simplified82.3%
associate-*l/82.3%
associate-*l*87.6%
Applied egg-rr87.6%
Taylor expanded in k around 0 62.6%
unpow262.6%
unpow262.6%
Simplified62.6%
expm1-log1p-u62.5%
expm1-udef60.4%
associate-/l*68.2%
Applied egg-rr68.2%
expm1-def72.8%
expm1-log1p73.0%
associate-*r/73.0%
associate-/l*75.6%
Simplified75.6%
if 2.1999999999999999e-155 < k Initial program 37.7%
associate-*l*37.7%
associate-*l*37.7%
associate-/r*37.7%
associate-/r/37.7%
*-commutative37.7%
times-frac37.7%
+-commutative37.7%
associate--l+47.9%
metadata-eval47.9%
+-rgt-identity47.9%
times-frac48.9%
Simplified48.9%
Taylor expanded in t around 0 76.9%
unpow276.9%
Simplified76.9%
associate-*l/76.9%
associate-*l*80.6%
Applied egg-rr80.6%
times-frac85.4%
*-commutative85.4%
times-frac92.8%
Simplified92.8%
Taylor expanded in k around 0 73.0%
unpow273.0%
Simplified73.0%
Final simplification74.5%
NOTE: k should be positive before calling this function (FPCore (t l k) :precision binary64 (* (/ 2.0 k) (* (/ (/ l (sin k)) t) (/ (/ l k) k))))
k = abs(k);
double code(double t, double l, double k) {
return (2.0 / k) * (((l / sin(k)) / t) * ((l / k) / k));
}
NOTE: k should be positive before calling this function
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 / k) * (((l / sin(k)) / t) * ((l / k) / k))
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
return (2.0 / k) * (((l / Math.sin(k)) / t) * ((l / k) / k));
}
k = abs(k) def code(t, l, k): return (2.0 / k) * (((l / math.sin(k)) / t) * ((l / k) / k))
k = abs(k) function code(t, l, k) return Float64(Float64(2.0 / k) * Float64(Float64(Float64(l / sin(k)) / t) * Float64(Float64(l / k) / k))) end
k = abs(k) function tmp = code(t, l, k) tmp = (2.0 / k) * (((l / sin(k)) / t) * ((l / k) / k)); end
NOTE: k should be positive before calling this function code[t_, l_, k_] := N[(N[(2.0 / k), $MachinePrecision] * N[(N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision] * N[(N[(l / k), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k = |k|\\
\\
\frac{2}{k} \cdot \left(\frac{\frac{\ell}{\sin k}}{t} \cdot \frac{\frac{\ell}{k}}{k}\right)
\end{array}
Initial program 38.4%
associate-*l*38.4%
associate-*l*38.3%
associate-/r*38.2%
associate-/r/38.2%
*-commutative38.2%
times-frac39.4%
+-commutative39.4%
associate--l+46.0%
metadata-eval46.0%
+-rgt-identity46.0%
times-frac50.4%
Simplified50.4%
Taylor expanded in t around 0 80.0%
unpow280.0%
Simplified80.0%
associate-*l/80.0%
associate-*l*84.7%
Applied egg-rr84.7%
times-frac88.8%
*-commutative88.8%
times-frac94.6%
Simplified94.6%
Taylor expanded in k around 0 73.8%
unpow273.8%
associate-/r*76.8%
Simplified76.8%
Final simplification76.8%
NOTE: k should be positive before calling this function (FPCore (t l k) :precision binary64 (* 2.0 (/ (* l (/ (/ l k) k)) (* k (* k t)))))
k = abs(k);
double code(double t, double l, double k) {
return 2.0 * ((l * ((l / k) / k)) / (k * (k * t)));
}
NOTE: k should be positive before calling this function
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 * ((l * ((l / k) / k)) / (k * (k * t)))
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
return 2.0 * ((l * ((l / k) / k)) / (k * (k * t)));
}
k = abs(k) def code(t, l, k): return 2.0 * ((l * ((l / k) / k)) / (k * (k * t)))
k = abs(k) function code(t, l, k) return Float64(2.0 * Float64(Float64(l * Float64(Float64(l / k) / k)) / Float64(k * Float64(k * t)))) end
k = abs(k) function tmp = code(t, l, k) tmp = 2.0 * ((l * ((l / k) / k)) / (k * (k * t))); end
NOTE: k should be positive before calling this function code[t_, l_, k_] := N[(2.0 * N[(N[(l * N[(N[(l / k), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision] / N[(k * N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k = |k|\\
\\
2 \cdot \frac{\ell \cdot \frac{\frac{\ell}{k}}{k}}{k \cdot \left(k \cdot t\right)}
\end{array}
Initial program 38.4%
associate-*l*38.4%
associate-*l*38.3%
associate-/r*38.2%
associate-/r/38.2%
*-commutative38.2%
times-frac39.4%
+-commutative39.4%
associate--l+46.0%
metadata-eval46.0%
+-rgt-identity46.0%
times-frac50.4%
Simplified50.4%
Taylor expanded in t around 0 80.0%
unpow280.0%
Simplified80.0%
associate-*l/80.0%
associate-*l*84.7%
Applied egg-rr84.7%
Taylor expanded in k around 0 63.8%
unpow263.8%
unpow263.8%
Simplified63.8%
div-inv63.8%
associate-/l*70.9%
Applied egg-rr70.9%
associate-*l*70.9%
associate-*r/71.0%
*-rgt-identity71.0%
unpow271.0%
associate-/r/71.0%
unpow271.0%
associate-/r*72.5%
Simplified72.5%
Final simplification72.5%
NOTE: k should be positive before calling this function (FPCore (t l k) :precision binary64 (* (/ 2.0 k) (* (/ (/ l k) k) (/ l (* k t)))))
k = abs(k);
double code(double t, double l, double k) {
return (2.0 / k) * (((l / k) / k) * (l / (k * t)));
}
NOTE: k should be positive before calling this function
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 / k) * (((l / k) / k) * (l / (k * t)))
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
return (2.0 / k) * (((l / k) / k) * (l / (k * t)));
}
k = abs(k) def code(t, l, k): return (2.0 / k) * (((l / k) / k) * (l / (k * t)))
k = abs(k) function code(t, l, k) return Float64(Float64(2.0 / k) * Float64(Float64(Float64(l / k) / k) * Float64(l / Float64(k * t)))) end
k = abs(k) function tmp = code(t, l, k) tmp = (2.0 / k) * (((l / k) / k) * (l / (k * t))); end
NOTE: k should be positive before calling this function code[t_, l_, k_] := N[(N[(2.0 / k), $MachinePrecision] * N[(N[(N[(l / k), $MachinePrecision] / k), $MachinePrecision] * N[(l / N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k = |k|\\
\\
\frac{2}{k} \cdot \left(\frac{\frac{\ell}{k}}{k} \cdot \frac{\ell}{k \cdot t}\right)
\end{array}
Initial program 38.4%
associate-*l*38.4%
associate-*l*38.3%
associate-/r*38.2%
associate-/r/38.2%
*-commutative38.2%
times-frac39.4%
+-commutative39.4%
associate--l+46.0%
metadata-eval46.0%
+-rgt-identity46.0%
times-frac50.4%
Simplified50.4%
Taylor expanded in t around 0 80.0%
unpow280.0%
Simplified80.0%
associate-*l/80.0%
associate-*l*84.7%
Applied egg-rr84.7%
times-frac88.8%
*-commutative88.8%
times-frac94.6%
Simplified94.6%
Taylor expanded in k around 0 73.8%
unpow273.8%
associate-/r*76.8%
Simplified76.8%
Taylor expanded in k around 0 74.0%
Final simplification74.0%
herbie shell --seed 2023229
(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))))