
(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 13 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 (pow (sin k) 2.0)))
(if (<= k 1e+139)
(* 2.0 (/ (* (/ (cos k) (* k k)) l) (/ t (/ l t_1))))
(* 2.0 (/ (* (/ l k) (/ l k)) (/ t_1 (/ (cos k) t)))))))k = abs(k);
double code(double t, double l, double k) {
double t_1 = pow(sin(k), 2.0);
double tmp;
if (k <= 1e+139) {
tmp = 2.0 * (((cos(k) / (k * k)) * l) / (t / (l / t_1)));
} else {
tmp = 2.0 * (((l / k) * (l / k)) / (t_1 / (cos(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) :: tmp
t_1 = sin(k) ** 2.0d0
if (k <= 1d+139) then
tmp = 2.0d0 * (((cos(k) / (k * k)) * l) / (t / (l / t_1)))
else
tmp = 2.0d0 * (((l / k) * (l / k)) / (t_1 / (cos(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 = Math.pow(Math.sin(k), 2.0);
double tmp;
if (k <= 1e+139) {
tmp = 2.0 * (((Math.cos(k) / (k * k)) * l) / (t / (l / t_1)));
} else {
tmp = 2.0 * (((l / k) * (l / k)) / (t_1 / (Math.cos(k) / t)));
}
return tmp;
}
k = abs(k) def code(t, l, k): t_1 = math.pow(math.sin(k), 2.0) tmp = 0 if k <= 1e+139: tmp = 2.0 * (((math.cos(k) / (k * k)) * l) / (t / (l / t_1))) else: tmp = 2.0 * (((l / k) * (l / k)) / (t_1 / (math.cos(k) / t))) return tmp
k = abs(k) function code(t, l, k) t_1 = sin(k) ^ 2.0 tmp = 0.0 if (k <= 1e+139) tmp = Float64(2.0 * Float64(Float64(Float64(cos(k) / Float64(k * k)) * l) / Float64(t / Float64(l / t_1)))); else tmp = Float64(2.0 * Float64(Float64(Float64(l / k) * Float64(l / k)) / Float64(t_1 / Float64(cos(k) / t)))); end return tmp end
k = abs(k) function tmp_2 = code(t, l, k) t_1 = sin(k) ^ 2.0; tmp = 0.0; if (k <= 1e+139) tmp = 2.0 * (((cos(k) / (k * k)) * l) / (t / (l / t_1))); else tmp = 2.0 * (((l / k) * (l / k)) / (t_1 / (cos(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[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[k, 1e+139], N[(2.0 * N[(N[(N[(N[Cos[k], $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision] * l), $MachinePrecision] / N[(t / N[(l / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(l / k), $MachinePrecision] * N[(l / k), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 / N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
k = |k|\\
\\
\begin{array}{l}
t_1 := {\sin k}^{2}\\
\mathbf{if}\;k \leq 10^{+139}:\\
\;\;\;\;2 \cdot \frac{\frac{\cos k}{k \cdot k} \cdot \ell}{\frac{t}{\frac{\ell}{t_1}}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{\frac{\ell}{k} \cdot \frac{\ell}{k}}{\frac{t_1}{\frac{\cos k}{t}}}\\
\end{array}
\end{array}
if k < 1.00000000000000003e139Initial program 36.9%
associate-*l*36.9%
associate-*l*37.3%
associate-/r*37.3%
associate-/r/37.8%
*-commutative37.8%
times-frac39.1%
+-commutative39.1%
associate--l+47.4%
metadata-eval47.4%
+-rgt-identity47.4%
times-frac52.9%
Simplified52.9%
Taylor expanded in t around 0 73.6%
unpow273.6%
times-frac74.5%
unpow274.5%
associate-/l*87.2%
*-commutative87.2%
Simplified87.2%
associate-*r/90.4%
associate-/l*92.4%
Applied egg-rr92.4%
if 1.00000000000000003e139 < k Initial program 35.7%
associate-*l*35.7%
associate-*l*35.7%
associate-/r*35.7%
associate-/r/32.5%
*-commutative32.5%
times-frac32.5%
+-commutative32.5%
associate--l+42.1%
metadata-eval42.1%
+-rgt-identity42.1%
times-frac42.1%
Simplified42.1%
Taylor expanded in t around 0 62.1%
unpow262.1%
times-frac62.1%
unpow262.1%
associate-/l*65.5%
*-commutative65.5%
Simplified65.5%
Taylor expanded in k around inf 62.1%
*-commutative62.1%
*-commutative62.1%
times-frac62.2%
unpow262.2%
unpow262.2%
times-frac96.7%
Simplified96.7%
Taylor expanded in l around 0 62.1%
associate-/r*62.2%
associate-*r/62.2%
unpow262.2%
unpow262.2%
times-frac96.7%
unpow296.7%
*-commutative96.7%
associate-/l*96.7%
associate-/l*96.8%
Simplified96.8%
unpow296.8%
Applied egg-rr96.8%
Final simplification93.0%
NOTE: k should be positive before calling this function
(FPCore (t l k)
:precision binary64
(let* ((t_1 (* t (pow (sin k) 2.0))))
(if (<= k 1.8e-73)
(*
2.0
(/
(*
(/ 1.0 k)
(+ (* (/ l k) (/ l (* k t))) (/ (* l l) (/ t 0.3333333333333333))))
k))
(if (<= k 3.8e+101)
(* 2.0 (* (/ (cos k) (* k k)) (* l (/ l t_1))))
(* 2.0 (* (* (/ l k) (/ l k)) (/ (cos k) t_1)))))))k = abs(k);
double code(double t, double l, double k) {
double t_1 = t * pow(sin(k), 2.0);
double tmp;
if (k <= 1.8e-73) {
tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k);
} else if (k <= 3.8e+101) {
tmp = 2.0 * ((cos(k) / (k * k)) * (l * (l / t_1)));
} else {
tmp = 2.0 * (((l / k) * (l / k)) * (cos(k) / t_1));
}
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) :: tmp
t_1 = t * (sin(k) ** 2.0d0)
if (k <= 1.8d-73) then
tmp = 2.0d0 * (((1.0d0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333d0)))) / k)
else if (k <= 3.8d+101) then
tmp = 2.0d0 * ((cos(k) / (k * k)) * (l * (l / t_1)))
else
tmp = 2.0d0 * (((l / k) * (l / k)) * (cos(k) / t_1))
end if
code = tmp
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
double t_1 = t * Math.pow(Math.sin(k), 2.0);
double tmp;
if (k <= 1.8e-73) {
tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k);
} else if (k <= 3.8e+101) {
tmp = 2.0 * ((Math.cos(k) / (k * k)) * (l * (l / t_1)));
} else {
tmp = 2.0 * (((l / k) * (l / k)) * (Math.cos(k) / t_1));
}
return tmp;
}
k = abs(k) def code(t, l, k): t_1 = t * math.pow(math.sin(k), 2.0) tmp = 0 if k <= 1.8e-73: tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k) elif k <= 3.8e+101: tmp = 2.0 * ((math.cos(k) / (k * k)) * (l * (l / t_1))) else: tmp = 2.0 * (((l / k) * (l / k)) * (math.cos(k) / t_1)) return tmp
k = abs(k) function code(t, l, k) t_1 = Float64(t * (sin(k) ^ 2.0)) tmp = 0.0 if (k <= 1.8e-73) tmp = Float64(2.0 * Float64(Float64(Float64(1.0 / k) * Float64(Float64(Float64(l / k) * Float64(l / Float64(k * t))) + Float64(Float64(l * l) / Float64(t / 0.3333333333333333)))) / k)); elseif (k <= 3.8e+101) tmp = Float64(2.0 * Float64(Float64(cos(k) / Float64(k * k)) * Float64(l * Float64(l / t_1)))); else tmp = Float64(2.0 * Float64(Float64(Float64(l / k) * Float64(l / k)) * Float64(cos(k) / t_1))); end return tmp end
k = abs(k) function tmp_2 = code(t, l, k) t_1 = t * (sin(k) ^ 2.0); tmp = 0.0; if (k <= 1.8e-73) tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k); elseif (k <= 3.8e+101) tmp = 2.0 * ((cos(k) / (k * k)) * (l * (l / t_1))); else tmp = 2.0 * (((l / k) * (l / k)) * (cos(k) / t_1)); end tmp_2 = tmp; end
NOTE: k should be positive before calling this function
code[t_, l_, k_] := Block[{t$95$1 = N[(t * N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, 1.8e-73], N[(2.0 * N[(N[(N[(1.0 / k), $MachinePrecision] * N[(N[(N[(l / k), $MachinePrecision] * N[(l / N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(l * l), $MachinePrecision] / N[(t / 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision], If[LessEqual[k, 3.8e+101], N[(2.0 * N[(N[(N[Cos[k], $MachinePrecision] / N[(k * k), $MachinePrecision]), $MachinePrecision] * N[(l * N[(l / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(l / k), $MachinePrecision] * N[(l / k), $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
k = |k|\\
\\
\begin{array}{l}
t_1 := t \cdot {\sin k}^{2}\\
\mathbf{if}\;k \leq 1.8 \cdot 10^{-73}:\\
\;\;\;\;2 \cdot \frac{\frac{1}{k} \cdot \left(\frac{\ell}{k} \cdot \frac{\ell}{k \cdot t} + \frac{\ell \cdot \ell}{\frac{t}{0.3333333333333333}}\right)}{k}\\
\mathbf{elif}\;k \leq 3.8 \cdot 10^{+101}:\\
\;\;\;\;2 \cdot \left(\frac{\cos k}{k \cdot k} \cdot \left(\ell \cdot \frac{\ell}{t_1}\right)\right)\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\left(\frac{\ell}{k} \cdot \frac{\ell}{k}\right) \cdot \frac{\cos k}{t_1}\right)\\
\end{array}
\end{array}
if k < 1.8e-73Initial program 39.3%
associate-*l*39.2%
associate-*l*39.2%
associate-/r*39.2%
associate-/r/39.8%
*-commutative39.8%
times-frac41.4%
+-commutative41.4%
associate--l+49.7%
metadata-eval49.7%
+-rgt-identity49.7%
times-frac56.6%
Simplified56.6%
Taylor expanded in t around 0 73.1%
unpow273.1%
times-frac73.6%
unpow273.6%
associate-/l*85.7%
*-commutative85.7%
Simplified85.7%
Taylor expanded in k around 0 68.1%
unpow268.1%
unpow268.1%
associate-*l*68.1%
associate-*r/68.1%
*-commutative68.1%
unpow268.1%
Simplified68.1%
Taylor expanded in k around 0 66.1%
unpow266.1%
associate-/r*66.1%
Simplified66.1%
associate-*l/66.2%
times-frac78.2%
associate-/l*78.2%
Applied egg-rr78.2%
if 1.8e-73 < k < 3.7999999999999998e101Initial program 29.1%
associate-*l*29.1%
associate-*l*31.9%
associate-/r*32.0%
associate-/r/31.9%
*-commutative31.9%
times-frac31.8%
+-commutative31.8%
associate--l+42.5%
metadata-eval42.5%
+-rgt-identity42.5%
times-frac42.4%
Simplified42.4%
Taylor expanded in t around 0 80.0%
unpow280.0%
times-frac80.5%
unpow280.5%
associate-/l*94.9%
*-commutative94.9%
Simplified94.9%
associate-/r/95.1%
Applied egg-rr95.1%
if 3.7999999999999998e101 < k Initial program 31.9%
associate-*l*31.9%
associate-*l*31.9%
associate-/r*31.9%
associate-/r/29.4%
*-commutative29.4%
times-frac29.5%
+-commutative29.5%
associate--l+36.9%
metadata-eval36.9%
+-rgt-identity36.9%
times-frac36.9%
Simplified36.9%
Taylor expanded in t around 0 61.7%
unpow261.7%
times-frac64.3%
unpow264.3%
associate-/l*71.5%
*-commutative71.5%
Simplified71.5%
Taylor expanded in k around inf 61.7%
*-commutative61.7%
*-commutative61.7%
times-frac64.3%
unpow264.3%
unpow264.3%
times-frac97.4%
Simplified97.4%
Final simplification83.4%
NOTE: k should be positive before calling this function
(FPCore (t l k)
:precision binary64
(if (<= k 7.1e-16)
(*
2.0
(/
(*
(/ 1.0 k)
(+ (* (/ l k) (/ l (* k t))) (/ (* l l) (/ t 0.3333333333333333))))
k))
(* 2.0 (* (* (/ l k) (/ l k)) (/ (cos k) (* t (pow (sin k) 2.0)))))))k = abs(k);
double code(double t, double l, double k) {
double tmp;
if (k <= 7.1e-16) {
tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k);
} else {
tmp = 2.0 * (((l / k) * (l / k)) * (cos(k) / (t * pow(sin(k), 2.0))));
}
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 <= 7.1d-16) then
tmp = 2.0d0 * (((1.0d0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333d0)))) / k)
else
tmp = 2.0d0 * (((l / k) * (l / k)) * (cos(k) / (t * (sin(k) ** 2.0d0))))
end if
code = tmp
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
double tmp;
if (k <= 7.1e-16) {
tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k);
} else {
tmp = 2.0 * (((l / k) * (l / k)) * (Math.cos(k) / (t * Math.pow(Math.sin(k), 2.0))));
}
return tmp;
}
k = abs(k) def code(t, l, k): tmp = 0 if k <= 7.1e-16: tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k) else: tmp = 2.0 * (((l / k) * (l / k)) * (math.cos(k) / (t * math.pow(math.sin(k), 2.0)))) return tmp
k = abs(k) function code(t, l, k) tmp = 0.0 if (k <= 7.1e-16) tmp = Float64(2.0 * Float64(Float64(Float64(1.0 / k) * Float64(Float64(Float64(l / k) * Float64(l / Float64(k * t))) + Float64(Float64(l * l) / Float64(t / 0.3333333333333333)))) / k)); else tmp = Float64(2.0 * Float64(Float64(Float64(l / k) * Float64(l / k)) * Float64(cos(k) / Float64(t * (sin(k) ^ 2.0))))); end return tmp end
k = abs(k) function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 7.1e-16) tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k); else tmp = 2.0 * (((l / k) * (l / k)) * (cos(k) / (t * (sin(k) ^ 2.0)))); end tmp_2 = tmp; end
NOTE: k should be positive before calling this function code[t_, l_, k_] := If[LessEqual[k, 7.1e-16], N[(2.0 * N[(N[(N[(1.0 / k), $MachinePrecision] * N[(N[(N[(l / k), $MachinePrecision] * N[(l / N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(l * l), $MachinePrecision] / N[(t / 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(l / k), $MachinePrecision] * N[(l / k), $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / N[(t * N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k = |k|\\
\\
\begin{array}{l}
\mathbf{if}\;k \leq 7.1 \cdot 10^{-16}:\\
\;\;\;\;2 \cdot \frac{\frac{1}{k} \cdot \left(\frac{\ell}{k} \cdot \frac{\ell}{k \cdot t} + \frac{\ell \cdot \ell}{\frac{t}{0.3333333333333333}}\right)}{k}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\left(\frac{\ell}{k} \cdot \frac{\ell}{k}\right) \cdot \frac{\cos k}{t \cdot {\sin k}^{2}}\right)\\
\end{array}
\end{array}
if k < 7.1e-16Initial program 38.2%
associate-*l*38.2%
associate-*l*38.7%
associate-/r*38.7%
associate-/r/39.2%
*-commutative39.2%
times-frac40.7%
+-commutative40.7%
associate--l+48.5%
metadata-eval48.5%
+-rgt-identity48.5%
times-frac54.9%
Simplified54.9%
Taylor expanded in t around 0 73.6%
unpow273.6%
times-frac74.1%
unpow274.1%
associate-/l*85.8%
*-commutative85.8%
Simplified85.8%
Taylor expanded in k around 0 69.0%
unpow269.0%
unpow269.0%
associate-*l*69.0%
associate-*r/69.0%
*-commutative69.0%
unpow269.0%
Simplified69.0%
Taylor expanded in k around 0 67.1%
unpow267.1%
associate-/r*67.1%
Simplified67.1%
associate-*l/67.2%
times-frac78.8%
associate-/l*78.8%
Applied egg-rr78.8%
if 7.1e-16 < k Initial program 32.1%
associate-*l*32.1%
associate-*l*32.1%
associate-/r*32.1%
associate-/r/30.4%
*-commutative30.4%
times-frac30.5%
+-commutative30.5%
associate--l+41.0%
metadata-eval41.0%
+-rgt-identity41.0%
times-frac41.0%
Simplified41.0%
Taylor expanded in t around 0 67.6%
unpow267.6%
times-frac69.5%
unpow269.5%
associate-/l*80.6%
*-commutative80.6%
Simplified80.6%
Taylor expanded in k around inf 67.6%
*-commutative67.6%
*-commutative67.6%
times-frac69.6%
unpow269.6%
unpow269.6%
times-frac93.3%
Simplified93.3%
Final simplification82.3%
NOTE: k should be positive before calling this function
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (sin k) 2.0)))
(if (<= k 8.4e+102)
(* 2.0 (/ (* (cos k) l) (* (* k k) (/ t (/ l t_1)))))
(* 2.0 (* (* (/ l k) (/ l k)) (/ (cos k) (* t t_1)))))))k = abs(k);
double code(double t, double l, double k) {
double t_1 = pow(sin(k), 2.0);
double tmp;
if (k <= 8.4e+102) {
tmp = 2.0 * ((cos(k) * l) / ((k * k) * (t / (l / t_1))));
} else {
tmp = 2.0 * (((l / k) * (l / k)) * (cos(k) / (t * t_1)));
}
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) :: tmp
t_1 = sin(k) ** 2.0d0
if (k <= 8.4d+102) then
tmp = 2.0d0 * ((cos(k) * l) / ((k * k) * (t / (l / t_1))))
else
tmp = 2.0d0 * (((l / k) * (l / k)) * (cos(k) / (t * t_1)))
end if
code = tmp
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
double t_1 = Math.pow(Math.sin(k), 2.0);
double tmp;
if (k <= 8.4e+102) {
tmp = 2.0 * ((Math.cos(k) * l) / ((k * k) * (t / (l / t_1))));
} else {
tmp = 2.0 * (((l / k) * (l / k)) * (Math.cos(k) / (t * t_1)));
}
return tmp;
}
k = abs(k) def code(t, l, k): t_1 = math.pow(math.sin(k), 2.0) tmp = 0 if k <= 8.4e+102: tmp = 2.0 * ((math.cos(k) * l) / ((k * k) * (t / (l / t_1)))) else: tmp = 2.0 * (((l / k) * (l / k)) * (math.cos(k) / (t * t_1))) return tmp
k = abs(k) function code(t, l, k) t_1 = sin(k) ^ 2.0 tmp = 0.0 if (k <= 8.4e+102) tmp = Float64(2.0 * Float64(Float64(cos(k) * l) / Float64(Float64(k * k) * Float64(t / Float64(l / t_1))))); else tmp = Float64(2.0 * Float64(Float64(Float64(l / k) * Float64(l / k)) * Float64(cos(k) / Float64(t * t_1)))); end return tmp end
k = abs(k) function tmp_2 = code(t, l, k) t_1 = sin(k) ^ 2.0; tmp = 0.0; if (k <= 8.4e+102) tmp = 2.0 * ((cos(k) * l) / ((k * k) * (t / (l / t_1)))); else tmp = 2.0 * (((l / k) * (l / k)) * (cos(k) / (t * t_1))); end tmp_2 = tmp; end
NOTE: k should be positive before calling this function
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[k, 8.4e+102], N[(2.0 * N[(N[(N[Cos[k], $MachinePrecision] * l), $MachinePrecision] / N[(N[(k * k), $MachinePrecision] * N[(t / N[(l / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(l / k), $MachinePrecision] * N[(l / k), $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / N[(t * t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
k = |k|\\
\\
\begin{array}{l}
t_1 := {\sin k}^{2}\\
\mathbf{if}\;k \leq 8.4 \cdot 10^{+102}:\\
\;\;\;\;2 \cdot \frac{\cos k \cdot \ell}{\left(k \cdot k\right) \cdot \frac{t}{\frac{\ell}{t_1}}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\left(\frac{\ell}{k} \cdot \frac{\ell}{k}\right) \cdot \frac{\cos k}{t \cdot t_1}\right)\\
\end{array}
\end{array}
if k < 8.40000000000000006e102Initial program 37.5%
associate-*l*37.5%
associate-*l*37.9%
associate-/r*37.9%
associate-/r/38.4%
*-commutative38.4%
times-frac39.8%
+-commutative39.8%
associate--l+48.4%
metadata-eval48.4%
+-rgt-identity48.4%
times-frac54.2%
Simplified54.2%
Taylor expanded in t around 0 73.8%
unpow273.8%
times-frac74.3%
unpow274.3%
associate-/l*87.1%
*-commutative87.1%
Simplified87.1%
frac-times89.6%
associate-/l*90.5%
Applied egg-rr90.5%
if 8.40000000000000006e102 < k Initial program 32.7%
associate-*l*32.7%
associate-*l*32.7%
associate-/r*32.7%
associate-/r/30.2%
*-commutative30.2%
times-frac30.2%
+-commutative30.2%
associate--l+37.8%
metadata-eval37.8%
+-rgt-identity37.8%
times-frac37.8%
Simplified37.8%
Taylor expanded in t around 0 63.2%
unpow263.2%
times-frac65.8%
unpow265.8%
associate-/l*70.8%
*-commutative70.8%
Simplified70.8%
Taylor expanded in k around inf 63.2%
*-commutative63.2%
*-commutative63.2%
times-frac65.8%
unpow265.8%
unpow265.8%
times-frac97.4%
Simplified97.4%
Final simplification91.6%
NOTE: k should be positive before calling this function
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (sin k) 2.0)))
(if (<= k 1.04e+139)
(* 2.0 (/ (* (cos k) l) (* (* k k) (/ t (/ l t_1)))))
(* 2.0 (/ (* (/ l k) (/ l k)) (/ t_1 (/ (cos k) t)))))))k = abs(k);
double code(double t, double l, double k) {
double t_1 = pow(sin(k), 2.0);
double tmp;
if (k <= 1.04e+139) {
tmp = 2.0 * ((cos(k) * l) / ((k * k) * (t / (l / t_1))));
} else {
tmp = 2.0 * (((l / k) * (l / k)) / (t_1 / (cos(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) :: tmp
t_1 = sin(k) ** 2.0d0
if (k <= 1.04d+139) then
tmp = 2.0d0 * ((cos(k) * l) / ((k * k) * (t / (l / t_1))))
else
tmp = 2.0d0 * (((l / k) * (l / k)) / (t_1 / (cos(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 = Math.pow(Math.sin(k), 2.0);
double tmp;
if (k <= 1.04e+139) {
tmp = 2.0 * ((Math.cos(k) * l) / ((k * k) * (t / (l / t_1))));
} else {
tmp = 2.0 * (((l / k) * (l / k)) / (t_1 / (Math.cos(k) / t)));
}
return tmp;
}
k = abs(k) def code(t, l, k): t_1 = math.pow(math.sin(k), 2.0) tmp = 0 if k <= 1.04e+139: tmp = 2.0 * ((math.cos(k) * l) / ((k * k) * (t / (l / t_1)))) else: tmp = 2.0 * (((l / k) * (l / k)) / (t_1 / (math.cos(k) / t))) return tmp
k = abs(k) function code(t, l, k) t_1 = sin(k) ^ 2.0 tmp = 0.0 if (k <= 1.04e+139) tmp = Float64(2.0 * Float64(Float64(cos(k) * l) / Float64(Float64(k * k) * Float64(t / Float64(l / t_1))))); else tmp = Float64(2.0 * Float64(Float64(Float64(l / k) * Float64(l / k)) / Float64(t_1 / Float64(cos(k) / t)))); end return tmp end
k = abs(k) function tmp_2 = code(t, l, k) t_1 = sin(k) ^ 2.0; tmp = 0.0; if (k <= 1.04e+139) tmp = 2.0 * ((cos(k) * l) / ((k * k) * (t / (l / t_1)))); else tmp = 2.0 * (((l / k) * (l / k)) / (t_1 / (cos(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[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[k, 1.04e+139], N[(2.0 * N[(N[(N[Cos[k], $MachinePrecision] * l), $MachinePrecision] / N[(N[(k * k), $MachinePrecision] * N[(t / N[(l / t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(l / k), $MachinePrecision] * N[(l / k), $MachinePrecision]), $MachinePrecision] / N[(t$95$1 / N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
k = |k|\\
\\
\begin{array}{l}
t_1 := {\sin k}^{2}\\
\mathbf{if}\;k \leq 1.04 \cdot 10^{+139}:\\
\;\;\;\;2 \cdot \frac{\cos k \cdot \ell}{\left(k \cdot k\right) \cdot \frac{t}{\frac{\ell}{t_1}}}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \frac{\frac{\ell}{k} \cdot \frac{\ell}{k}}{\frac{t_1}{\frac{\cos k}{t}}}\\
\end{array}
\end{array}
if k < 1.04e139Initial program 36.9%
associate-*l*36.9%
associate-*l*37.3%
associate-/r*37.3%
associate-/r/37.8%
*-commutative37.8%
times-frac39.1%
+-commutative39.1%
associate--l+47.4%
metadata-eval47.4%
+-rgt-identity47.4%
times-frac52.9%
Simplified52.9%
Taylor expanded in t around 0 73.6%
unpow273.6%
times-frac74.5%
unpow274.5%
associate-/l*87.2%
*-commutative87.2%
Simplified87.2%
frac-times90.0%
associate-/l*90.9%
Applied egg-rr90.9%
if 1.04e139 < k Initial program 35.7%
associate-*l*35.7%
associate-*l*35.7%
associate-/r*35.7%
associate-/r/32.5%
*-commutative32.5%
times-frac32.5%
+-commutative32.5%
associate--l+42.1%
metadata-eval42.1%
+-rgt-identity42.1%
times-frac42.1%
Simplified42.1%
Taylor expanded in t around 0 62.1%
unpow262.1%
times-frac62.1%
unpow262.1%
associate-/l*65.5%
*-commutative65.5%
Simplified65.5%
Taylor expanded in k around inf 62.1%
*-commutative62.1%
*-commutative62.1%
times-frac62.2%
unpow262.2%
unpow262.2%
times-frac96.7%
Simplified96.7%
Taylor expanded in l around 0 62.1%
associate-/r*62.2%
associate-*r/62.2%
unpow262.2%
unpow262.2%
times-frac96.7%
unpow296.7%
*-commutative96.7%
associate-/l*96.7%
associate-/l*96.8%
Simplified96.8%
unpow296.8%
Applied egg-rr96.8%
Final simplification91.6%
NOTE: k should be positive before calling this function (FPCore (t l k) :precision binary64 (* (/ 2.0 (* k (* k t))) (* (/ l (sin k)) (/ l (tan k)))))
k = abs(k);
double code(double t, double l, double k) {
return (2.0 / (k * (k * t))) * ((l / sin(k)) * (l / tan(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 * (k * t))) * ((l / sin(k)) * (l / tan(k)))
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
return (2.0 / (k * (k * t))) * ((l / Math.sin(k)) * (l / Math.tan(k)));
}
k = abs(k) def code(t, l, k): return (2.0 / (k * (k * t))) * ((l / math.sin(k)) * (l / math.tan(k)))
k = abs(k) function code(t, l, k) return Float64(Float64(2.0 / Float64(k * Float64(k * t))) * Float64(Float64(l / sin(k)) * Float64(l / tan(k)))) end
k = abs(k) function tmp = code(t, l, k) tmp = (2.0 / (k * (k * t))) * ((l / sin(k)) * (l / tan(k))); end
NOTE: k should be positive before calling this function code[t_, l_, k_] := N[(N[(2.0 / N[(k * N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] * N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k = |k|\\
\\
\frac{2}{k \cdot \left(k \cdot t\right)} \cdot \left(\frac{\ell}{\sin k} \cdot \frac{\ell}{\tan k}\right)
\end{array}
Initial program 36.8%
associate-*l*36.8%
associate-*l*37.1%
associate-/r*37.1%
associate-/r/37.1%
*-commutative37.1%
times-frac38.3%
+-commutative38.3%
associate--l+46.8%
metadata-eval46.8%
+-rgt-identity46.8%
times-frac51.6%
Simplified51.6%
Taylor expanded in t around 0 79.5%
unpow279.5%
associate-*l*82.8%
Simplified82.8%
Final simplification82.8%
NOTE: k should be positive before calling this function
(FPCore (t l k)
:precision binary64
(if (<= k 0.0019)
(*
2.0
(/
(*
(/ 1.0 k)
(+ (* (/ l k) (/ l (* k t))) (/ (* l l) (/ t 0.3333333333333333))))
k))
(* 2.0 (* 0.3333333333333333 (/ (* (cos k) (pow (/ l k) 2.0)) t)))))k = abs(k);
double code(double t, double l, double k) {
double tmp;
if (k <= 0.0019) {
tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k);
} else {
tmp = 2.0 * (0.3333333333333333 * ((cos(k) * pow((l / k), 2.0)) / 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 (k <= 0.0019d0) then
tmp = 2.0d0 * (((1.0d0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333d0)))) / k)
else
tmp = 2.0d0 * (0.3333333333333333d0 * ((cos(k) * ((l / k) ** 2.0d0)) / t))
end if
code = tmp
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
double tmp;
if (k <= 0.0019) {
tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k);
} else {
tmp = 2.0 * (0.3333333333333333 * ((Math.cos(k) * Math.pow((l / k), 2.0)) / t));
}
return tmp;
}
k = abs(k) def code(t, l, k): tmp = 0 if k <= 0.0019: tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k) else: tmp = 2.0 * (0.3333333333333333 * ((math.cos(k) * math.pow((l / k), 2.0)) / t)) return tmp
k = abs(k) function code(t, l, k) tmp = 0.0 if (k <= 0.0019) tmp = Float64(2.0 * Float64(Float64(Float64(1.0 / k) * Float64(Float64(Float64(l / k) * Float64(l / Float64(k * t))) + Float64(Float64(l * l) / Float64(t / 0.3333333333333333)))) / k)); else tmp = Float64(2.0 * Float64(0.3333333333333333 * Float64(Float64(cos(k) * (Float64(l / k) ^ 2.0)) / t))); end return tmp end
k = abs(k) function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 0.0019) tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k); else tmp = 2.0 * (0.3333333333333333 * ((cos(k) * ((l / k) ^ 2.0)) / t)); end tmp_2 = tmp; end
NOTE: k should be positive before calling this function code[t_, l_, k_] := If[LessEqual[k, 0.0019], N[(2.0 * N[(N[(N[(1.0 / k), $MachinePrecision] * N[(N[(N[(l / k), $MachinePrecision] * N[(l / N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(l * l), $MachinePrecision] / N[(t / 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(0.3333333333333333 * N[(N[(N[Cos[k], $MachinePrecision] * N[Power[N[(l / k), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k = |k|\\
\\
\begin{array}{l}
\mathbf{if}\;k \leq 0.0019:\\
\;\;\;\;2 \cdot \frac{\frac{1}{k} \cdot \left(\frac{\ell}{k} \cdot \frac{\ell}{k \cdot t} + \frac{\ell \cdot \ell}{\frac{t}{0.3333333333333333}}\right)}{k}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(0.3333333333333333 \cdot \frac{\cos k \cdot {\left(\frac{\ell}{k}\right)}^{2}}{t}\right)\\
\end{array}
\end{array}
if k < 0.0019Initial program 38.3%
associate-*l*38.3%
associate-*l*38.8%
associate-/r*38.8%
associate-/r/39.3%
*-commutative39.3%
times-frac40.8%
+-commutative40.8%
associate--l+48.5%
metadata-eval48.5%
+-rgt-identity48.5%
times-frac54.9%
Simplified54.9%
Taylor expanded in t around 0 73.9%
unpow273.9%
times-frac74.3%
unpow274.3%
associate-/l*86.0%
*-commutative86.0%
Simplified86.0%
Taylor expanded in k around 0 69.3%
unpow269.3%
unpow269.3%
associate-*l*69.3%
associate-*r/69.3%
*-commutative69.3%
unpow269.3%
Simplified69.3%
Taylor expanded in k around 0 67.4%
unpow267.4%
associate-/r*67.4%
Simplified67.4%
associate-*l/67.5%
times-frac79.0%
associate-/l*79.0%
Applied egg-rr79.0%
if 0.0019 < k Initial program 31.5%
associate-*l*31.5%
associate-*l*31.5%
associate-/r*31.5%
associate-/r/29.7%
*-commutative29.7%
times-frac29.8%
+-commutative29.8%
associate--l+40.8%
metadata-eval40.8%
+-rgt-identity40.8%
times-frac40.7%
Simplified40.7%
Taylor expanded in t around 0 66.5%
unpow266.5%
times-frac68.5%
unpow268.5%
associate-/l*80.0%
*-commutative80.0%
Simplified80.0%
Taylor expanded in k around 0 54.0%
unpow254.0%
unpow254.0%
associate-*l*54.0%
associate-*r/54.0%
*-commutative54.0%
unpow254.0%
Simplified54.0%
Taylor expanded in k around inf 53.8%
*-commutative53.8%
times-frac54.5%
unpow254.5%
unpow254.5%
times-frac59.6%
unpow259.6%
Simplified59.6%
associate-*r/59.6%
Applied egg-rr59.6%
Final simplification74.5%
NOTE: k should be positive before calling this function
(FPCore (t l k)
:precision binary64
(if (<= k 0.0019)
(*
2.0
(/
(*
(/ 1.0 k)
(+ (* (/ l k) (/ l (* k t))) (/ (* l l) (/ t 0.3333333333333333))))
k))
(* 2.0 (* 0.3333333333333333 (* (* (/ l k) (/ l k)) (/ (cos k) t))))))k = abs(k);
double code(double t, double l, double k) {
double tmp;
if (k <= 0.0019) {
tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k);
} else {
tmp = 2.0 * (0.3333333333333333 * (((l / k) * (l / k)) * (cos(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 (k <= 0.0019d0) then
tmp = 2.0d0 * (((1.0d0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333d0)))) / k)
else
tmp = 2.0d0 * (0.3333333333333333d0 * (((l / k) * (l / k)) * (cos(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 (k <= 0.0019) {
tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k);
} else {
tmp = 2.0 * (0.3333333333333333 * (((l / k) * (l / k)) * (Math.cos(k) / t)));
}
return tmp;
}
k = abs(k) def code(t, l, k): tmp = 0 if k <= 0.0019: tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k) else: tmp = 2.0 * (0.3333333333333333 * (((l / k) * (l / k)) * (math.cos(k) / t))) return tmp
k = abs(k) function code(t, l, k) tmp = 0.0 if (k <= 0.0019) tmp = Float64(2.0 * Float64(Float64(Float64(1.0 / k) * Float64(Float64(Float64(l / k) * Float64(l / Float64(k * t))) + Float64(Float64(l * l) / Float64(t / 0.3333333333333333)))) / k)); else tmp = Float64(2.0 * Float64(0.3333333333333333 * Float64(Float64(Float64(l / k) * Float64(l / k)) * Float64(cos(k) / t)))); end return tmp end
k = abs(k) function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 0.0019) tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k); else tmp = 2.0 * (0.3333333333333333 * (((l / k) * (l / k)) * (cos(k) / t))); end tmp_2 = tmp; end
NOTE: k should be positive before calling this function code[t_, l_, k_] := If[LessEqual[k, 0.0019], N[(2.0 * N[(N[(N[(1.0 / k), $MachinePrecision] * N[(N[(N[(l / k), $MachinePrecision] * N[(l / N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(l * l), $MachinePrecision] / N[(t / 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(0.3333333333333333 * N[(N[(N[(l / k), $MachinePrecision] * N[(l / k), $MachinePrecision]), $MachinePrecision] * N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k = |k|\\
\\
\begin{array}{l}
\mathbf{if}\;k \leq 0.0019:\\
\;\;\;\;2 \cdot \frac{\frac{1}{k} \cdot \left(\frac{\ell}{k} \cdot \frac{\ell}{k \cdot t} + \frac{\ell \cdot \ell}{\frac{t}{0.3333333333333333}}\right)}{k}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(0.3333333333333333 \cdot \left(\left(\frac{\ell}{k} \cdot \frac{\ell}{k}\right) \cdot \frac{\cos k}{t}\right)\right)\\
\end{array}
\end{array}
if k < 0.0019Initial program 38.3%
associate-*l*38.3%
associate-*l*38.8%
associate-/r*38.8%
associate-/r/39.3%
*-commutative39.3%
times-frac40.8%
+-commutative40.8%
associate--l+48.5%
metadata-eval48.5%
+-rgt-identity48.5%
times-frac54.9%
Simplified54.9%
Taylor expanded in t around 0 73.9%
unpow273.9%
times-frac74.3%
unpow274.3%
associate-/l*86.0%
*-commutative86.0%
Simplified86.0%
Taylor expanded in k around 0 69.3%
unpow269.3%
unpow269.3%
associate-*l*69.3%
associate-*r/69.3%
*-commutative69.3%
unpow269.3%
Simplified69.3%
Taylor expanded in k around 0 67.4%
unpow267.4%
associate-/r*67.4%
Simplified67.4%
associate-*l/67.5%
times-frac79.0%
associate-/l*79.0%
Applied egg-rr79.0%
if 0.0019 < k Initial program 31.5%
associate-*l*31.5%
associate-*l*31.5%
associate-/r*31.5%
associate-/r/29.7%
*-commutative29.7%
times-frac29.8%
+-commutative29.8%
associate--l+40.8%
metadata-eval40.8%
+-rgt-identity40.8%
times-frac40.7%
Simplified40.7%
Taylor expanded in t around 0 66.5%
unpow266.5%
times-frac68.5%
unpow268.5%
associate-/l*80.0%
*-commutative80.0%
Simplified80.0%
Taylor expanded in k around 0 54.0%
unpow254.0%
unpow254.0%
associate-*l*54.0%
associate-*r/54.0%
*-commutative54.0%
unpow254.0%
Simplified54.0%
Taylor expanded in k around inf 53.8%
*-commutative53.8%
times-frac54.5%
unpow254.5%
unpow254.5%
times-frac59.6%
unpow259.6%
Simplified59.6%
unpow293.1%
Applied egg-rr59.6%
Final simplification74.5%
NOTE: k should be positive before calling this function
(FPCore (t l k)
:precision binary64
(if (<= l 1.75e+174)
(*
2.0
(/
(*
(/ 1.0 k)
(+ (* (/ l k) (/ l (* k t))) (/ (* l l) (/ t 0.3333333333333333))))
k))
(*
2.0
(*
(+ (/ (/ 1.0 k) k) -0.5)
(+ (/ (* l l) (* k (* k t))) (/ (* (* l l) 0.3333333333333333) t))))))k = abs(k);
double code(double t, double l, double k) {
double tmp;
if (l <= 1.75e+174) {
tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k);
} else {
tmp = 2.0 * ((((1.0 / k) / k) + -0.5) * (((l * l) / (k * (k * t))) + (((l * l) * 0.3333333333333333) / 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 <= 1.75d+174) then
tmp = 2.0d0 * (((1.0d0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333d0)))) / k)
else
tmp = 2.0d0 * ((((1.0d0 / k) / k) + (-0.5d0)) * (((l * l) / (k * (k * t))) + (((l * l) * 0.3333333333333333d0) / 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 <= 1.75e+174) {
tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k);
} else {
tmp = 2.0 * ((((1.0 / k) / k) + -0.5) * (((l * l) / (k * (k * t))) + (((l * l) * 0.3333333333333333) / t)));
}
return tmp;
}
k = abs(k) def code(t, l, k): tmp = 0 if l <= 1.75e+174: tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k) else: tmp = 2.0 * ((((1.0 / k) / k) + -0.5) * (((l * l) / (k * (k * t))) + (((l * l) * 0.3333333333333333) / t))) return tmp
k = abs(k) function code(t, l, k) tmp = 0.0 if (l <= 1.75e+174) tmp = Float64(2.0 * Float64(Float64(Float64(1.0 / k) * Float64(Float64(Float64(l / k) * Float64(l / Float64(k * t))) + Float64(Float64(l * l) / Float64(t / 0.3333333333333333)))) / k)); else tmp = Float64(2.0 * Float64(Float64(Float64(Float64(1.0 / k) / k) + -0.5) * Float64(Float64(Float64(l * l) / Float64(k * Float64(k * t))) + Float64(Float64(Float64(l * l) * 0.3333333333333333) / t)))); end return tmp end
k = abs(k) function tmp_2 = code(t, l, k) tmp = 0.0; if (l <= 1.75e+174) tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k); else tmp = 2.0 * ((((1.0 / k) / k) + -0.5) * (((l * l) / (k * (k * t))) + (((l * l) * 0.3333333333333333) / t))); end tmp_2 = tmp; end
NOTE: k should be positive before calling this function code[t_, l_, k_] := If[LessEqual[l, 1.75e+174], N[(2.0 * N[(N[(N[(1.0 / k), $MachinePrecision] * N[(N[(N[(l / k), $MachinePrecision] * N[(l / N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(l * l), $MachinePrecision] / N[(t / 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision], N[(2.0 * N[(N[(N[(N[(1.0 / k), $MachinePrecision] / k), $MachinePrecision] + -0.5), $MachinePrecision] * N[(N[(N[(l * l), $MachinePrecision] / N[(k * N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(N[(l * l), $MachinePrecision] * 0.3333333333333333), $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
k = |k|\\
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 1.75 \cdot 10^{+174}:\\
\;\;\;\;2 \cdot \frac{\frac{1}{k} \cdot \left(\frac{\ell}{k} \cdot \frac{\ell}{k \cdot t} + \frac{\ell \cdot \ell}{\frac{t}{0.3333333333333333}}\right)}{k}\\
\mathbf{else}:\\
\;\;\;\;2 \cdot \left(\left(\frac{\frac{1}{k}}{k} + -0.5\right) \cdot \left(\frac{\ell \cdot \ell}{k \cdot \left(k \cdot t\right)} + \frac{\left(\ell \cdot \ell\right) \cdot 0.3333333333333333}{t}\right)\right)\\
\end{array}
\end{array}
if l < 1.7500000000000001e174Initial program 37.9%
associate-*l*37.9%
associate-*l*38.3%
associate-/r*38.3%
associate-/r/38.3%
*-commutative38.3%
times-frac39.6%
+-commutative39.6%
associate--l+49.0%
metadata-eval49.0%
+-rgt-identity49.0%
times-frac54.4%
Simplified54.4%
Taylor expanded in t around 0 74.5%
unpow274.5%
times-frac75.4%
unpow275.4%
associate-/l*87.1%
*-commutative87.1%
Simplified87.1%
Taylor expanded in k around 0 67.4%
unpow267.4%
unpow267.4%
associate-*l*67.4%
associate-*r/67.4%
*-commutative67.4%
unpow267.4%
Simplified67.4%
Taylor expanded in k around 0 65.0%
unpow265.0%
associate-/r*65.0%
Simplified65.0%
associate-*l/65.1%
times-frac75.1%
associate-/l*75.1%
Applied egg-rr75.1%
if 1.7500000000000001e174 < l Initial program 26.9%
associate-*l*26.9%
associate-*l*26.9%
associate-/r*26.9%
associate-/r/26.9%
*-commutative26.9%
times-frac26.9%
+-commutative26.9%
associate--l+26.9%
metadata-eval26.9%
+-rgt-identity26.9%
times-frac26.9%
Simplified26.9%
Taylor expanded in t around 0 51.4%
unpow251.4%
times-frac51.7%
unpow251.7%
associate-/l*62.7%
*-commutative62.7%
Simplified62.7%
Taylor expanded in k around 0 51.4%
unpow251.4%
unpow251.4%
associate-*l*51.4%
associate-*r/51.4%
*-commutative51.4%
unpow251.4%
Simplified51.4%
Taylor expanded in k around 0 58.2%
sub-neg58.2%
unpow258.2%
associate-/r*58.2%
metadata-eval58.2%
Simplified58.2%
Final simplification73.4%
NOTE: k should be positive before calling this function
(FPCore (t l k)
:precision binary64
(*
2.0
(/
(*
(/ 1.0 k)
(+ (* (/ l k) (/ l (* k t))) (/ (* l l) (/ t 0.3333333333333333))))
k)))k = abs(k);
double code(double t, double l, double k) {
return 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / 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 * (((1.0d0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333d0)))) / k)
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
return 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k);
}
k = abs(k) def code(t, l, k): return 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k)
k = abs(k) function code(t, l, k) return Float64(2.0 * Float64(Float64(Float64(1.0 / k) * Float64(Float64(Float64(l / k) * Float64(l / Float64(k * t))) + Float64(Float64(l * l) / Float64(t / 0.3333333333333333)))) / k)) end
k = abs(k) function tmp = code(t, l, k) tmp = 2.0 * (((1.0 / k) * (((l / k) * (l / (k * t))) + ((l * l) / (t / 0.3333333333333333)))) / k); end
NOTE: k should be positive before calling this function code[t_, l_, k_] := N[(2.0 * N[(N[(N[(1.0 / k), $MachinePrecision] * N[(N[(N[(l / k), $MachinePrecision] * N[(l / N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] + N[(N[(l * l), $MachinePrecision] / N[(t / 0.3333333333333333), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k = |k|\\
\\
2 \cdot \frac{\frac{1}{k} \cdot \left(\frac{\ell}{k} \cdot \frac{\ell}{k \cdot t} + \frac{\ell \cdot \ell}{\frac{t}{0.3333333333333333}}\right)}{k}
\end{array}
Initial program 36.8%
associate-*l*36.8%
associate-*l*37.1%
associate-/r*37.1%
associate-/r/37.1%
*-commutative37.1%
times-frac38.3%
+-commutative38.3%
associate--l+46.8%
metadata-eval46.8%
+-rgt-identity46.8%
times-frac51.6%
Simplified51.6%
Taylor expanded in t around 0 72.2%
unpow272.2%
times-frac73.0%
unpow273.0%
associate-/l*84.6%
*-commutative84.6%
Simplified84.6%
Taylor expanded in k around 0 65.8%
unpow265.8%
unpow265.8%
associate-*l*65.8%
associate-*r/65.8%
*-commutative65.8%
unpow265.8%
Simplified65.8%
Taylor expanded in k around 0 63.2%
unpow263.2%
associate-/r*63.2%
Simplified63.2%
associate-*l/63.3%
times-frac72.3%
associate-/l*72.3%
Applied egg-rr72.3%
Final simplification72.3%
NOTE: k should be positive before calling this function (FPCore (t l k) :precision binary64 (* 2.0 (/ (+ (/ 0.3333333333333333 t) (/ 1.0 (* k (* k t)))) (/ (* k k) (* l l)))))
k = abs(k);
double code(double t, double l, double k) {
return 2.0 * (((0.3333333333333333 / t) + (1.0 / (k * (k * t)))) / ((k * k) / (l * l)));
}
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 * (((0.3333333333333333d0 / t) + (1.0d0 / (k * (k * t)))) / ((k * k) / (l * l)))
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
return 2.0 * (((0.3333333333333333 / t) + (1.0 / (k * (k * t)))) / ((k * k) / (l * l)));
}
k = abs(k) def code(t, l, k): return 2.0 * (((0.3333333333333333 / t) + (1.0 / (k * (k * t)))) / ((k * k) / (l * l)))
k = abs(k) function code(t, l, k) return Float64(2.0 * Float64(Float64(Float64(0.3333333333333333 / t) + Float64(1.0 / Float64(k * Float64(k * t)))) / Float64(Float64(k * k) / Float64(l * l)))) end
k = abs(k) function tmp = code(t, l, k) tmp = 2.0 * (((0.3333333333333333 / t) + (1.0 / (k * (k * t)))) / ((k * k) / (l * l))); end
NOTE: k should be positive before calling this function code[t_, l_, k_] := N[(2.0 * N[(N[(N[(0.3333333333333333 / t), $MachinePrecision] + N[(1.0 / N[(k * N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(k * k), $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k = |k|\\
\\
2 \cdot \frac{\frac{0.3333333333333333}{t} + \frac{1}{k \cdot \left(k \cdot t\right)}}{\frac{k \cdot k}{\ell \cdot \ell}}
\end{array}
Initial program 36.8%
associate-*l*36.8%
associate-*l*37.1%
associate-/r*37.1%
associate-/r/37.1%
*-commutative37.1%
times-frac38.3%
+-commutative38.3%
associate--l+46.8%
metadata-eval46.8%
+-rgt-identity46.8%
times-frac51.6%
Simplified51.6%
Taylor expanded in t around 0 72.2%
unpow272.2%
times-frac73.0%
unpow273.0%
associate-/l*84.6%
*-commutative84.6%
Simplified84.6%
Taylor expanded in k around 0 65.8%
unpow265.8%
unpow265.8%
associate-*l*65.8%
associate-*r/65.8%
*-commutative65.8%
unpow265.8%
Simplified65.8%
Taylor expanded in k around 0 63.2%
unpow263.2%
associate-/r*63.2%
Simplified63.2%
Taylor expanded in l around 0 63.3%
associate-/l*63.4%
associate-*r/63.4%
metadata-eval63.4%
unpow263.4%
associate-*r*63.4%
unpow263.4%
unpow263.4%
Simplified63.4%
Final simplification63.4%
NOTE: k should be positive before calling this function (FPCore (t l k) :precision binary64 (* 2.0 (/ (+ (/ 0.3333333333333333 t) (/ (/ 1.0 k) (* k t))) (* (/ k l) (/ k l)))))
k = abs(k);
double code(double t, double l, double k) {
return 2.0 * (((0.3333333333333333 / t) + ((1.0 / k) / (k * t))) / ((k / l) * (k / l)));
}
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 * (((0.3333333333333333d0 / t) + ((1.0d0 / k) / (k * t))) / ((k / l) * (k / l)))
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
return 2.0 * (((0.3333333333333333 / t) + ((1.0 / k) / (k * t))) / ((k / l) * (k / l)));
}
k = abs(k) def code(t, l, k): return 2.0 * (((0.3333333333333333 / t) + ((1.0 / k) / (k * t))) / ((k / l) * (k / l)))
k = abs(k) function code(t, l, k) return Float64(2.0 * Float64(Float64(Float64(0.3333333333333333 / t) + Float64(Float64(1.0 / k) / Float64(k * t))) / Float64(Float64(k / l) * Float64(k / l)))) end
k = abs(k) function tmp = code(t, l, k) tmp = 2.0 * (((0.3333333333333333 / t) + ((1.0 / k) / (k * t))) / ((k / l) * (k / l))); end
NOTE: k should be positive before calling this function code[t_, l_, k_] := N[(2.0 * N[(N[(N[(0.3333333333333333 / t), $MachinePrecision] + N[(N[(1.0 / k), $MachinePrecision] / N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[(k / l), $MachinePrecision] * N[(k / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k = |k|\\
\\
2 \cdot \frac{\frac{0.3333333333333333}{t} + \frac{\frac{1}{k}}{k \cdot t}}{\frac{k}{\ell} \cdot \frac{k}{\ell}}
\end{array}
Initial program 36.8%
associate-*l*36.8%
associate-*l*37.1%
associate-/r*37.1%
associate-/r/37.1%
*-commutative37.1%
times-frac38.3%
+-commutative38.3%
associate--l+46.8%
metadata-eval46.8%
+-rgt-identity46.8%
times-frac51.6%
Simplified51.6%
Taylor expanded in t around 0 72.2%
unpow272.2%
times-frac73.0%
unpow273.0%
associate-/l*84.6%
*-commutative84.6%
Simplified84.6%
Taylor expanded in k around 0 65.8%
unpow265.8%
unpow265.8%
associate-*l*65.8%
associate-*r/65.8%
*-commutative65.8%
unpow265.8%
Simplified65.8%
Taylor expanded in k around 0 63.2%
unpow263.2%
associate-/r*63.2%
Simplified63.2%
Taylor expanded in l around 0 63.3%
associate-/l*63.4%
associate-*r/63.4%
metadata-eval63.4%
unpow263.4%
associate-*r*63.4%
associate-/r*63.4%
unpow263.4%
unpow263.4%
times-frac71.7%
Simplified71.7%
Final simplification71.7%
NOTE: k should be positive before calling this function (FPCore (t l k) :precision binary64 (* 2.0 (* 0.3333333333333333 (/ (* l l) (* k (* k t))))))
k = abs(k);
double code(double t, double l, double k) {
return 2.0 * (0.3333333333333333 * ((l * l) / (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 * (0.3333333333333333d0 * ((l * l) / (k * (k * t))))
end function
k = Math.abs(k);
public static double code(double t, double l, double k) {
return 2.0 * (0.3333333333333333 * ((l * l) / (k * (k * t))));
}
k = abs(k) def code(t, l, k): return 2.0 * (0.3333333333333333 * ((l * l) / (k * (k * t))))
k = abs(k) function code(t, l, k) return Float64(2.0 * Float64(0.3333333333333333 * Float64(Float64(l * l) / Float64(k * Float64(k * t))))) end
k = abs(k) function tmp = code(t, l, k) tmp = 2.0 * (0.3333333333333333 * ((l * l) / (k * (k * t)))); end
NOTE: k should be positive before calling this function code[t_, l_, k_] := N[(2.0 * N[(0.3333333333333333 * N[(N[(l * l), $MachinePrecision] / N[(k * N[(k * t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
k = |k|\\
\\
2 \cdot \left(0.3333333333333333 \cdot \frac{\ell \cdot \ell}{k \cdot \left(k \cdot t\right)}\right)
\end{array}
Initial program 36.8%
associate-*l*36.8%
associate-*l*37.1%
associate-/r*37.1%
associate-/r/37.1%
*-commutative37.1%
times-frac38.3%
+-commutative38.3%
associate--l+46.8%
metadata-eval46.8%
+-rgt-identity46.8%
times-frac51.6%
Simplified51.6%
Taylor expanded in t around 0 72.2%
unpow272.2%
times-frac73.0%
unpow273.0%
associate-/l*84.6%
*-commutative84.6%
Simplified84.6%
Taylor expanded in k around 0 65.8%
unpow265.8%
unpow265.8%
associate-*l*65.8%
associate-*r/65.8%
*-commutative65.8%
unpow265.8%
Simplified65.8%
Taylor expanded in k around inf 63.3%
*-commutative63.3%
times-frac62.4%
unpow262.4%
unpow262.4%
times-frac63.2%
unpow263.2%
Simplified63.2%
Taylor expanded in k around 0 60.8%
unpow260.8%
unpow260.8%
associate-*r*58.7%
Simplified58.7%
Final simplification58.7%
herbie shell --seed 2023255
(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))))