
(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 6 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 (/ 2.0 (* (pow (/ k l) 2.0) (/ (pow (sin k) 2.0) (/ (cos k) t)))))
double code(double t, double l, double k) {
return 2.0 / (pow((k / l), 2.0) * (pow(sin(k), 2.0) / (cos(k) / t)));
}
real(8) function code(t, l, k)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: k
code = 2.0d0 / (((k / l) ** 2.0d0) * ((sin(k) ** 2.0d0) / (cos(k) / t)))
end function
public static double code(double t, double l, double k) {
return 2.0 / (Math.pow((k / l), 2.0) * (Math.pow(Math.sin(k), 2.0) / (Math.cos(k) / t)));
}
def code(t, l, k): return 2.0 / (math.pow((k / l), 2.0) * (math.pow(math.sin(k), 2.0) / (math.cos(k) / t)))
function code(t, l, k) return Float64(2.0 / Float64((Float64(k / l) ^ 2.0) * Float64((sin(k) ^ 2.0) / Float64(cos(k) / t)))) end
function tmp = code(t, l, k) tmp = 2.0 / (((k / l) ^ 2.0) * ((sin(k) ^ 2.0) / (cos(k) / t))); end
code[t_, l_, k_] := N[(2.0 / N[(N[Power[N[(k / l), $MachinePrecision], 2.0], $MachinePrecision] * N[(N[Power[N[Sin[k], $MachinePrecision], 2.0], $MachinePrecision] / N[(N[Cos[k], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{{\left(\frac{k}{\ell}\right)}^{2} \cdot \frac{{\sin k}^{2}}{\frac{\cos k}{t}}}
\end{array}
Initial program 32.2%
Taylor expanded in t around 0 70.7%
times-frac70.6%
Simplified70.6%
add-sqr-sqrt70.7%
pow270.7%
div-inv70.6%
sqrt-prod70.6%
unpow270.6%
sqrt-prod41.7%
add-sqr-sqrt75.6%
pow-flip75.6%
metadata-eval75.6%
Applied egg-rr75.6%
Taylor expanded in l around 0 89.8%
Taylor expanded in k around inf 70.7%
times-frac70.6%
unpow270.6%
unpow270.6%
times-frac89.8%
unpow289.8%
*-commutative89.8%
associate-/l*89.8%
Simplified89.8%
Final simplification89.8%
(FPCore (t l k)
:precision binary64
(let* ((t_1 (pow (* k (/ 1.0 l)) 2.0)))
(if (<= k 2.2e-5)
(/ 2.0 (* t_1 (/ (* t (pow k 2.0)) (cos k))))
(/ 2.0 (* t_1 (/ (* t (- 0.5 (/ (cos (* 2.0 k)) 2.0))) (cos k)))))))
double code(double t, double l, double k) {
double t_1 = pow((k * (1.0 / l)), 2.0);
double tmp;
if (k <= 2.2e-5) {
tmp = 2.0 / (t_1 * ((t * pow(k, 2.0)) / cos(k)));
} else {
tmp = 2.0 / (t_1 * ((t * (0.5 - (cos((2.0 * k)) / 2.0))) / cos(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) :: t_1
real(8) :: tmp
t_1 = (k * (1.0d0 / l)) ** 2.0d0
if (k <= 2.2d-5) then
tmp = 2.0d0 / (t_1 * ((t * (k ** 2.0d0)) / cos(k)))
else
tmp = 2.0d0 / (t_1 * ((t * (0.5d0 - (cos((2.0d0 * k)) / 2.0d0))) / cos(k)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double t_1 = Math.pow((k * (1.0 / l)), 2.0);
double tmp;
if (k <= 2.2e-5) {
tmp = 2.0 / (t_1 * ((t * Math.pow(k, 2.0)) / Math.cos(k)));
} else {
tmp = 2.0 / (t_1 * ((t * (0.5 - (Math.cos((2.0 * k)) / 2.0))) / Math.cos(k)));
}
return tmp;
}
def code(t, l, k): t_1 = math.pow((k * (1.0 / l)), 2.0) tmp = 0 if k <= 2.2e-5: tmp = 2.0 / (t_1 * ((t * math.pow(k, 2.0)) / math.cos(k))) else: tmp = 2.0 / (t_1 * ((t * (0.5 - (math.cos((2.0 * k)) / 2.0))) / math.cos(k))) return tmp
function code(t, l, k) t_1 = Float64(k * Float64(1.0 / l)) ^ 2.0 tmp = 0.0 if (k <= 2.2e-5) tmp = Float64(2.0 / Float64(t_1 * Float64(Float64(t * (k ^ 2.0)) / cos(k)))); else tmp = Float64(2.0 / Float64(t_1 * Float64(Float64(t * Float64(0.5 - Float64(cos(Float64(2.0 * k)) / 2.0))) / cos(k)))); end return tmp end
function tmp_2 = code(t, l, k) t_1 = (k * (1.0 / l)) ^ 2.0; tmp = 0.0; if (k <= 2.2e-5) tmp = 2.0 / (t_1 * ((t * (k ^ 2.0)) / cos(k))); else tmp = 2.0 / (t_1 * ((t * (0.5 - (cos((2.0 * k)) / 2.0))) / cos(k))); end tmp_2 = tmp; end
code[t_, l_, k_] := Block[{t$95$1 = N[Power[N[(k * N[(1.0 / l), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]}, If[LessEqual[k, 2.2e-5], N[(2.0 / N[(t$95$1 * N[(N[(t * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(t$95$1 * N[(N[(t * N[(0.5 - N[(N[Cos[N[(2.0 * k), $MachinePrecision]], $MachinePrecision] / 2.0), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]]
\begin{array}{l}
\\
\begin{array}{l}
t_1 := {\left(k \cdot \frac{1}{\ell}\right)}^{2}\\
\mathbf{if}\;k \leq 2.2 \cdot 10^{-5}:\\
\;\;\;\;\frac{2}{t_1 \cdot \frac{t \cdot {k}^{2}}{\cos k}}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{t_1 \cdot \frac{t \cdot \left(0.5 - \frac{\cos \left(2 \cdot k\right)}{2}\right)}{\cos k}}\\
\end{array}
\end{array}
if k < 2.1999999999999999e-5Initial program 34.9%
Taylor expanded in t around 0 72.5%
times-frac72.9%
Simplified72.9%
add-sqr-sqrt72.9%
pow272.9%
div-inv72.9%
sqrt-prod72.9%
unpow272.9%
sqrt-prod26.2%
add-sqr-sqrt74.1%
pow-flip74.2%
metadata-eval74.2%
Applied egg-rr74.2%
Taylor expanded in l around 0 90.5%
Taylor expanded in k around 0 76.9%
if 2.1999999999999999e-5 < k Initial program 25.6%
Taylor expanded in t around 0 66.3%
times-frac65.1%
Simplified65.1%
add-sqr-sqrt65.2%
pow265.2%
div-inv65.2%
sqrt-prod65.2%
unpow265.2%
sqrt-prod79.0%
add-sqr-sqrt79.2%
pow-flip79.2%
metadata-eval79.2%
Applied egg-rr79.2%
Taylor expanded in l around 0 88.1%
unpow288.1%
sin-mult88.1%
Applied egg-rr88.1%
div-sub88.1%
+-inverses88.1%
cos-088.1%
metadata-eval88.1%
count-288.1%
*-commutative88.1%
Simplified88.1%
Final simplification80.2%
(FPCore (t l k) :precision binary64 (/ 2.0 (* (pow (* k (/ 1.0 l)) 2.0) (/ (* t (pow k 2.0)) (cos k)))))
double code(double t, double l, double k) {
return 2.0 / (pow((k * (1.0 / l)), 2.0) * ((t * pow(k, 2.0)) / cos(k)));
}
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 * (1.0d0 / l)) ** 2.0d0) * ((t * (k ** 2.0d0)) / cos(k)))
end function
public static double code(double t, double l, double k) {
return 2.0 / (Math.pow((k * (1.0 / l)), 2.0) * ((t * Math.pow(k, 2.0)) / Math.cos(k)));
}
def code(t, l, k): return 2.0 / (math.pow((k * (1.0 / l)), 2.0) * ((t * math.pow(k, 2.0)) / math.cos(k)))
function code(t, l, k) return Float64(2.0 / Float64((Float64(k * Float64(1.0 / l)) ^ 2.0) * Float64(Float64(t * (k ^ 2.0)) / cos(k)))) end
function tmp = code(t, l, k) tmp = 2.0 / (((k * (1.0 / l)) ^ 2.0) * ((t * (k ^ 2.0)) / cos(k))); end
code[t_, l_, k_] := N[(2.0 / N[(N[Power[N[(k * N[(1.0 / l), $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision] * N[(N[(t * N[Power[k, 2.0], $MachinePrecision]), $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{{\left(k \cdot \frac{1}{\ell}\right)}^{2} \cdot \frac{t \cdot {k}^{2}}{\cos k}}
\end{array}
Initial program 32.2%
Taylor expanded in t around 0 70.7%
times-frac70.6%
Simplified70.6%
add-sqr-sqrt70.7%
pow270.7%
div-inv70.6%
sqrt-prod70.6%
unpow270.6%
sqrt-prod41.7%
add-sqr-sqrt75.6%
pow-flip75.6%
metadata-eval75.6%
Applied egg-rr75.6%
Taylor expanded in l around 0 89.8%
Taylor expanded in k around 0 70.7%
Final simplification70.7%
(FPCore (t l k) :precision binary64 (if (<= l 1.35e+91) (* (/ 2.0 t) (pow (* l (sqrt (pow k -4.0))) 2.0)) (/ 2.0 (* (/ t (pow l 2.0)) (/ (pow k 4.0) (cos k))))))
double code(double t, double l, double k) {
double tmp;
if (l <= 1.35e+91) {
tmp = (2.0 / t) * pow((l * sqrt(pow(k, -4.0))), 2.0);
} else {
tmp = 2.0 / ((t / pow(l, 2.0)) * (pow(k, 4.0) / cos(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 (l <= 1.35d+91) then
tmp = (2.0d0 / t) * ((l * sqrt((k ** (-4.0d0)))) ** 2.0d0)
else
tmp = 2.0d0 / ((t / (l ** 2.0d0)) * ((k ** 4.0d0) / cos(k)))
end if
code = tmp
end function
public static double code(double t, double l, double k) {
double tmp;
if (l <= 1.35e+91) {
tmp = (2.0 / t) * Math.pow((l * Math.sqrt(Math.pow(k, -4.0))), 2.0);
} else {
tmp = 2.0 / ((t / Math.pow(l, 2.0)) * (Math.pow(k, 4.0) / Math.cos(k)));
}
return tmp;
}
def code(t, l, k): tmp = 0 if l <= 1.35e+91: tmp = (2.0 / t) * math.pow((l * math.sqrt(math.pow(k, -4.0))), 2.0) else: tmp = 2.0 / ((t / math.pow(l, 2.0)) * (math.pow(k, 4.0) / math.cos(k))) return tmp
function code(t, l, k) tmp = 0.0 if (l <= 1.35e+91) tmp = Float64(Float64(2.0 / t) * (Float64(l * sqrt((k ^ -4.0))) ^ 2.0)); else tmp = Float64(2.0 / Float64(Float64(t / (l ^ 2.0)) * Float64((k ^ 4.0) / cos(k)))); end return tmp end
function tmp_2 = code(t, l, k) tmp = 0.0; if (l <= 1.35e+91) tmp = (2.0 / t) * ((l * sqrt((k ^ -4.0))) ^ 2.0); else tmp = 2.0 / ((t / (l ^ 2.0)) * ((k ^ 4.0) / cos(k))); end tmp_2 = tmp; end
code[t_, l_, k_] := If[LessEqual[l, 1.35e+91], N[(N[(2.0 / t), $MachinePrecision] * N[Power[N[(l * N[Sqrt[N[Power[k, -4.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision], N[(2.0 / N[(N[(t / N[Power[l, 2.0], $MachinePrecision]), $MachinePrecision] * N[(N[Power[k, 4.0], $MachinePrecision] / N[Cos[k], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]]
\begin{array}{l}
\\
\begin{array}{l}
\mathbf{if}\;\ell \leq 1.35 \cdot 10^{+91}:\\
\;\;\;\;\frac{2}{t} \cdot {\left(\ell \cdot \sqrt{{k}^{-4}}\right)}^{2}\\
\mathbf{else}:\\
\;\;\;\;\frac{2}{\frac{t}{{\ell}^{2}} \cdot \frac{{k}^{4}}{\cos k}}\\
\end{array}
\end{array}
if l < 1.35e91Initial program 33.9%
associate-/r*33.9%
associate-*l/34.4%
associate--l+34.4%
Simplified34.4%
Taylor expanded in k around 0 60.1%
associate-*r/60.1%
*-commutative60.1%
times-frac60.8%
Simplified60.8%
add-sqr-sqrt60.8%
pow260.8%
div-inv60.7%
sqrt-prod60.7%
pow260.7%
sqrt-prod30.4%
add-sqr-sqrt69.9%
pow-flip69.9%
metadata-eval69.9%
Applied egg-rr69.9%
if 1.35e91 < l Initial program 25.1%
Taylor expanded in t around 0 72.0%
associate-*r*72.1%
times-frac72.0%
Simplified72.0%
Taylor expanded in k around 0 64.4%
Taylor expanded in k around inf 58.1%
*-commutative58.1%
times-frac62.1%
Simplified62.1%
Final simplification68.4%
(FPCore (t l k) :precision binary64 (* (/ 2.0 t) (pow (* l (sqrt (pow k -4.0))) 2.0)))
double code(double t, double l, double k) {
return (2.0 / t) * pow((l * sqrt(pow(k, -4.0))), 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 = (2.0d0 / t) * ((l * sqrt((k ** (-4.0d0)))) ** 2.0d0)
end function
public static double code(double t, double l, double k) {
return (2.0 / t) * Math.pow((l * Math.sqrt(Math.pow(k, -4.0))), 2.0);
}
def code(t, l, k): return (2.0 / t) * math.pow((l * math.sqrt(math.pow(k, -4.0))), 2.0)
function code(t, l, k) return Float64(Float64(2.0 / t) * (Float64(l * sqrt((k ^ -4.0))) ^ 2.0)) end
function tmp = code(t, l, k) tmp = (2.0 / t) * ((l * sqrt((k ^ -4.0))) ^ 2.0); end
code[t_, l_, k_] := N[(N[(2.0 / t), $MachinePrecision] * N[Power[N[(l * N[Sqrt[N[Power[k, -4.0], $MachinePrecision]], $MachinePrecision]), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{t} \cdot {\left(\ell \cdot \sqrt{{k}^{-4}}\right)}^{2}
\end{array}
Initial program 32.2%
associate-/r*32.2%
associate-*l/32.6%
associate--l+32.6%
Simplified32.6%
Taylor expanded in k around 0 58.5%
associate-*r/58.5%
*-commutative58.5%
times-frac58.8%
Simplified58.8%
add-sqr-sqrt58.8%
pow258.8%
div-inv58.6%
sqrt-prod58.6%
pow258.6%
sqrt-prod34.2%
add-sqr-sqrt66.2%
pow-flip66.2%
metadata-eval66.2%
Applied egg-rr66.2%
Final simplification66.2%
(FPCore (t l k) :precision binary64 (* (/ 2.0 t) (/ (pow l 2.0) (pow k 4.0))))
double code(double t, double l, double k) {
return (2.0 / t) * (pow(l, 2.0) / pow(k, 4.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) * ((l ** 2.0d0) / (k ** 4.0d0))
end function
public static double code(double t, double l, double k) {
return (2.0 / t) * (Math.pow(l, 2.0) / Math.pow(k, 4.0));
}
def code(t, l, k): return (2.0 / t) * (math.pow(l, 2.0) / math.pow(k, 4.0))
function code(t, l, k) return Float64(Float64(2.0 / t) * Float64((l ^ 2.0) / (k ^ 4.0))) end
function tmp = code(t, l, k) tmp = (2.0 / t) * ((l ^ 2.0) / (k ^ 4.0)); end
code[t_, l_, k_] := N[(N[(2.0 / t), $MachinePrecision] * N[(N[Power[l, 2.0], $MachinePrecision] / N[Power[k, 4.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]
\begin{array}{l}
\\
\frac{2}{t} \cdot \frac{{\ell}^{2}}{{k}^{4}}
\end{array}
Initial program 32.2%
associate-/r*32.2%
associate-*l/32.6%
associate--l+32.6%
Simplified32.6%
Taylor expanded in k around 0 58.5%
associate-*r/58.5%
*-commutative58.5%
times-frac58.8%
Simplified58.8%
Final simplification58.8%
herbie shell --seed 2023306
(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))))