
(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 15 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}
(FPCore (t l k)
:precision binary64
(if (or (<= t -1.8e-51) (not (<= t 2.1e-98)))
(/
2.0
(pow
(*
(* (/ t (pow (cbrt l) 2.0)) (cbrt (sin k)))
(cbrt (* (tan k) (+ 2.0 (pow (/ k t) 2.0)))))
3.0))
(* (* (/ l (pow k 2.0)) (/ 2.0 t)) (/ (/ l (sin k)) (tan k)))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -1.8e-51) || !(t <= 2.1e-98)) {
tmp = 2.0 / pow((((t / pow(cbrt(l), 2.0)) * cbrt(sin(k))) * cbrt((tan(k) * (2.0 + pow((k / t), 2.0))))), 3.0);
} else {
tmp = ((l / pow(k, 2.0)) * (2.0 / t)) * ((l / sin(k)) / tan(k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -1.8e-51) || !(t <= 2.1e-98)) {
tmp = 2.0 / Math.pow((((t / Math.pow(Math.cbrt(l), 2.0)) * Math.cbrt(Math.sin(k))) * Math.cbrt((Math.tan(k) * (2.0 + Math.pow((k / t), 2.0))))), 3.0);
} else {
tmp = ((l / Math.pow(k, 2.0)) * (2.0 / t)) * ((l / Math.sin(k)) / Math.tan(k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if ((t <= -1.8e-51) || !(t <= 2.1e-98)) tmp = Float64(2.0 / (Float64(Float64(Float64(t / (cbrt(l) ^ 2.0)) * cbrt(sin(k))) * cbrt(Float64(tan(k) * Float64(2.0 + (Float64(k / t) ^ 2.0))))) ^ 3.0)); else tmp = Float64(Float64(Float64(l / (k ^ 2.0)) * Float64(2.0 / t)) * Float64(Float64(l / sin(k)) / tan(k))); end return tmp end
code[t_, l_, k_] := If[Or[LessEqual[t, -1.8e-51], N[Not[LessEqual[t, 2.1e-98]], $MachinePrecision]], N[(2.0 / N[Power[N[(N[(N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision] * N[Power[N[(N[Tan[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision], N[(N[(N[(l / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.8 \cdot 10^{-51} \lor \neg \left(t \leq 2.1 \cdot 10^{-98}\right):\\
\;\;\;\;\frac{2}{{\left(\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}} \cdot \sqrt[3]{\sin k}\right) \cdot \sqrt[3]{\tan k \cdot \left(2 + {\left(\frac{k}{t}\right)}^{2}\right)}\right)}^{3}}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{\ell}{{k}^{2}} \cdot \frac{2}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\end{array}
\end{array}
if t < -1.8e-51 or 2.09999999999999992e-98 < t Initial program 65.1%
associate-/r*71.9%
add-cube-cbrt71.8%
*-un-lft-identity71.8%
times-frac71.8%
pow271.8%
cbrt-div71.7%
rem-cbrt-cube71.8%
cbrt-div71.7%
rem-cbrt-cube79.5%
Applied egg-rr79.5%
/-rgt-identity79.5%
associate-*r/76.0%
add-cube-cbrt76.0%
pow376.0%
cbrt-prod76.0%
cbrt-div78.2%
unpow278.2%
add-cbrt-cube87.6%
Applied egg-rr87.6%
add-cube-cbrt87.6%
pow387.6%
Applied egg-rr94.7%
associate-+r+94.7%
metadata-eval94.7%
Simplified94.7%
if -1.8e-51 < t < 2.09999999999999992e-98Initial program 41.2%
Simplified40.1%
associate-*r*46.3%
*-un-lft-identity46.3%
times-frac46.3%
Applied egg-rr46.3%
/-rgt-identity46.3%
associate-*r/46.3%
times-frac46.4%
*-commutative46.4%
associate-/r*46.4%
Simplified46.4%
Taylor expanded in t around 0 78.8%
associate-*r/78.8%
*-commutative78.8%
times-frac83.9%
Simplified83.9%
Final simplification90.5%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0)))
(if (<=
(/
2.0
(*
(+ 1.0 (+ t_1 1.0))
(* (tan k) (* (sin k) (/ (pow t 3.0) (* l l))))))
INFINITY)
(* (/ (/ (* 2.0 l) (* (sin k) (pow t 3.0))) (tan k)) (/ l (+ 2.0 t_1)))
(* (* (/ l (pow k 2.0)) (/ 2.0 t)) (/ (/ l (sin k)) (tan k))))))
double code(double t, double l, double k) {
double t_1 = pow((k / t), 2.0);
double tmp;
if ((2.0 / ((1.0 + (t_1 + 1.0)) * (tan(k) * (sin(k) * (pow(t, 3.0) / (l * l)))))) <= ((double) INFINITY)) {
tmp = (((2.0 * l) / (sin(k) * pow(t, 3.0))) / tan(k)) * (l / (2.0 + t_1));
} else {
tmp = ((l / pow(k, 2.0)) * (2.0 / t)) * ((l / sin(k)) / tan(k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k / t), 2.0);
double tmp;
if ((2.0 / ((1.0 + (t_1 + 1.0)) * (Math.tan(k) * (Math.sin(k) * (Math.pow(t, 3.0) / (l * l)))))) <= Double.POSITIVE_INFINITY) {
tmp = (((2.0 * l) / (Math.sin(k) * Math.pow(t, 3.0))) / Math.tan(k)) * (l / (2.0 + t_1));
} else {
tmp = ((l / Math.pow(k, 2.0)) * (2.0 / t)) * ((l / Math.sin(k)) / Math.tan(k));
}
return tmp;
}
def code(t, l, k): t_1 = math.pow((k / t), 2.0) tmp = 0 if (2.0 / ((1.0 + (t_1 + 1.0)) * (math.tan(k) * (math.sin(k) * (math.pow(t, 3.0) / (l * l)))))) <= math.inf: tmp = (((2.0 * l) / (math.sin(k) * math.pow(t, 3.0))) / math.tan(k)) * (l / (2.0 + t_1)) else: tmp = ((l / math.pow(k, 2.0)) * (2.0 / t)) * ((l / math.sin(k)) / math.tan(k)) return tmp
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 tmp = 0.0 if (Float64(2.0 / Float64(Float64(1.0 + Float64(t_1 + 1.0)) * Float64(tan(k) * Float64(sin(k) * Float64((t ^ 3.0) / Float64(l * l)))))) <= Inf) tmp = Float64(Float64(Float64(Float64(2.0 * l) / Float64(sin(k) * (t ^ 3.0))) / tan(k)) * Float64(l / Float64(2.0 + t_1))); else tmp = Float64(Float64(Float64(l / (k ^ 2.0)) * Float64(2.0 / t)) * Float64(Float64(l / sin(k)) / tan(k))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = (k / t) ^ 2.0; tmp = 0.0; if ((2.0 / ((1.0 + (t_1 + 1.0)) * (tan(k) * (sin(k) * ((t ^ 3.0) / (l * l)))))) <= Inf) tmp = (((2.0 * l) / (sin(k) * (t ^ 3.0))) / tan(k)) * (l / (2.0 + t_1)); else tmp = ((l / (k ^ 2.0)) * (2.0 / t)) * ((l / sin(k)) / tan(k)); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[N[(2.0 / N[(N[(1.0 + N[(t$95$1 + 1.0), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t, 3.0], $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], Infinity], N[(N[(N[(N[(2.0 * l), $MachinePrecision] / N[(N[Sin[k], $MachinePrecision] * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(l / N[(2.0 + t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(l / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
\mathbf{if}\;\frac{2}{\left(1 + \left(t_1 + 1\right)\right) \cdot \left(\tan k \cdot \left(\sin k \cdot \frac{{t}^{3}}{\ell \cdot \ell}\right)\right)} \leq \infty:\\
\;\;\;\;\frac{\frac{2 \cdot \ell}{\sin k \cdot {t}^{3}}}{\tan k} \cdot \frac{\ell}{2 + t_1}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{\ell}{{k}^{2}} \cdot \frac{2}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\end{array}
\end{array}
if (/.f64 2 (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t 3) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (+.f64 (+.f64 1 (pow.f64 (/.f64 k t) 2)) 1))) < +inf.0Initial program 80.6%
Simplified74.1%
associate-*r*77.4%
*-commutative77.4%
times-frac80.6%
Applied egg-rr80.6%
expm1-log1p-u63.2%
expm1-udef59.0%
times-frac65.3%
Applied egg-rr65.3%
expm1-def70.6%
expm1-log1p88.1%
associate-*r/88.1%
associate-/l/88.2%
associate-*l/88.7%
Simplified88.7%
if +inf.0 < (/.f64 2 (*.f64 (*.f64 (*.f64 (/.f64 (pow.f64 t 3) (*.f64 l l)) (sin.f64 k)) (tan.f64 k)) (+.f64 (+.f64 1 (pow.f64 (/.f64 k t) 2)) 1))) Initial program 0.0%
Simplified0.0%
associate-*r*11.6%
*-un-lft-identity11.6%
times-frac11.5%
Applied egg-rr11.5%
/-rgt-identity11.5%
associate-*r/11.6%
times-frac11.6%
*-commutative11.6%
associate-/r*11.6%
Simplified11.6%
Taylor expanded in t around 0 49.5%
associate-*r/49.5%
*-commutative49.5%
times-frac54.8%
Simplified54.8%
Final simplification78.3%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (+ 2.0 (pow (/ k t) 2.0))))
(if (<= t -3.9e+211)
(/
(/ 2.0 (* (tan k) (* (sin k) (pow (/ (/ t (cbrt l)) (cbrt l)) 3.0))))
t_1)
(if (or (<= t -1.9e-51) (not (<= t 2.1e-100)))
(/
2.0
(pow
(* (/ t (pow (cbrt l) 2.0)) (cbrt (* t_1 (* (sin k) (tan k)))))
3.0))
(* (* (/ l (pow k 2.0)) (/ 2.0 t)) (/ (/ l (sin k)) (tan k)))))))
double code(double t, double l, double k) {
double t_1 = 2.0 + pow((k / t), 2.0);
double tmp;
if (t <= -3.9e+211) {
tmp = (2.0 / (tan(k) * (sin(k) * pow(((t / cbrt(l)) / cbrt(l)), 3.0)))) / t_1;
} else if ((t <= -1.9e-51) || !(t <= 2.1e-100)) {
tmp = 2.0 / pow(((t / pow(cbrt(l), 2.0)) * cbrt((t_1 * (sin(k) * tan(k))))), 3.0);
} else {
tmp = ((l / pow(k, 2.0)) * (2.0 / t)) * ((l / sin(k)) / tan(k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = 2.0 + Math.pow((k / t), 2.0);
double tmp;
if (t <= -3.9e+211) {
tmp = (2.0 / (Math.tan(k) * (Math.sin(k) * Math.pow(((t / Math.cbrt(l)) / Math.cbrt(l)), 3.0)))) / t_1;
} else if ((t <= -1.9e-51) || !(t <= 2.1e-100)) {
tmp = 2.0 / Math.pow(((t / Math.pow(Math.cbrt(l), 2.0)) * Math.cbrt((t_1 * (Math.sin(k) * Math.tan(k))))), 3.0);
} else {
tmp = ((l / Math.pow(k, 2.0)) * (2.0 / t)) * ((l / Math.sin(k)) / Math.tan(k));
}
return tmp;
}
function code(t, l, k) t_1 = Float64(2.0 + (Float64(k / t) ^ 2.0)) tmp = 0.0 if (t <= -3.9e+211) tmp = Float64(Float64(2.0 / Float64(tan(k) * Float64(sin(k) * (Float64(Float64(t / cbrt(l)) / cbrt(l)) ^ 3.0)))) / t_1); elseif ((t <= -1.9e-51) || !(t <= 2.1e-100)) tmp = Float64(2.0 / (Float64(Float64(t / (cbrt(l) ^ 2.0)) * cbrt(Float64(t_1 * Float64(sin(k) * tan(k))))) ^ 3.0)); else tmp = Float64(Float64(Float64(l / (k ^ 2.0)) * Float64(2.0 / t)) * Float64(Float64(l / sin(k)) / tan(k))); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -3.9e+211], N[(N[(2.0 / N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[Power[N[(N[(t / N[Power[l, 1/3], $MachinePrecision]), $MachinePrecision] / N[Power[l, 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / t$95$1), $MachinePrecision], If[Or[LessEqual[t, -1.9e-51], N[Not[LessEqual[t, 2.1e-100]], $MachinePrecision]], N[(2.0 / N[Power[N[(N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[Power[N[(t$95$1 * N[(N[Sin[k], $MachinePrecision] * N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision], N[(N[(N[(l / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := 2 + {\left(\frac{k}{t}\right)}^{2}\\
\mathbf{if}\;t \leq -3.9 \cdot 10^{+211}:\\
\;\;\;\;\frac{\frac{2}{\tan k \cdot \left(\sin k \cdot {\left(\frac{\frac{t}{\sqrt[3]{\ell}}}{\sqrt[3]{\ell}}\right)}^{3}\right)}}{t_1}\\
\mathbf{elif}\;t \leq -1.9 \cdot 10^{-51} \lor \neg \left(t \leq 2.1 \cdot 10^{-100}\right):\\
\;\;\;\;\frac{2}{{\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}} \cdot \sqrt[3]{t_1 \cdot \left(\sin k \cdot \tan k\right)}\right)}^{3}}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{\ell}{{k}^{2}} \cdot \frac{2}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\end{array}
\end{array}
if t < -3.90000000000000023e211Initial program 70.6%
Simplified80.7%
add-cube-cbrt80.7%
pow280.7%
cbrt-div80.7%
rem-cbrt-cube80.7%
cbrt-div80.7%
rem-cbrt-cube80.7%
Applied egg-rr80.7%
add-cube-cbrt80.7%
pow380.7%
cbrt-div80.7%
unpow280.7%
add-cbrt-cube86.0%
Applied egg-rr86.0%
if -3.90000000000000023e211 < t < -1.90000000000000001e-51 or 2.10000000000000009e-100 < t Initial program 64.4%
associate-/r*70.8%
add-cube-cbrt70.7%
*-un-lft-identity70.7%
times-frac70.7%
pow270.7%
cbrt-div70.6%
rem-cbrt-cube70.7%
cbrt-div70.6%
rem-cbrt-cube79.4%
Applied egg-rr79.4%
distribute-lft-in79.4%
associate-*l*75.0%
frac-times71.6%
pow-plus71.6%
metadata-eval71.6%
*-un-lft-identity71.6%
Applied egg-rr71.5%
distribute-lft-out71.5%
+-commutative71.5%
associate-+r+71.5%
metadata-eval71.5%
associate-*l*71.5%
Simplified71.5%
add-cube-cbrt71.5%
pow371.5%
cbrt-prod71.5%
cbrt-div75.5%
unpow375.4%
add-cbrt-cube83.0%
associate-/l/83.0%
pow283.0%
Applied egg-rr83.0%
if -1.90000000000000001e-51 < t < 2.10000000000000009e-100Initial program 41.2%
Simplified40.1%
associate-*r*46.3%
*-un-lft-identity46.3%
times-frac46.3%
Applied egg-rr46.3%
/-rgt-identity46.3%
associate-*r/46.3%
times-frac46.4%
*-commutative46.4%
associate-/r*46.4%
Simplified46.4%
Taylor expanded in t around 0 78.8%
associate-*r/78.8%
*-commutative78.8%
times-frac83.9%
Simplified83.9%
Final simplification83.5%
(FPCore (t l k)
:precision binary64
(if (or (<= t -2e-51) (not (<= t 2.7e-91)))
(/
2.0
(*
(* (tan k) (pow (* (/ t (pow (cbrt l) 2.0)) (cbrt (sin k))) 3.0))
(+ 1.0 (+ (pow (/ k t) 2.0) 1.0))))
(* (* (/ l (pow k 2.0)) (/ 2.0 t)) (/ (/ l (sin k)) (tan k)))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -2e-51) || !(t <= 2.7e-91)) {
tmp = 2.0 / ((tan(k) * pow(((t / pow(cbrt(l), 2.0)) * cbrt(sin(k))), 3.0)) * (1.0 + (pow((k / t), 2.0) + 1.0)));
} else {
tmp = ((l / pow(k, 2.0)) * (2.0 / t)) * ((l / sin(k)) / tan(k));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -2e-51) || !(t <= 2.7e-91)) {
tmp = 2.0 / ((Math.tan(k) * Math.pow(((t / Math.pow(Math.cbrt(l), 2.0)) * Math.cbrt(Math.sin(k))), 3.0)) * (1.0 + (Math.pow((k / t), 2.0) + 1.0)));
} else {
tmp = ((l / Math.pow(k, 2.0)) * (2.0 / t)) * ((l / Math.sin(k)) / Math.tan(k));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if ((t <= -2e-51) || !(t <= 2.7e-91)) tmp = Float64(2.0 / Float64(Float64(tan(k) * (Float64(Float64(t / (cbrt(l) ^ 2.0)) * cbrt(sin(k))) ^ 3.0)) * Float64(1.0 + Float64((Float64(k / t) ^ 2.0) + 1.0)))); else tmp = Float64(Float64(Float64(l / (k ^ 2.0)) * Float64(2.0 / t)) * Float64(Float64(l / sin(k)) / tan(k))); end return tmp end
code[t_, l_, k_] := If[Or[LessEqual[t, -2e-51], N[Not[LessEqual[t, 2.7e-91]], $MachinePrecision]], N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[Power[N[(N[(t / N[Power[N[Power[l, 1/3], $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] * N[Power[N[Sin[k], $MachinePrecision], 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision]), $MachinePrecision] * N[(1.0 + N[(N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision] + 1.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(l / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -2 \cdot 10^{-51} \lor \neg \left(t \leq 2.7 \cdot 10^{-91}\right):\\
\;\;\;\;\frac{2}{\left(\tan k \cdot {\left(\frac{t}{{\left(\sqrt[3]{\ell}\right)}^{2}} \cdot \sqrt[3]{\sin k}\right)}^{3}\right) \cdot \left(1 + \left({\left(\frac{k}{t}\right)}^{2} + 1\right)\right)}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{\ell}{{k}^{2}} \cdot \frac{2}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\end{array}
\end{array}
if t < -2e-51 or 2.6999999999999997e-91 < t Initial program 65.3%
associate-/r*72.2%
add-cube-cbrt72.1%
*-un-lft-identity72.1%
times-frac72.1%
pow272.1%
cbrt-div72.0%
rem-cbrt-cube72.1%
cbrt-div72.0%
rem-cbrt-cube79.9%
Applied egg-rr79.9%
/-rgt-identity79.9%
associate-*r/76.3%
add-cube-cbrt76.3%
pow376.3%
cbrt-prod76.3%
cbrt-div78.5%
unpow278.5%
add-cbrt-cube88.1%
Applied egg-rr88.1%
expm1-log1p-u51.9%
expm1-udef41.0%
associate-/l/41.0%
pow241.0%
Applied egg-rr41.0%
expm1-def51.9%
expm1-log1p88.2%
Simplified88.2%
if -2e-51 < t < 2.6999999999999997e-91Initial program 41.4%
Simplified40.3%
associate-*r*46.4%
*-un-lft-identity46.4%
times-frac46.4%
Applied egg-rr46.4%
/-rgt-identity46.4%
associate-*r/46.4%
times-frac46.4%
*-commutative46.4%
associate-/r*46.4%
Simplified46.4%
Taylor expanded in t around 0 78.2%
associate-*r/78.2%
*-commutative78.2%
times-frac83.2%
Simplified83.2%
Final simplification86.2%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (/ t (cbrt l)))
(t_2
(/
2.0
(*
(* (tan k) (* (sin k) (* (pow t_1 2.0) (/ t_1 l))))
(+ 1.0 (+ 1.0 (* (/ k t) (/ k t))))))))
(if (<= t -26000000000.0)
t_2
(if (<= t 5.4e-56)
(* (* (/ l (pow k 2.0)) (/ 2.0 t)) (/ (/ l (sin k)) (tan k)))
(if (<= t 5.6e+102)
(*
(/ (/ (* 2.0 l) (* (sin k) (pow t 3.0))) (tan k))
(/ l (+ 2.0 (pow (/ k t) 2.0))))
t_2)))))
double code(double t, double l, double k) {
double t_1 = t / cbrt(l);
double t_2 = 2.0 / ((tan(k) * (sin(k) * (pow(t_1, 2.0) * (t_1 / l)))) * (1.0 + (1.0 + ((k / t) * (k / t)))));
double tmp;
if (t <= -26000000000.0) {
tmp = t_2;
} else if (t <= 5.4e-56) {
tmp = ((l / pow(k, 2.0)) * (2.0 / t)) * ((l / sin(k)) / tan(k));
} else if (t <= 5.6e+102) {
tmp = (((2.0 * l) / (sin(k) * pow(t, 3.0))) / tan(k)) * (l / (2.0 + pow((k / t), 2.0)));
} else {
tmp = t_2;
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = t / Math.cbrt(l);
double t_2 = 2.0 / ((Math.tan(k) * (Math.sin(k) * (Math.pow(t_1, 2.0) * (t_1 / l)))) * (1.0 + (1.0 + ((k / t) * (k / t)))));
double tmp;
if (t <= -26000000000.0) {
tmp = t_2;
} else if (t <= 5.4e-56) {
tmp = ((l / Math.pow(k, 2.0)) * (2.0 / t)) * ((l / Math.sin(k)) / Math.tan(k));
} else if (t <= 5.6e+102) {
tmp = (((2.0 * l) / (Math.sin(k) * Math.pow(t, 3.0))) / Math.tan(k)) * (l / (2.0 + Math.pow((k / t), 2.0)));
} else {
tmp = t_2;
}
return tmp;
}
function code(t, l, k) t_1 = Float64(t / cbrt(l)) t_2 = Float64(2.0 / Float64(Float64(tan(k) * Float64(sin(k) * Float64((t_1 ^ 2.0) * Float64(t_1 / l)))) * Float64(1.0 + Float64(1.0 + Float64(Float64(k / t) * Float64(k / t)))))) tmp = 0.0 if (t <= -26000000000.0) tmp = t_2; elseif (t <= 5.4e-56) tmp = Float64(Float64(Float64(l / (k ^ 2.0)) * Float64(2.0 / t)) * Float64(Float64(l / sin(k)) / tan(k))); elseif (t <= 5.6e+102) tmp = Float64(Float64(Float64(Float64(2.0 * l) / Float64(sin(k) * (t ^ 3.0))) / tan(k)) * Float64(l / Float64(2.0 + (Float64(k / t) ^ 2.0)))); else tmp = t_2; end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(t / N[Power[l, 1/3], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(2.0 / N[(N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[Power[t$95$1, 2.0], $MachinePrecision] * N[(t$95$1 / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(1.0 + N[(1.0 + N[(N[(k / t), $MachinePrecision] * N[(k / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -26000000000.0], t$95$2, If[LessEqual[t, 5.4e-56], N[(N[(N[(l / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 5.6e+102], N[(N[(N[(N[(2.0 * l), $MachinePrecision] / N[(N[Sin[k], $MachinePrecision] * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(l / N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], t$95$2]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{t}{\sqrt[3]{\ell}}\\
t_2 := \frac{2}{\left(\tan k \cdot \left(\sin k \cdot \left({t_1}^{2} \cdot \frac{t_1}{\ell}\right)\right)\right) \cdot \left(1 + \left(1 + \frac{k}{t} \cdot \frac{k}{t}\right)\right)}\\
\mathbf{if}\;t \leq -26000000000:\\
\;\;\;\;t_2\\
\mathbf{elif}\;t \leq 5.4 \cdot 10^{-56}:\\
\;\;\;\;\left(\frac{\ell}{{k}^{2}} \cdot \frac{2}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\mathbf{elif}\;t \leq 5.6 \cdot 10^{+102}:\\
\;\;\;\;\frac{\frac{2 \cdot \ell}{\sin k \cdot {t}^{3}}}{\tan k} \cdot \frac{\ell}{2 + {\left(\frac{k}{t}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;t_2\\
\end{array}
\end{array}
if t < -2.6e10 or 5.60000000000000037e102 < t Initial program 64.5%
associate-/r*70.0%
add-cube-cbrt70.0%
*-un-lft-identity70.0%
times-frac69.9%
pow269.9%
cbrt-div69.9%
rem-cbrt-cube70.0%
cbrt-div70.0%
rem-cbrt-cube81.3%
Applied egg-rr81.3%
unpow281.3%
Applied egg-rr81.3%
if -2.6e10 < t < 5.3999999999999999e-56Initial program 44.5%
Simplified43.6%
associate-*r*50.3%
*-un-lft-identity50.3%
times-frac51.1%
Applied egg-rr51.1%
/-rgt-identity51.1%
associate-*r/50.3%
times-frac51.1%
*-commutative51.1%
associate-/r*51.9%
Simplified51.9%
Taylor expanded in t around 0 76.3%
associate-*r/76.3%
*-commutative76.3%
times-frac80.5%
Simplified80.5%
if 5.3999999999999999e-56 < t < 5.60000000000000037e102Initial program 71.8%
Simplified67.9%
associate-*r*74.8%
*-commutative74.8%
times-frac88.8%
Applied egg-rr88.8%
expm1-log1p-u66.3%
expm1-udef52.5%
times-frac56.3%
Applied egg-rr56.3%
expm1-def77.2%
expm1-log1p99.6%
associate-*r/99.7%
associate-/l/99.8%
associate-*l/99.9%
Simplified99.9%
Final simplification82.9%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (/ 2.0 (pow t 3.0))) (t_2 (/ (/ l (sin k)) (tan k))))
(if (<= t -1.8e+212)
(* (* 0.5 (/ (pow l 2.0) k)) (/ t_1 (tan k)))
(if (<= t -5.5e+102)
(/ (pow (/ (cbrt (* 2.0 (pow l 2.0))) t) 3.0) (* 2.0 (pow k 2.0)))
(if (or (<= t -2.1e-51) (not (<= t 8e-91)))
(* t_2 (/ (* l t_1) (+ 2.0 (pow (/ k t) 2.0))))
(* (* (/ l (pow k 2.0)) (/ 2.0 t)) t_2))))))
double code(double t, double l, double k) {
double t_1 = 2.0 / pow(t, 3.0);
double t_2 = (l / sin(k)) / tan(k);
double tmp;
if (t <= -1.8e+212) {
tmp = (0.5 * (pow(l, 2.0) / k)) * (t_1 / tan(k));
} else if (t <= -5.5e+102) {
tmp = pow((cbrt((2.0 * pow(l, 2.0))) / t), 3.0) / (2.0 * pow(k, 2.0));
} else if ((t <= -2.1e-51) || !(t <= 8e-91)) {
tmp = t_2 * ((l * t_1) / (2.0 + pow((k / t), 2.0)));
} else {
tmp = ((l / pow(k, 2.0)) * (2.0 / t)) * t_2;
}
return tmp;
}
public static double code(double t, double l, double k) {
double t_1 = 2.0 / Math.pow(t, 3.0);
double t_2 = (l / Math.sin(k)) / Math.tan(k);
double tmp;
if (t <= -1.8e+212) {
tmp = (0.5 * (Math.pow(l, 2.0) / k)) * (t_1 / Math.tan(k));
} else if (t <= -5.5e+102) {
tmp = Math.pow((Math.cbrt((2.0 * Math.pow(l, 2.0))) / t), 3.0) / (2.0 * Math.pow(k, 2.0));
} else if ((t <= -2.1e-51) || !(t <= 8e-91)) {
tmp = t_2 * ((l * t_1) / (2.0 + Math.pow((k / t), 2.0)));
} else {
tmp = ((l / Math.pow(k, 2.0)) * (2.0 / t)) * t_2;
}
return tmp;
}
function code(t, l, k) t_1 = Float64(2.0 / (t ^ 3.0)) t_2 = Float64(Float64(l / sin(k)) / tan(k)) tmp = 0.0 if (t <= -1.8e+212) tmp = Float64(Float64(0.5 * Float64((l ^ 2.0) / k)) * Float64(t_1 / tan(k))); elseif (t <= -5.5e+102) tmp = Float64((Float64(cbrt(Float64(2.0 * (l ^ 2.0))) / t) ^ 3.0) / Float64(2.0 * (k ^ 2.0))); elseif ((t <= -2.1e-51) || !(t <= 8e-91)) tmp = Float64(t_2 * Float64(Float64(l * t_1) / Float64(2.0 + (Float64(k / t) ^ 2.0)))); else tmp = Float64(Float64(Float64(l / (k ^ 2.0)) * Float64(2.0 / t)) * t_2); end return tmp end
code[t_, l_, k_] := Block[{t$95$1 = N[(2.0 / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]}, Block[{t$95$2 = N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[t, -1.8e+212], N[(N[(0.5 * N[(N[Power[l, 2.0], $MachinePrecision] / k), $MachinePrecision]), $MachinePrecision] * N[(t$95$1 / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, -5.5e+102], N[(N[Power[N[(N[Power[N[(2.0 * N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision], 1/3], $MachinePrecision] / t), $MachinePrecision], 3.0], $MachinePrecision] / N[(2.0 * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[Or[LessEqual[t, -2.1e-51], N[Not[LessEqual[t, 8e-91]], $MachinePrecision]], N[(t$95$2 * N[(N[(l * t$95$1), $MachinePrecision] / N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(l / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / t), $MachinePrecision]), $MachinePrecision] * t$95$2), $MachinePrecision]]]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{2}{{t}^{3}}\\
t_2 := \frac{\frac{\ell}{\sin k}}{\tan k}\\
\mathbf{if}\;t \leq -1.8 \cdot 10^{+212}:\\
\;\;\;\;\left(0.5 \cdot \frac{{\ell}^{2}}{k}\right) \cdot \frac{t_1}{\tan k}\\
\mathbf{elif}\;t \leq -5.5 \cdot 10^{+102}:\\
\;\;\;\;\frac{{\left(\frac{\sqrt[3]{2 \cdot {\ell}^{2}}}{t}\right)}^{3}}{2 \cdot {k}^{2}}\\
\mathbf{elif}\;t \leq -2.1 \cdot 10^{-51} \lor \neg \left(t \leq 8 \cdot 10^{-91}\right):\\
\;\;\;\;t_2 \cdot \frac{\ell \cdot t_1}{2 + {\left(\frac{k}{t}\right)}^{2}}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{\ell}{{k}^{2}} \cdot \frac{2}{t}\right) \cdot t_2\\
\end{array}
\end{array}
if t < -1.8e212Initial program 70.6%
Simplified35.3%
*-commutative35.3%
associate-*r*35.3%
times-frac70.6%
pow270.6%
Applied egg-rr70.6%
Taylor expanded in k around 0 70.6%
if -1.8e212 < t < -5.49999999999999981e102Initial program 49.9%
Simplified49.3%
Taylor expanded in k around 0 49.3%
add-cube-cbrt49.3%
pow249.3%
cbrt-div49.3%
associate-*l/49.3%
cbrt-div49.3%
pow249.3%
unpow349.3%
add-cbrt-cube49.3%
cbrt-div49.3%
Applied egg-rr71.8%
pow-plus71.8%
metadata-eval71.8%
cube-div63.4%
rem-cube-cbrt63.6%
Simplified63.6%
if -5.49999999999999981e102 < t < -2.10000000000000002e-51 or 8.00000000000000018e-91 < t Initial program 68.5%
Simplified64.6%
associate-*r*71.0%
*-un-lft-identity71.0%
times-frac77.2%
Applied egg-rr77.2%
/-rgt-identity77.2%
associate-*r/71.0%
times-frac77.2%
*-commutative77.2%
associate-/r*80.0%
Simplified80.0%
if -2.10000000000000002e-51 < t < 8.00000000000000018e-91Initial program 41.4%
Simplified40.3%
associate-*r*46.4%
*-un-lft-identity46.4%
times-frac46.4%
Applied egg-rr46.4%
/-rgt-identity46.4%
associate-*r/46.4%
times-frac46.4%
*-commutative46.4%
associate-/r*46.4%
Simplified46.4%
Taylor expanded in t around 0 78.2%
associate-*r/78.2%
*-commutative78.2%
times-frac83.2%
Simplified83.2%
Final simplification78.8%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (/ k t) 2.0)))
(if (<= t -9000000000.0)
(/
2.0
(*
(+ 1.0 (+ t_1 1.0))
(* (tan k) (* (sin k) (* (/ (pow t 2.0) l) (/ t l))))))
(if (<= t 7e-50)
(* (* (/ l (pow k 2.0)) (/ 2.0 t)) (/ (/ l (sin k)) (tan k)))
(*
(/ (/ (* 2.0 l) (* (sin k) (pow t 3.0))) (tan k))
(/ l (+ 2.0 t_1)))))))
double code(double t, double l, double k) {
double t_1 = pow((k / t), 2.0);
double tmp;
if (t <= -9000000000.0) {
tmp = 2.0 / ((1.0 + (t_1 + 1.0)) * (tan(k) * (sin(k) * ((pow(t, 2.0) / l) * (t / l)))));
} else if (t <= 7e-50) {
tmp = ((l / pow(k, 2.0)) * (2.0 / t)) * ((l / sin(k)) / tan(k));
} else {
tmp = (((2.0 * l) / (sin(k) * pow(t, 3.0))) / tan(k)) * (l / (2.0 + t_1));
}
return tmp;
}
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 = (k / t) ** 2.0d0
if (t <= (-9000000000.0d0)) then
tmp = 2.0d0 / ((1.0d0 + (t_1 + 1.0d0)) * (tan(k) * (sin(k) * (((t ** 2.0d0) / l) * (t / l)))))
else if (t <= 7d-50) then
tmp = ((l / (k ** 2.0d0)) * (2.0d0 / t)) * ((l / sin(k)) / tan(k))
else
tmp = (((2.0d0 * l) / (sin(k) * (t ** 3.0d0))) / tan(k)) * (l / (2.0d0 + t_1))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k / t), 2.0);
double tmp;
if (t <= -9000000000.0) {
tmp = 2.0 / ((1.0 + (t_1 + 1.0)) * (Math.tan(k) * (Math.sin(k) * ((Math.pow(t, 2.0) / l) * (t / l)))));
} else if (t <= 7e-50) {
tmp = ((l / Math.pow(k, 2.0)) * (2.0 / t)) * ((l / Math.sin(k)) / Math.tan(k));
} else {
tmp = (((2.0 * l) / (Math.sin(k) * Math.pow(t, 3.0))) / Math.tan(k)) * (l / (2.0 + t_1));
}
return tmp;
}
def code(t, l, k): t_1 = math.pow((k / t), 2.0) tmp = 0 if t <= -9000000000.0: tmp = 2.0 / ((1.0 + (t_1 + 1.0)) * (math.tan(k) * (math.sin(k) * ((math.pow(t, 2.0) / l) * (t / l))))) elif t <= 7e-50: tmp = ((l / math.pow(k, 2.0)) * (2.0 / t)) * ((l / math.sin(k)) / math.tan(k)) else: tmp = (((2.0 * l) / (math.sin(k) * math.pow(t, 3.0))) / math.tan(k)) * (l / (2.0 + t_1)) return tmp
function code(t, l, k) t_1 = Float64(k / t) ^ 2.0 tmp = 0.0 if (t <= -9000000000.0) tmp = Float64(2.0 / Float64(Float64(1.0 + Float64(t_1 + 1.0)) * Float64(tan(k) * Float64(sin(k) * Float64(Float64((t ^ 2.0) / l) * Float64(t / l)))))); elseif (t <= 7e-50) tmp = Float64(Float64(Float64(l / (k ^ 2.0)) * Float64(2.0 / t)) * Float64(Float64(l / sin(k)) / tan(k))); else tmp = Float64(Float64(Float64(Float64(2.0 * l) / Float64(sin(k) * (t ^ 3.0))) / tan(k)) * Float64(l / Float64(2.0 + t_1))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = (k / t) ^ 2.0; tmp = 0.0; if (t <= -9000000000.0) tmp = 2.0 / ((1.0 + (t_1 + 1.0)) * (tan(k) * (sin(k) * (((t ^ 2.0) / l) * (t / l))))); elseif (t <= 7e-50) tmp = ((l / (k ^ 2.0)) * (2.0 / t)) * ((l / sin(k)) / tan(k)); else tmp = (((2.0 * l) / (sin(k) * (t ^ 3.0))) / tan(k)) * (l / (2.0 + t_1)); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[t, -9000000000.0], N[(2.0 / N[(N[(1.0 + N[(t$95$1 + 1.0), $MachinePrecision]), $MachinePrecision] * N[(N[Tan[k], $MachinePrecision] * N[(N[Sin[k], $MachinePrecision] * N[(N[(N[Power[t, 2.0], $MachinePrecision] / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], If[LessEqual[t, 7e-50], N[(N[(N[(l / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(N[(2.0 * l), $MachinePrecision] / N[(N[Sin[k], $MachinePrecision] * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(l / N[(2.0 + t$95$1), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(\frac{k}{t}\right)}^{2}\\
\mathbf{if}\;t \leq -9000000000:\\
\;\;\;\;\frac{2}{\left(1 + \left(t_1 + 1\right)\right) \cdot \left(\tan k \cdot \left(\sin k \cdot \left(\frac{{t}^{2}}{\ell} \cdot \frac{t}{\ell}\right)\right)\right)}\\
\mathbf{elif}\;t \leq 7 \cdot 10^{-50}:\\
\;\;\;\;\left(\frac{\ell}{{k}^{2}} \cdot \frac{2}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{2 \cdot \ell}{\sin k \cdot {t}^{3}}}{\tan k} \cdot \frac{\ell}{2 + t_1}\\
\end{array}
\end{array}
if t < -9e9Initial program 61.6%
unpow361.6%
times-frac75.8%
pow275.8%
Applied egg-rr75.8%
if -9e9 < t < 6.99999999999999993e-50Initial program 44.5%
Simplified43.6%
associate-*r*50.3%
*-un-lft-identity50.3%
times-frac51.1%
Applied egg-rr51.1%
/-rgt-identity51.1%
associate-*r/50.3%
times-frac51.1%
*-commutative51.1%
associate-/r*51.9%
Simplified51.9%
Taylor expanded in t around 0 76.3%
associate-*r/76.3%
*-commutative76.3%
times-frac80.5%
Simplified80.5%
if 6.99999999999999993e-50 < t Initial program 70.3%
Simplified65.5%
associate-*r*70.0%
*-commutative70.0%
times-frac75.6%
Applied egg-rr75.6%
expm1-log1p-u66.6%
expm1-udef61.1%
times-frac65.8%
Applied egg-rr65.8%
expm1-def74.1%
expm1-log1p83.0%
associate-*r/83.2%
associate-/l/83.2%
associate-*l/83.2%
Simplified83.2%
Final simplification80.0%
(FPCore (t l k)
:precision binary64
(if (or (<= t -1.8e-51) (not (<= t 1.2e-91)))
(*
(/ (* l (/ 2.0 (pow t 3.0))) (* (sin k) (+ 2.0 (pow (/ k t) 2.0))))
(/ l (tan k)))
(* (* (/ l (pow k 2.0)) (/ 2.0 t)) (/ (/ l (sin k)) (tan k)))))
double code(double t, double l, double k) {
double tmp;
if ((t <= -1.8e-51) || !(t <= 1.2e-91)) {
tmp = ((l * (2.0 / pow(t, 3.0))) / (sin(k) * (2.0 + pow((k / t), 2.0)))) * (l / tan(k));
} else {
tmp = ((l / pow(k, 2.0)) * (2.0 / t)) * ((l / sin(k)) / tan(k));
}
return tmp;
}
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 ((t <= (-1.8d-51)) .or. (.not. (t <= 1.2d-91))) then
tmp = ((l * (2.0d0 / (t ** 3.0d0))) / (sin(k) * (2.0d0 + ((k / t) ** 2.0d0)))) * (l / tan(k))
else
tmp = ((l / (k ** 2.0d0)) * (2.0d0 / t)) * ((l / sin(k)) / tan(k))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if ((t <= -1.8e-51) || !(t <= 1.2e-91)) {
tmp = ((l * (2.0 / Math.pow(t, 3.0))) / (Math.sin(k) * (2.0 + Math.pow((k / t), 2.0)))) * (l / Math.tan(k));
} else {
tmp = ((l / Math.pow(k, 2.0)) * (2.0 / t)) * ((l / Math.sin(k)) / Math.tan(k));
}
return tmp;
}
def code(t, l, k): tmp = 0 if (t <= -1.8e-51) or not (t <= 1.2e-91): tmp = ((l * (2.0 / math.pow(t, 3.0))) / (math.sin(k) * (2.0 + math.pow((k / t), 2.0)))) * (l / math.tan(k)) else: tmp = ((l / math.pow(k, 2.0)) * (2.0 / t)) * ((l / math.sin(k)) / math.tan(k)) return tmp
function code(t, l, k) tmp = 0.0 if ((t <= -1.8e-51) || !(t <= 1.2e-91)) tmp = Float64(Float64(Float64(l * Float64(2.0 / (t ^ 3.0))) / Float64(sin(k) * Float64(2.0 + (Float64(k / t) ^ 2.0)))) * Float64(l / tan(k))); else tmp = Float64(Float64(Float64(l / (k ^ 2.0)) * Float64(2.0 / t)) * Float64(Float64(l / sin(k)) / tan(k))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if ((t <= -1.8e-51) || ~((t <= 1.2e-91))) tmp = ((l * (2.0 / (t ^ 3.0))) / (sin(k) * (2.0 + ((k / t) ^ 2.0)))) * (l / tan(k)); else tmp = ((l / (k ^ 2.0)) * (2.0 / t)) * ((l / sin(k)) / tan(k)); end tmp_2 = tmp; end
code[t_, l_, k_] := If[Or[LessEqual[t, -1.8e-51], N[Not[LessEqual[t, 1.2e-91]], $MachinePrecision]], N[(N[(N[(l * N[(2.0 / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(N[Sin[k], $MachinePrecision] * N[(2.0 + N[Power[N[(k / t), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] * N[(l / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[(l / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(2.0 / t), $MachinePrecision]), $MachinePrecision] * N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;t \leq -1.8 \cdot 10^{-51} \lor \neg \left(t \leq 1.2 \cdot 10^{-91}\right):\\
\;\;\;\;\frac{\ell \cdot \frac{2}{{t}^{3}}}{\sin k \cdot \left(2 + {\left(\frac{k}{t}\right)}^{2}\right)} \cdot \frac{\ell}{\tan k}\\
\mathbf{else}:\\
\;\;\;\;\left(\frac{\ell}{{k}^{2}} \cdot \frac{2}{t}\right) \cdot \frac{\frac{\ell}{\sin k}}{\tan k}\\
\end{array}
\end{array}
if t < -1.8e-51 or 1.20000000000000005e-91 < t Initial program 65.3%
Simplified58.5%
associate-*r*64.1%
associate-*r*64.2%
times-frac76.4%
Applied egg-rr76.4%
if -1.8e-51 < t < 1.20000000000000005e-91Initial program 41.4%
Simplified40.3%
associate-*r*46.4%
*-un-lft-identity46.4%
times-frac46.4%
Applied egg-rr46.4%
/-rgt-identity46.4%
associate-*r/46.4%
times-frac46.4%
*-commutative46.4%
associate-/r*46.4%
Simplified46.4%
Taylor expanded in t around 0 78.2%
associate-*r/78.2%
*-commutative78.2%
times-frac83.2%
Simplified83.2%
Final simplification79.1%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (/ (/ l (sin k)) (tan k))))
(if (<= k 1.04e-20)
(* t_1 (/ l (pow t 3.0)))
(* t_1 (* 2.0 (/ l (* t (pow k 2.0))))))))
double code(double t, double l, double k) {
double t_1 = (l / sin(k)) / tan(k);
double tmp;
if (k <= 1.04e-20) {
tmp = t_1 * (l / pow(t, 3.0));
} else {
tmp = t_1 * (2.0 * (l / (t * pow(k, 2.0))));
}
return tmp;
}
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 = (l / sin(k)) / tan(k)
if (k <= 1.04d-20) then
tmp = t_1 * (l / (t ** 3.0d0))
else
tmp = t_1 * (2.0d0 * (l / (t * (k ** 2.0d0))))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = (l / Math.sin(k)) / Math.tan(k);
double tmp;
if (k <= 1.04e-20) {
tmp = t_1 * (l / Math.pow(t, 3.0));
} else {
tmp = t_1 * (2.0 * (l / (t * Math.pow(k, 2.0))));
}
return tmp;
}
def code(t, l, k): t_1 = (l / math.sin(k)) / math.tan(k) tmp = 0 if k <= 1.04e-20: tmp = t_1 * (l / math.pow(t, 3.0)) else: tmp = t_1 * (2.0 * (l / (t * math.pow(k, 2.0)))) return tmp
function code(t, l, k) t_1 = Float64(Float64(l / sin(k)) / tan(k)) tmp = 0.0 if (k <= 1.04e-20) tmp = Float64(t_1 * Float64(l / (t ^ 3.0))); else tmp = Float64(t_1 * Float64(2.0 * Float64(l / Float64(t * (k ^ 2.0))))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = (l / sin(k)) / tan(k); tmp = 0.0; if (k <= 1.04e-20) tmp = t_1 * (l / (t ^ 3.0)); else tmp = t_1 * (2.0 * (l / (t * (k ^ 2.0)))); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision]}, If[LessEqual[k, 1.04e-20], N[(t$95$1 * N[(l / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(t$95$1 * N[(2.0 * N[(l / N[(t * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := \frac{\frac{\ell}{\sin k}}{\tan k}\\
\mathbf{if}\;k \leq 1.04 \cdot 10^{-20}:\\
\;\;\;\;t_1 \cdot \frac{\ell}{{t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;t_1 \cdot \left(2 \cdot \frac{\ell}{t \cdot {k}^{2}}\right)\\
\end{array}
\end{array}
if k < 1.04000000000000007e-20Initial program 58.7%
Simplified53.4%
associate-*r*59.6%
*-un-lft-identity59.6%
times-frac62.4%
Applied egg-rr62.4%
/-rgt-identity62.4%
associate-*r/59.6%
times-frac62.5%
*-commutative62.5%
associate-/r*66.0%
Simplified66.0%
Taylor expanded in t around inf 63.2%
if 1.04000000000000007e-20 < k Initial program 46.2%
Simplified44.4%
associate-*r*48.9%
*-un-lft-identity48.9%
times-frac50.6%
Applied egg-rr50.6%
/-rgt-identity50.6%
associate-*r/48.9%
times-frac50.6%
*-commutative50.6%
associate-/r*50.5%
Simplified50.5%
Taylor expanded in t around 0 67.5%
Final simplification64.3%
(FPCore (t l k) :precision binary64 (if (<= k 3.3e+100) (* (/ (/ l (sin k)) (tan k)) (/ l (pow t 3.0))) (/ 2.0 (* (* 2.0 (pow k 2.0)) (/ (pow (/ t (cbrt l)) 3.0) l)))))
double code(double t, double l, double k) {
double tmp;
if (k <= 3.3e+100) {
tmp = ((l / sin(k)) / tan(k)) * (l / pow(t, 3.0));
} else {
tmp = 2.0 / ((2.0 * pow(k, 2.0)) * (pow((t / cbrt(l)), 3.0) / l));
}
return tmp;
}
public static double code(double t, double l, double k) {
double tmp;
if (k <= 3.3e+100) {
tmp = ((l / Math.sin(k)) / Math.tan(k)) * (l / Math.pow(t, 3.0));
} else {
tmp = 2.0 / ((2.0 * Math.pow(k, 2.0)) * (Math.pow((t / Math.cbrt(l)), 3.0) / l));
}
return tmp;
}
function code(t, l, k) tmp = 0.0 if (k <= 3.3e+100) tmp = Float64(Float64(Float64(l / sin(k)) / tan(k)) * Float64(l / (t ^ 3.0))); else tmp = Float64(2.0 / Float64(Float64(2.0 * (k ^ 2.0)) * Float64((Float64(t / cbrt(l)) ^ 3.0) / l))); end return tmp end
code[t_, l_, k_] := If[LessEqual[k, 3.3e+100], N[(N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(2.0 * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[N[(t / N[Power[l, 1/3], $MachinePrecision]), $MachinePrecision], 3.0], $MachinePrecision] / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 3.3 \cdot 10^{+100}:\\
\;\;\;\;\frac{\frac{\ell}{\sin k}}{\tan k} \cdot \frac{\ell}{{t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\left(2 \cdot {k}^{2}\right) \cdot \frac{{\left(\frac{t}{\sqrt[3]{\ell}}\right)}^{3}}{\ell}}\\
\end{array}
\end{array}
if k < 3.3000000000000001e100Initial program 58.2%
Simplified53.5%
associate-*r*59.4%
*-un-lft-identity59.4%
times-frac61.9%
Applied egg-rr61.9%
/-rgt-identity61.9%
associate-*r/59.4%
times-frac62.0%
*-commutative62.0%
associate-/r*65.1%
Simplified65.1%
Taylor expanded in t around inf 63.7%
if 3.3000000000000001e100 < k Initial program 40.3%
associate-/r*47.6%
add-cube-cbrt47.5%
*-un-lft-identity47.5%
times-frac47.5%
pow247.5%
cbrt-div47.6%
rem-cbrt-cube47.6%
cbrt-div47.6%
rem-cbrt-cube55.8%
Applied egg-rr55.8%
distribute-lft-in55.8%
associate-*l*55.7%
frac-times50.2%
pow-plus50.2%
metadata-eval50.2%
*-un-lft-identity50.2%
Applied egg-rr50.2%
distribute-lft-out50.2%
+-commutative50.2%
associate-+r+50.2%
metadata-eval50.2%
associate-*l*50.2%
Simplified50.2%
Taylor expanded in k around 0 39.7%
Final simplification60.4%
(FPCore (t l k) :precision binary64 (if (<= k 3.3e+100) (* (/ (/ l (sin k)) (tan k)) (/ l (pow t 3.0))) (/ (/ (pow l 2.0) (pow k 2.0)) (pow t 3.0))))
double code(double t, double l, double k) {
double tmp;
if (k <= 3.3e+100) {
tmp = ((l / sin(k)) / tan(k)) * (l / pow(t, 3.0));
} else {
tmp = (pow(l, 2.0) / pow(k, 2.0)) / pow(t, 3.0);
}
return tmp;
}
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.3d+100) then
tmp = ((l / sin(k)) / tan(k)) * (l / (t ** 3.0d0))
else
tmp = ((l ** 2.0d0) / (k ** 2.0d0)) / (t ** 3.0d0)
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (k <= 3.3e+100) {
tmp = ((l / Math.sin(k)) / Math.tan(k)) * (l / Math.pow(t, 3.0));
} else {
tmp = (Math.pow(l, 2.0) / Math.pow(k, 2.0)) / Math.pow(t, 3.0);
}
return tmp;
}
def code(t, l, k): tmp = 0 if k <= 3.3e+100: tmp = ((l / math.sin(k)) / math.tan(k)) * (l / math.pow(t, 3.0)) else: tmp = (math.pow(l, 2.0) / math.pow(k, 2.0)) / math.pow(t, 3.0) return tmp
function code(t, l, k) tmp = 0.0 if (k <= 3.3e+100) tmp = Float64(Float64(Float64(l / sin(k)) / tan(k)) * Float64(l / (t ^ 3.0))); else tmp = Float64(Float64((l ^ 2.0) / (k ^ 2.0)) / (t ^ 3.0)); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (k <= 3.3e+100) tmp = ((l / sin(k)) / tan(k)) * (l / (t ^ 3.0)); else tmp = ((l ^ 2.0) / (k ^ 2.0)) / (t ^ 3.0); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[k, 3.3e+100], N[(N[(N[(l / N[Sin[k], $MachinePrecision]), $MachinePrecision] / N[Tan[k], $MachinePrecision]), $MachinePrecision] * N[(l / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;k \leq 3.3 \cdot 10^{+100}:\\
\;\;\;\;\frac{\frac{\ell}{\sin k}}{\tan k} \cdot \frac{\ell}{{t}^{3}}\\
\mathbf{else}:\\
\;\;\;\;\frac{\frac{{\ell}^{2}}{{k}^{2}}}{{t}^{3}}\\
\end{array}
\end{array}
if k < 3.3000000000000001e100Initial program 58.2%
Simplified53.5%
associate-*r*59.4%
*-un-lft-identity59.4%
times-frac61.9%
Applied egg-rr61.9%
/-rgt-identity61.9%
associate-*r/59.4%
times-frac62.0%
*-commutative62.0%
associate-/r*65.1%
Simplified65.1%
Taylor expanded in t around inf 63.7%
if 3.3000000000000001e100 < k Initial program 40.3%
Simplified37.3%
Taylor expanded in k around 0 40.3%
associate-/r*40.4%
Simplified40.4%
Final simplification60.5%
(FPCore (t l k) :precision binary64 (* (pow l 2.0) (* (pow k -2.0) (pow t -3.0))))
double code(double t, double l, double k) {
return pow(l, 2.0) * (pow(k, -2.0) * pow(t, -3.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = (l ** 2.0d0) * ((k ** (-2.0d0)) * (t ** (-3.0d0)))
end function
public static double code(double t, double l, double k) {
return Math.pow(l, 2.0) * (Math.pow(k, -2.0) * Math.pow(t, -3.0));
}
def code(t, l, k): return math.pow(l, 2.0) * (math.pow(k, -2.0) * math.pow(t, -3.0))
function code(t, l, k) return Float64((l ^ 2.0) * Float64((k ^ -2.0) * (t ^ -3.0))) end
function tmp = code(t, l, k) tmp = (l ^ 2.0) * ((k ^ -2.0) * (t ^ -3.0)); end
code[t_, l_, k_] := N[(N[Power[l, 2.0], $MachinePrecision] * N[(N[Power[k, -2.0], $MachinePrecision] * N[Power[t, -3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
{\ell}^{2} \cdot \left({k}^{-2} \cdot {t}^{-3}\right)
\end{array}
Initial program 55.7%
Simplified51.3%
Taylor expanded in k around 0 53.7%
associate-/r*53.7%
Simplified53.7%
expm1-log1p-u37.6%
expm1-udef36.1%
div-inv35.3%
div-inv34.5%
pow-flip34.6%
metadata-eval34.6%
pow-flip34.6%
metadata-eval34.6%
Applied egg-rr34.6%
expm1-def36.0%
expm1-log1p52.6%
associate-*l*52.6%
Simplified52.6%
Final simplification52.6%
(FPCore (t l k) :precision binary64 (/ (/ (pow l 2.0) (pow k 2.0)) (pow t 3.0)))
double code(double t, double l, double k) {
return (pow(l, 2.0) / pow(k, 2.0)) / pow(t, 3.0);
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = ((l ** 2.0d0) / (k ** 2.0d0)) / (t ** 3.0d0)
end function
public static double code(double t, double l, double k) {
return (Math.pow(l, 2.0) / Math.pow(k, 2.0)) / Math.pow(t, 3.0);
}
def code(t, l, k): return (math.pow(l, 2.0) / math.pow(k, 2.0)) / math.pow(t, 3.0)
function code(t, l, k) return Float64(Float64((l ^ 2.0) / (k ^ 2.0)) / (t ^ 3.0)) end
function tmp = code(t, l, k) tmp = ((l ^ 2.0) / (k ^ 2.0)) / (t ^ 3.0); end
code[t_, l_, k_] := N[(N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\frac{{\ell}^{2}}{{k}^{2}}}{{t}^{3}}
\end{array}
Initial program 55.7%
Simplified51.3%
Taylor expanded in k around 0 53.7%
associate-/r*53.7%
Simplified53.7%
Final simplification53.7%
(FPCore (t l k) :precision binary64 (/ (pow l 2.0) (* (pow k 2.0) (pow t 3.0))))
double code(double t, double l, double k) {
return pow(l, 2.0) / (pow(k, 2.0) * pow(t, 3.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = (l ** 2.0d0) / ((k ** 2.0d0) * (t ** 3.0d0))
end function
public static double code(double t, double l, double k) {
return Math.pow(l, 2.0) / (Math.pow(k, 2.0) * Math.pow(t, 3.0));
}
def code(t, l, k): return math.pow(l, 2.0) / (math.pow(k, 2.0) * math.pow(t, 3.0))
function code(t, l, k) return Float64((l ^ 2.0) / Float64((k ^ 2.0) * (t ^ 3.0))) end
function tmp = code(t, l, k) tmp = (l ^ 2.0) / ((k ^ 2.0) * (t ^ 3.0)); end
code[t_, l_, k_] := N[(N[Power[l, 2.0], $MachinePrecision] / N[(N[Power[k, 2.0], $MachinePrecision] * N[Power[t, 3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{{\ell}^{2}}{{k}^{2} \cdot {t}^{3}}
\end{array}
Initial program 55.7%
Simplified51.3%
Taylor expanded in k around 0 53.7%
Final simplification53.7%
(FPCore (t l k) :precision binary64 (/ (* (* l l) (* 2.0 (pow t -3.0))) (* 2.0 (pow k 2.0))))
double code(double t, double l, double k) {
return ((l * l) * (2.0 * pow(t, -3.0))) / (2.0 * pow(k, 2.0));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = ((l * l) * (2.0d0 * (t ** (-3.0d0)))) / (2.0d0 * (k ** 2.0d0))
end function
public static double code(double t, double l, double k) {
return ((l * l) * (2.0 * Math.pow(t, -3.0))) / (2.0 * Math.pow(k, 2.0));
}
def code(t, l, k): return ((l * l) * (2.0 * math.pow(t, -3.0))) / (2.0 * math.pow(k, 2.0))
function code(t, l, k) return Float64(Float64(Float64(l * l) * Float64(2.0 * (t ^ -3.0))) / Float64(2.0 * (k ^ 2.0))) end
function tmp = code(t, l, k) tmp = ((l * l) * (2.0 * (t ^ -3.0))) / (2.0 * (k ^ 2.0)); end
code[t_, l_, k_] := N[(N[(N[(l * l), $MachinePrecision] * N[(2.0 * N[Power[t, -3.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(2.0 * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{\left(\ell \cdot \ell\right) \cdot \left(2 \cdot {t}^{-3}\right)}{2 \cdot {k}^{2}}
\end{array}
Initial program 55.7%
Simplified51.3%
Taylor expanded in k around 0 51.9%
div-inv51.9%
pow-flip51.9%
metadata-eval51.9%
Applied egg-rr51.9%
Final simplification51.9%
herbie shell --seed 2023300
(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))))