
(FPCore (t l Om Omc) :precision binary64 (asin (sqrt (/ (- 1.0 (pow (/ Om Omc) 2.0)) (+ 1.0 (* 2.0 (pow (/ t l) 2.0)))))))
double code(double t, double l, double Om, double Omc) {
return asin(sqrt(((1.0 - pow((Om / Omc), 2.0)) / (1.0 + (2.0 * pow((t / l), 2.0))))));
}
real(8) function code(t, l, om, omc)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: omc
code = asin(sqrt(((1.0d0 - ((om / omc) ** 2.0d0)) / (1.0d0 + (2.0d0 * ((t / l) ** 2.0d0))))))
end function
public static double code(double t, double l, double Om, double Omc) {
return Math.asin(Math.sqrt(((1.0 - Math.pow((Om / Omc), 2.0)) / (1.0 + (2.0 * Math.pow((t / l), 2.0))))));
}
def code(t, l, Om, Omc): return math.asin(math.sqrt(((1.0 - math.pow((Om / Omc), 2.0)) / (1.0 + (2.0 * math.pow((t / l), 2.0))))))
function code(t, l, Om, Omc) return asin(sqrt(Float64(Float64(1.0 - (Float64(Om / Omc) ^ 2.0)) / Float64(1.0 + Float64(2.0 * (Float64(t / l) ^ 2.0)))))) end
function tmp = code(t, l, Om, Omc) tmp = asin(sqrt(((1.0 - ((Om / Omc) ^ 2.0)) / (1.0 + (2.0 * ((t / l) ^ 2.0)))))); end
code[t_, l_, Om_, Omc_] := N[ArcSin[N[Sqrt[N[(N[(1.0 - N[Power[N[(Om / Omc), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(2.0 * N[Power[N[(t / l), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\sin^{-1} \left(\sqrt{\frac{1 - {\left(\frac{Om}{Omc}\right)}^{2}}{1 + 2 \cdot {\left(\frac{t}{\ell}\right)}^{2}}}\right)
\end{array}
Sampling outcomes in binary64 precision:
Herbie found 11 alternatives:
| Alternative | Accuracy | Speedup |
|---|
(FPCore (t l Om Omc) :precision binary64 (asin (sqrt (/ (- 1.0 (pow (/ Om Omc) 2.0)) (+ 1.0 (* 2.0 (pow (/ t l) 2.0)))))))
double code(double t, double l, double Om, double Omc) {
return asin(sqrt(((1.0 - pow((Om / Omc), 2.0)) / (1.0 + (2.0 * pow((t / l), 2.0))))));
}
real(8) function code(t, l, om, omc)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: omc
code = asin(sqrt(((1.0d0 - ((om / omc) ** 2.0d0)) / (1.0d0 + (2.0d0 * ((t / l) ** 2.0d0))))))
end function
public static double code(double t, double l, double Om, double Omc) {
return Math.asin(Math.sqrt(((1.0 - Math.pow((Om / Omc), 2.0)) / (1.0 + (2.0 * Math.pow((t / l), 2.0))))));
}
def code(t, l, Om, Omc): return math.asin(math.sqrt(((1.0 - math.pow((Om / Omc), 2.0)) / (1.0 + (2.0 * math.pow((t / l), 2.0))))))
function code(t, l, Om, Omc) return asin(sqrt(Float64(Float64(1.0 - (Float64(Om / Omc) ^ 2.0)) / Float64(1.0 + Float64(2.0 * (Float64(t / l) ^ 2.0)))))) end
function tmp = code(t, l, Om, Omc) tmp = asin(sqrt(((1.0 - ((Om / Omc) ^ 2.0)) / (1.0 + (2.0 * ((t / l) ^ 2.0)))))); end
code[t_, l_, Om_, Omc_] := N[ArcSin[N[Sqrt[N[(N[(1.0 - N[Power[N[(Om / Omc), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(2.0 * N[Power[N[(t / l), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
\\
\sin^{-1} \left(\sqrt{\frac{1 - {\left(\frac{Om}{Omc}\right)}^{2}}{1 + 2 \cdot {\left(\frac{t}{\ell}\right)}^{2}}}\right)
\end{array}
NOTE: t should be positive before calling this function
(FPCore (t l Om Omc)
:precision binary64
(if (<= (/ t l) -2e+96)
(asin (* (sqrt (- 1.0 (pow (/ Om Omc) 2.0))) (/ (/ (- l) t) (sqrt 2.0))))
(if (<= (/ t l) 5e+123)
(asin
(sqrt
(/
(- 1.0 (* (/ Om Omc) (/ Om Omc)))
(+ 1.0 (* 2.0 (* (/ t l) (/ t l)))))))
(asin (* l (/ (sqrt 0.5) t))))))t = abs(t);
double code(double t, double l, double Om, double Omc) {
double tmp;
if ((t / l) <= -2e+96) {
tmp = asin((sqrt((1.0 - pow((Om / Omc), 2.0))) * ((-l / t) / sqrt(2.0))));
} else if ((t / l) <= 5e+123) {
tmp = asin(sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l)))))));
} else {
tmp = asin((l * (sqrt(0.5) / t)));
}
return tmp;
}
NOTE: t should be positive before calling this function
real(8) function code(t, l, om, omc)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: omc
real(8) :: tmp
if ((t / l) <= (-2d+96)) then
tmp = asin((sqrt((1.0d0 - ((om / omc) ** 2.0d0))) * ((-l / t) / sqrt(2.0d0))))
else if ((t / l) <= 5d+123) then
tmp = asin(sqrt(((1.0d0 - ((om / omc) * (om / omc))) / (1.0d0 + (2.0d0 * ((t / l) * (t / l)))))))
else
tmp = asin((l * (sqrt(0.5d0) / t)))
end if
code = tmp
end function
t = Math.abs(t);
public static double code(double t, double l, double Om, double Omc) {
double tmp;
if ((t / l) <= -2e+96) {
tmp = Math.asin((Math.sqrt((1.0 - Math.pow((Om / Omc), 2.0))) * ((-l / t) / Math.sqrt(2.0))));
} else if ((t / l) <= 5e+123) {
tmp = Math.asin(Math.sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l)))))));
} else {
tmp = Math.asin((l * (Math.sqrt(0.5) / t)));
}
return tmp;
}
t = abs(t) def code(t, l, Om, Omc): tmp = 0 if (t / l) <= -2e+96: tmp = math.asin((math.sqrt((1.0 - math.pow((Om / Omc), 2.0))) * ((-l / t) / math.sqrt(2.0)))) elif (t / l) <= 5e+123: tmp = math.asin(math.sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l))))))) else: tmp = math.asin((l * (math.sqrt(0.5) / t))) return tmp
t = abs(t) function code(t, l, Om, Omc) tmp = 0.0 if (Float64(t / l) <= -2e+96) tmp = asin(Float64(sqrt(Float64(1.0 - (Float64(Om / Omc) ^ 2.0))) * Float64(Float64(Float64(-l) / t) / sqrt(2.0)))); elseif (Float64(t / l) <= 5e+123) tmp = asin(sqrt(Float64(Float64(1.0 - Float64(Float64(Om / Omc) * Float64(Om / Omc))) / Float64(1.0 + Float64(2.0 * Float64(Float64(t / l) * Float64(t / l))))))); else tmp = asin(Float64(l * Float64(sqrt(0.5) / t))); end return tmp end
t = abs(t) function tmp_2 = code(t, l, Om, Omc) tmp = 0.0; if ((t / l) <= -2e+96) tmp = asin((sqrt((1.0 - ((Om / Omc) ^ 2.0))) * ((-l / t) / sqrt(2.0)))); elseif ((t / l) <= 5e+123) tmp = asin(sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l))))))); else tmp = asin((l * (sqrt(0.5) / t))); end tmp_2 = tmp; end
NOTE: t should be positive before calling this function code[t_, l_, Om_, Omc_] := If[LessEqual[N[(t / l), $MachinePrecision], -2e+96], N[ArcSin[N[(N[Sqrt[N[(1.0 - N[Power[N[(Om / Omc), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[(N[((-l) / t), $MachinePrecision] / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[N[(t / l), $MachinePrecision], 5e+123], N[ArcSin[N[Sqrt[N[(N[(1.0 - N[(N[(Om / Omc), $MachinePrecision] * N[(Om / Omc), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(2.0 * N[(N[(t / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision], N[ArcSin[N[(l * N[(N[Sqrt[0.5], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
t = |t|\\
\\
\begin{array}{l}
\mathbf{if}\;\frac{t}{\ell} \leq -2 \cdot 10^{+96}:\\
\;\;\;\;\sin^{-1} \left(\sqrt{1 - {\left(\frac{Om}{Omc}\right)}^{2}} \cdot \frac{\frac{-\ell}{t}}{\sqrt{2}}\right)\\
\mathbf{elif}\;\frac{t}{\ell} \leq 5 \cdot 10^{+123}:\\
\;\;\;\;\sin^{-1} \left(\sqrt{\frac{1 - \frac{Om}{Omc} \cdot \frac{Om}{Omc}}{1 + 2 \cdot \left(\frac{t}{\ell} \cdot \frac{t}{\ell}\right)}}\right)\\
\mathbf{else}:\\
\;\;\;\;\sin^{-1} \left(\ell \cdot \frac{\sqrt{0.5}}{t}\right)\\
\end{array}
\end{array}
if (/.f64 t l) < -2.0000000000000001e96Initial program 68.3%
sqrt-div68.3%
div-inv68.3%
add-sqr-sqrt68.3%
hypot-1-def68.3%
*-commutative68.3%
sqrt-prod68.4%
unpow268.4%
sqrt-prod0.0%
add-sqr-sqrt95.9%
Applied egg-rr95.9%
associate-*r/95.9%
*-rgt-identity95.9%
associate-*l/95.9%
associate-/l*96.0%
Simplified96.0%
Taylor expanded in t around -inf 88.9%
mul-1-neg88.9%
*-commutative88.9%
distribute-rgt-neg-in88.9%
unpow288.9%
unpow288.9%
times-frac99.7%
unpow299.7%
*-commutative99.7%
associate-/r*99.7%
Simplified99.7%
if -2.0000000000000001e96 < (/.f64 t l) < 4.99999999999999974e123Initial program 98.0%
unpow298.0%
Applied egg-rr98.0%
unpow298.0%
Applied egg-rr98.0%
if 4.99999999999999974e123 < (/.f64 t l) Initial program 54.2%
Taylor expanded in t around inf 38.8%
associate-/l*38.8%
unpow238.8%
unpow238.8%
unpow238.8%
unpow238.8%
Simplified38.8%
Taylor expanded in Om around 0 99.5%
associate-/l*99.0%
Simplified99.0%
associate-/r/99.6%
Applied egg-rr99.6%
Final simplification98.5%
NOTE: t should be positive before calling this function (FPCore (t l Om Omc) :precision binary64 (asin (/ (sqrt (- 1.0 (pow (/ Om Omc) 2.0))) (hypot 1.0 (/ t (/ l (sqrt 2.0)))))))
t = abs(t);
double code(double t, double l, double Om, double Omc) {
return asin((sqrt((1.0 - pow((Om / Omc), 2.0))) / hypot(1.0, (t / (l / sqrt(2.0))))));
}
t = Math.abs(t);
public static double code(double t, double l, double Om, double Omc) {
return Math.asin((Math.sqrt((1.0 - Math.pow((Om / Omc), 2.0))) / Math.hypot(1.0, (t / (l / Math.sqrt(2.0))))));
}
t = abs(t) def code(t, l, Om, Omc): return math.asin((math.sqrt((1.0 - math.pow((Om / Omc), 2.0))) / math.hypot(1.0, (t / (l / math.sqrt(2.0))))))
t = abs(t) function code(t, l, Om, Omc) return asin(Float64(sqrt(Float64(1.0 - (Float64(Om / Omc) ^ 2.0))) / hypot(1.0, Float64(t / Float64(l / sqrt(2.0)))))) end
t = abs(t) function tmp = code(t, l, Om, Omc) tmp = asin((sqrt((1.0 - ((Om / Omc) ^ 2.0))) / hypot(1.0, (t / (l / sqrt(2.0)))))); end
NOTE: t should be positive before calling this function code[t_, l_, Om_, Omc_] := N[ArcSin[N[(N[Sqrt[N[(1.0 - N[Power[N[(Om / Omc), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[Sqrt[1.0 ^ 2 + N[(t / N[(l / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
t = |t|\\
\\
\sin^{-1} \left(\frac{\sqrt{1 - {\left(\frac{Om}{Omc}\right)}^{2}}}{\mathsf{hypot}\left(1, \frac{t}{\frac{\ell}{\sqrt{2}}}\right)}\right)
\end{array}
Initial program 86.0%
sqrt-div86.0%
div-inv86.0%
add-sqr-sqrt86.0%
hypot-1-def86.0%
*-commutative86.0%
sqrt-prod85.9%
unpow285.9%
sqrt-prod57.4%
add-sqr-sqrt97.8%
Applied egg-rr97.8%
associate-*r/97.8%
*-rgt-identity97.8%
associate-*l/97.8%
associate-/l*97.8%
Simplified97.8%
Final simplification97.8%
NOTE: t should be positive before calling this function (FPCore (t l Om Omc) :precision binary64 (asin (/ (sqrt (- 1.0 (pow (/ Om Omc) 2.0))) (hypot 1.0 (* (sqrt 2.0) (/ t l))))))
t = abs(t);
double code(double t, double l, double Om, double Omc) {
return asin((sqrt((1.0 - pow((Om / Omc), 2.0))) / hypot(1.0, (sqrt(2.0) * (t / l)))));
}
t = Math.abs(t);
public static double code(double t, double l, double Om, double Omc) {
return Math.asin((Math.sqrt((1.0 - Math.pow((Om / Omc), 2.0))) / Math.hypot(1.0, (Math.sqrt(2.0) * (t / l)))));
}
t = abs(t) def code(t, l, Om, Omc): return math.asin((math.sqrt((1.0 - math.pow((Om / Omc), 2.0))) / math.hypot(1.0, (math.sqrt(2.0) * (t / l)))))
t = abs(t) function code(t, l, Om, Omc) return asin(Float64(sqrt(Float64(1.0 - (Float64(Om / Omc) ^ 2.0))) / hypot(1.0, Float64(sqrt(2.0) * Float64(t / l))))) end
t = abs(t) function tmp = code(t, l, Om, Omc) tmp = asin((sqrt((1.0 - ((Om / Omc) ^ 2.0))) / hypot(1.0, (sqrt(2.0) * (t / l))))); end
NOTE: t should be positive before calling this function code[t_, l_, Om_, Omc_] := N[ArcSin[N[(N[Sqrt[N[(1.0 - N[Power[N[(Om / Omc), $MachinePrecision], 2.0], $MachinePrecision]), $MachinePrecision]], $MachinePrecision] / N[Sqrt[1.0 ^ 2 + N[(N[Sqrt[2.0], $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision] ^ 2], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
t = |t|\\
\\
\sin^{-1} \left(\frac{\sqrt{1 - {\left(\frac{Om}{Omc}\right)}^{2}}}{\mathsf{hypot}\left(1, \sqrt{2} \cdot \frac{t}{\ell}\right)}\right)
\end{array}
Initial program 86.0%
sqrt-div86.0%
add-sqr-sqrt86.0%
hypot-1-def86.0%
*-commutative86.0%
sqrt-prod85.9%
unpow285.9%
sqrt-prod57.4%
add-sqr-sqrt97.8%
Applied egg-rr97.8%
Final simplification97.8%
NOTE: t should be positive before calling this function
(FPCore (t l Om Omc)
:precision binary64
(if (<= (/ t l) -1e+162)
(asin
(* (sqrt (- 1.0 (/ (* Om Om) (* Omc Omc)))) (/ (- l) (* t (sqrt 2.0)))))
(if (<= (/ t l) 5e+123)
(asin
(sqrt
(/
(- 1.0 (* (/ Om Omc) (/ Om Omc)))
(+ 1.0 (* 2.0 (* (/ t l) (/ t l)))))))
(asin (* l (/ (sqrt 0.5) t))))))t = abs(t);
double code(double t, double l, double Om, double Omc) {
double tmp;
if ((t / l) <= -1e+162) {
tmp = asin((sqrt((1.0 - ((Om * Om) / (Omc * Omc)))) * (-l / (t * sqrt(2.0)))));
} else if ((t / l) <= 5e+123) {
tmp = asin(sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l)))))));
} else {
tmp = asin((l * (sqrt(0.5) / t)));
}
return tmp;
}
NOTE: t should be positive before calling this function
real(8) function code(t, l, om, omc)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: omc
real(8) :: tmp
if ((t / l) <= (-1d+162)) then
tmp = asin((sqrt((1.0d0 - ((om * om) / (omc * omc)))) * (-l / (t * sqrt(2.0d0)))))
else if ((t / l) <= 5d+123) then
tmp = asin(sqrt(((1.0d0 - ((om / omc) * (om / omc))) / (1.0d0 + (2.0d0 * ((t / l) * (t / l)))))))
else
tmp = asin((l * (sqrt(0.5d0) / t)))
end if
code = tmp
end function
t = Math.abs(t);
public static double code(double t, double l, double Om, double Omc) {
double tmp;
if ((t / l) <= -1e+162) {
tmp = Math.asin((Math.sqrt((1.0 - ((Om * Om) / (Omc * Omc)))) * (-l / (t * Math.sqrt(2.0)))));
} else if ((t / l) <= 5e+123) {
tmp = Math.asin(Math.sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l)))))));
} else {
tmp = Math.asin((l * (Math.sqrt(0.5) / t)));
}
return tmp;
}
t = abs(t) def code(t, l, Om, Omc): tmp = 0 if (t / l) <= -1e+162: tmp = math.asin((math.sqrt((1.0 - ((Om * Om) / (Omc * Omc)))) * (-l / (t * math.sqrt(2.0))))) elif (t / l) <= 5e+123: tmp = math.asin(math.sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l))))))) else: tmp = math.asin((l * (math.sqrt(0.5) / t))) return tmp
t = abs(t) function code(t, l, Om, Omc) tmp = 0.0 if (Float64(t / l) <= -1e+162) tmp = asin(Float64(sqrt(Float64(1.0 - Float64(Float64(Om * Om) / Float64(Omc * Omc)))) * Float64(Float64(-l) / Float64(t * sqrt(2.0))))); elseif (Float64(t / l) <= 5e+123) tmp = asin(sqrt(Float64(Float64(1.0 - Float64(Float64(Om / Omc) * Float64(Om / Omc))) / Float64(1.0 + Float64(2.0 * Float64(Float64(t / l) * Float64(t / l))))))); else tmp = asin(Float64(l * Float64(sqrt(0.5) / t))); end return tmp end
t = abs(t) function tmp_2 = code(t, l, Om, Omc) tmp = 0.0; if ((t / l) <= -1e+162) tmp = asin((sqrt((1.0 - ((Om * Om) / (Omc * Omc)))) * (-l / (t * sqrt(2.0))))); elseif ((t / l) <= 5e+123) tmp = asin(sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l))))))); else tmp = asin((l * (sqrt(0.5) / t))); end tmp_2 = tmp; end
NOTE: t should be positive before calling this function code[t_, l_, Om_, Omc_] := If[LessEqual[N[(t / l), $MachinePrecision], -1e+162], N[ArcSin[N[(N[Sqrt[N[(1.0 - N[(N[(Om * Om), $MachinePrecision] / N[(Omc * Omc), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision] * N[((-l) / N[(t * N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[N[(t / l), $MachinePrecision], 5e+123], N[ArcSin[N[Sqrt[N[(N[(1.0 - N[(N[(Om / Omc), $MachinePrecision] * N[(Om / Omc), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(2.0 * N[(N[(t / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision], N[ArcSin[N[(l * N[(N[Sqrt[0.5], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
t = |t|\\
\\
\begin{array}{l}
\mathbf{if}\;\frac{t}{\ell} \leq -1 \cdot 10^{+162}:\\
\;\;\;\;\sin^{-1} \left(\sqrt{1 - \frac{Om \cdot Om}{Omc \cdot Omc}} \cdot \frac{-\ell}{t \cdot \sqrt{2}}\right)\\
\mathbf{elif}\;\frac{t}{\ell} \leq 5 \cdot 10^{+123}:\\
\;\;\;\;\sin^{-1} \left(\sqrt{\frac{1 - \frac{Om}{Omc} \cdot \frac{Om}{Omc}}{1 + 2 \cdot \left(\frac{t}{\ell} \cdot \frac{t}{\ell}\right)}}\right)\\
\mathbf{else}:\\
\;\;\;\;\sin^{-1} \left(\ell \cdot \frac{\sqrt{0.5}}{t}\right)\\
\end{array}
\end{array}
if (/.f64 t l) < -9.9999999999999994e161Initial program 64.3%
sqrt-div64.3%
add-sqr-sqrt64.3%
hypot-1-def64.3%
*-commutative64.3%
sqrt-prod64.3%
unpow264.3%
sqrt-prod0.0%
add-sqr-sqrt95.1%
Applied egg-rr95.1%
Taylor expanded in t around -inf 89.8%
mul-1-neg89.8%
*-commutative89.8%
unpow289.8%
unpow289.8%
times-frac99.8%
unpow299.8%
unpow299.8%
times-frac89.8%
Simplified89.8%
if -9.9999999999999994e161 < (/.f64 t l) < 4.99999999999999974e123Initial program 97.5%
unpow297.5%
Applied egg-rr97.5%
unpow297.5%
Applied egg-rr97.5%
if 4.99999999999999974e123 < (/.f64 t l) Initial program 54.2%
Taylor expanded in t around inf 38.8%
associate-/l*38.8%
unpow238.8%
unpow238.8%
unpow238.8%
unpow238.8%
Simplified38.8%
Taylor expanded in Om around 0 99.5%
associate-/l*99.0%
Simplified99.0%
associate-/r/99.6%
Applied egg-rr99.6%
Final simplification97.0%
NOTE: t should be positive before calling this function
(FPCore (t l Om Omc)
:precision binary64
(if (<= (/ t l) -2e+138)
(asin
(* (/ (/ (- l) t) (sqrt 2.0)) (sqrt (- 1.0 (/ (/ (* Om Om) Omc) Omc)))))
(if (<= (/ t l) 5e+123)
(asin
(sqrt
(/
(- 1.0 (* (/ Om Omc) (/ Om Omc)))
(+ 1.0 (* 2.0 (* (/ t l) (/ t l)))))))
(asin (* l (/ (sqrt 0.5) t))))))t = abs(t);
double code(double t, double l, double Om, double Omc) {
double tmp;
if ((t / l) <= -2e+138) {
tmp = asin((((-l / t) / sqrt(2.0)) * sqrt((1.0 - (((Om * Om) / Omc) / Omc)))));
} else if ((t / l) <= 5e+123) {
tmp = asin(sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l)))))));
} else {
tmp = asin((l * (sqrt(0.5) / t)));
}
return tmp;
}
NOTE: t should be positive before calling this function
real(8) function code(t, l, om, omc)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: omc
real(8) :: tmp
if ((t / l) <= (-2d+138)) then
tmp = asin((((-l / t) / sqrt(2.0d0)) * sqrt((1.0d0 - (((om * om) / omc) / omc)))))
else if ((t / l) <= 5d+123) then
tmp = asin(sqrt(((1.0d0 - ((om / omc) * (om / omc))) / (1.0d0 + (2.0d0 * ((t / l) * (t / l)))))))
else
tmp = asin((l * (sqrt(0.5d0) / t)))
end if
code = tmp
end function
t = Math.abs(t);
public static double code(double t, double l, double Om, double Omc) {
double tmp;
if ((t / l) <= -2e+138) {
tmp = Math.asin((((-l / t) / Math.sqrt(2.0)) * Math.sqrt((1.0 - (((Om * Om) / Omc) / Omc)))));
} else if ((t / l) <= 5e+123) {
tmp = Math.asin(Math.sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l)))))));
} else {
tmp = Math.asin((l * (Math.sqrt(0.5) / t)));
}
return tmp;
}
t = abs(t) def code(t, l, Om, Omc): tmp = 0 if (t / l) <= -2e+138: tmp = math.asin((((-l / t) / math.sqrt(2.0)) * math.sqrt((1.0 - (((Om * Om) / Omc) / Omc))))) elif (t / l) <= 5e+123: tmp = math.asin(math.sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l))))))) else: tmp = math.asin((l * (math.sqrt(0.5) / t))) return tmp
t = abs(t) function code(t, l, Om, Omc) tmp = 0.0 if (Float64(t / l) <= -2e+138) tmp = asin(Float64(Float64(Float64(Float64(-l) / t) / sqrt(2.0)) * sqrt(Float64(1.0 - Float64(Float64(Float64(Om * Om) / Omc) / Omc))))); elseif (Float64(t / l) <= 5e+123) tmp = asin(sqrt(Float64(Float64(1.0 - Float64(Float64(Om / Omc) * Float64(Om / Omc))) / Float64(1.0 + Float64(2.0 * Float64(Float64(t / l) * Float64(t / l))))))); else tmp = asin(Float64(l * Float64(sqrt(0.5) / t))); end return tmp end
t = abs(t) function tmp_2 = code(t, l, Om, Omc) tmp = 0.0; if ((t / l) <= -2e+138) tmp = asin((((-l / t) / sqrt(2.0)) * sqrt((1.0 - (((Om * Om) / Omc) / Omc))))); elseif ((t / l) <= 5e+123) tmp = asin(sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l))))))); else tmp = asin((l * (sqrt(0.5) / t))); end tmp_2 = tmp; end
NOTE: t should be positive before calling this function code[t_, l_, Om_, Omc_] := If[LessEqual[N[(t / l), $MachinePrecision], -2e+138], N[ArcSin[N[(N[(N[((-l) / t), $MachinePrecision] / N[Sqrt[2.0], $MachinePrecision]), $MachinePrecision] * N[Sqrt[N[(1.0 - N[(N[(N[(Om * Om), $MachinePrecision] / Omc), $MachinePrecision] / Omc), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]), $MachinePrecision]], $MachinePrecision], If[LessEqual[N[(t / l), $MachinePrecision], 5e+123], N[ArcSin[N[Sqrt[N[(N[(1.0 - N[(N[(Om / Omc), $MachinePrecision] * N[(Om / Omc), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(2.0 * N[(N[(t / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision], N[ArcSin[N[(l * N[(N[Sqrt[0.5], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
t = |t|\\
\\
\begin{array}{l}
\mathbf{if}\;\frac{t}{\ell} \leq -2 \cdot 10^{+138}:\\
\;\;\;\;\sin^{-1} \left(\frac{\frac{-\ell}{t}}{\sqrt{2}} \cdot \sqrt{1 - \frac{\frac{Om \cdot Om}{Omc}}{Omc}}\right)\\
\mathbf{elif}\;\frac{t}{\ell} \leq 5 \cdot 10^{+123}:\\
\;\;\;\;\sin^{-1} \left(\sqrt{\frac{1 - \frac{Om}{Omc} \cdot \frac{Om}{Omc}}{1 + 2 \cdot \left(\frac{t}{\ell} \cdot \frac{t}{\ell}\right)}}\right)\\
\mathbf{else}:\\
\;\;\;\;\sin^{-1} \left(\ell \cdot \frac{\sqrt{0.5}}{t}\right)\\
\end{array}
\end{array}
if (/.f64 t l) < -2.0000000000000001e138Initial program 63.5%
sqrt-div63.5%
div-inv63.5%
add-sqr-sqrt63.5%
hypot-1-def63.5%
*-commutative63.5%
sqrt-prod63.5%
unpow263.5%
sqrt-prod0.0%
add-sqr-sqrt95.4%
Applied egg-rr95.4%
associate-*r/95.4%
*-rgt-identity95.4%
associate-*l/95.4%
associate-/l*95.5%
Simplified95.5%
Taylor expanded in t around -inf 87.3%
mul-1-neg87.3%
*-commutative87.3%
distribute-rgt-neg-in87.3%
unpow287.3%
unpow287.3%
times-frac99.8%
unpow299.8%
*-commutative99.8%
associate-/r*99.8%
Simplified99.8%
unpow299.8%
times-frac87.3%
associate-/r*96.7%
Applied egg-rr96.7%
if -2.0000000000000001e138 < (/.f64 t l) < 4.99999999999999974e123Initial program 98.0%
unpow298.0%
Applied egg-rr98.0%
unpow298.0%
Applied egg-rr98.0%
if 4.99999999999999974e123 < (/.f64 t l) Initial program 54.2%
Taylor expanded in t around inf 38.8%
associate-/l*38.8%
unpow238.8%
unpow238.8%
unpow238.8%
unpow238.8%
Simplified38.8%
Taylor expanded in Om around 0 99.5%
associate-/l*99.0%
Simplified99.0%
associate-/r/99.6%
Applied egg-rr99.6%
Final simplification98.1%
NOTE: t should be positive before calling this function
(FPCore (t l Om Omc)
:precision binary64
(if (<= (/ t l) -10000.0)
(asin (sqrt (* 0.5 (* (/ l t) (/ l t)))))
(if (<= (/ t l) -1e-123)
(asin (sqrt (- 1.0 (/ (* Om Om) (* Omc Omc)))))
(if (<= (/ t l) 5e+22)
(asin (sqrt (/ 1.0 (+ 1.0 (/ (* 2.0 (* t t)) (* l l))))))
(asin (* l (/ (sqrt 0.5) t)))))))t = abs(t);
double code(double t, double l, double Om, double Omc) {
double tmp;
if ((t / l) <= -10000.0) {
tmp = asin(sqrt((0.5 * ((l / t) * (l / t)))));
} else if ((t / l) <= -1e-123) {
tmp = asin(sqrt((1.0 - ((Om * Om) / (Omc * Omc)))));
} else if ((t / l) <= 5e+22) {
tmp = asin(sqrt((1.0 / (1.0 + ((2.0 * (t * t)) / (l * l))))));
} else {
tmp = asin((l * (sqrt(0.5) / t)));
}
return tmp;
}
NOTE: t should be positive before calling this function
real(8) function code(t, l, om, omc)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: omc
real(8) :: tmp
if ((t / l) <= (-10000.0d0)) then
tmp = asin(sqrt((0.5d0 * ((l / t) * (l / t)))))
else if ((t / l) <= (-1d-123)) then
tmp = asin(sqrt((1.0d0 - ((om * om) / (omc * omc)))))
else if ((t / l) <= 5d+22) then
tmp = asin(sqrt((1.0d0 / (1.0d0 + ((2.0d0 * (t * t)) / (l * l))))))
else
tmp = asin((l * (sqrt(0.5d0) / t)))
end if
code = tmp
end function
t = Math.abs(t);
public static double code(double t, double l, double Om, double Omc) {
double tmp;
if ((t / l) <= -10000.0) {
tmp = Math.asin(Math.sqrt((0.5 * ((l / t) * (l / t)))));
} else if ((t / l) <= -1e-123) {
tmp = Math.asin(Math.sqrt((1.0 - ((Om * Om) / (Omc * Omc)))));
} else if ((t / l) <= 5e+22) {
tmp = Math.asin(Math.sqrt((1.0 / (1.0 + ((2.0 * (t * t)) / (l * l))))));
} else {
tmp = Math.asin((l * (Math.sqrt(0.5) / t)));
}
return tmp;
}
t = abs(t) def code(t, l, Om, Omc): tmp = 0 if (t / l) <= -10000.0: tmp = math.asin(math.sqrt((0.5 * ((l / t) * (l / t))))) elif (t / l) <= -1e-123: tmp = math.asin(math.sqrt((1.0 - ((Om * Om) / (Omc * Omc))))) elif (t / l) <= 5e+22: tmp = math.asin(math.sqrt((1.0 / (1.0 + ((2.0 * (t * t)) / (l * l)))))) else: tmp = math.asin((l * (math.sqrt(0.5) / t))) return tmp
t = abs(t) function code(t, l, Om, Omc) tmp = 0.0 if (Float64(t / l) <= -10000.0) tmp = asin(sqrt(Float64(0.5 * Float64(Float64(l / t) * Float64(l / t))))); elseif (Float64(t / l) <= -1e-123) tmp = asin(sqrt(Float64(1.0 - Float64(Float64(Om * Om) / Float64(Omc * Omc))))); elseif (Float64(t / l) <= 5e+22) tmp = asin(sqrt(Float64(1.0 / Float64(1.0 + Float64(Float64(2.0 * Float64(t * t)) / Float64(l * l)))))); else tmp = asin(Float64(l * Float64(sqrt(0.5) / t))); end return tmp end
t = abs(t) function tmp_2 = code(t, l, Om, Omc) tmp = 0.0; if ((t / l) <= -10000.0) tmp = asin(sqrt((0.5 * ((l / t) * (l / t))))); elseif ((t / l) <= -1e-123) tmp = asin(sqrt((1.0 - ((Om * Om) / (Omc * Omc))))); elseif ((t / l) <= 5e+22) tmp = asin(sqrt((1.0 / (1.0 + ((2.0 * (t * t)) / (l * l)))))); else tmp = asin((l * (sqrt(0.5) / t))); end tmp_2 = tmp; end
NOTE: t should be positive before calling this function code[t_, l_, Om_, Omc_] := If[LessEqual[N[(t / l), $MachinePrecision], -10000.0], N[ArcSin[N[Sqrt[N[(0.5 * N[(N[(l / t), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision], If[LessEqual[N[(t / l), $MachinePrecision], -1e-123], N[ArcSin[N[Sqrt[N[(1.0 - N[(N[(Om * Om), $MachinePrecision] / N[(Omc * Omc), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision], If[LessEqual[N[(t / l), $MachinePrecision], 5e+22], N[ArcSin[N[Sqrt[N[(1.0 / N[(1.0 + N[(N[(2.0 * N[(t * t), $MachinePrecision]), $MachinePrecision] / N[(l * l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision], N[ArcSin[N[(l * N[(N[Sqrt[0.5], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]]
\begin{array}{l}
t = |t|\\
\\
\begin{array}{l}
\mathbf{if}\;\frac{t}{\ell} \leq -10000:\\
\;\;\;\;\sin^{-1} \left(\sqrt{0.5 \cdot \left(\frac{\ell}{t} \cdot \frac{\ell}{t}\right)}\right)\\
\mathbf{elif}\;\frac{t}{\ell} \leq -1 \cdot 10^{-123}:\\
\;\;\;\;\sin^{-1} \left(\sqrt{1 - \frac{Om \cdot Om}{Omc \cdot Omc}}\right)\\
\mathbf{elif}\;\frac{t}{\ell} \leq 5 \cdot 10^{+22}:\\
\;\;\;\;\sin^{-1} \left(\sqrt{\frac{1}{1 + \frac{2 \cdot \left(t \cdot t\right)}{\ell \cdot \ell}}}\right)\\
\mathbf{else}:\\
\;\;\;\;\sin^{-1} \left(\ell \cdot \frac{\sqrt{0.5}}{t}\right)\\
\end{array}
\end{array}
if (/.f64 t l) < -1e4Initial program 80.3%
Taylor expanded in t around inf 43.2%
associate-/l*43.2%
unpow243.2%
unpow243.2%
unpow243.2%
unpow243.2%
Simplified43.2%
Taylor expanded in Om around 0 47.6%
unpow247.6%
unpow247.6%
times-frac80.1%
Simplified80.1%
if -1e4 < (/.f64 t l) < -1.0000000000000001e-123Initial program 96.6%
Taylor expanded in t around 0 84.7%
unpow284.7%
unpow284.7%
Simplified84.7%
if -1.0000000000000001e-123 < (/.f64 t l) < 4.9999999999999996e22Initial program 97.6%
unpow297.6%
clear-num97.6%
frac-times97.6%
*-un-lft-identity97.6%
Applied egg-rr97.6%
Taylor expanded in Om around 0 87.3%
associate-*r/87.3%
rem-square-sqrt87.3%
unpow287.3%
*-commutative87.3%
unpow287.3%
rem-square-sqrt87.3%
unpow287.3%
rem-square-sqrt87.3%
unpow287.3%
*-commutative87.3%
unpow287.3%
rem-square-sqrt87.3%
unpow287.3%
Simplified87.3%
if 4.9999999999999996e22 < (/.f64 t l) Initial program 69.5%
Taylor expanded in t around inf 49.1%
associate-/l*49.1%
unpow249.1%
unpow249.1%
unpow249.1%
unpow249.1%
Simplified49.1%
Taylor expanded in Om around 0 98.4%
associate-/l*98.1%
Simplified98.1%
associate-/r/98.4%
Applied egg-rr98.4%
Final simplification88.3%
NOTE: t should be positive before calling this function
(FPCore (t l Om Omc)
:precision binary64
(if (<= (/ t l) 5e+123)
(asin
(sqrt
(/
(- 1.0 (* (/ Om Omc) (/ Om Omc)))
(+ 1.0 (* 2.0 (* (/ t l) (/ t l)))))))
(asin (* l (/ (sqrt 0.5) t)))))t = abs(t);
double code(double t, double l, double Om, double Omc) {
double tmp;
if ((t / l) <= 5e+123) {
tmp = asin(sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l)))))));
} else {
tmp = asin((l * (sqrt(0.5) / t)));
}
return tmp;
}
NOTE: t should be positive before calling this function
real(8) function code(t, l, om, omc)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: omc
real(8) :: tmp
if ((t / l) <= 5d+123) then
tmp = asin(sqrt(((1.0d0 - ((om / omc) * (om / omc))) / (1.0d0 + (2.0d0 * ((t / l) * (t / l)))))))
else
tmp = asin((l * (sqrt(0.5d0) / t)))
end if
code = tmp
end function
t = Math.abs(t);
public static double code(double t, double l, double Om, double Omc) {
double tmp;
if ((t / l) <= 5e+123) {
tmp = Math.asin(Math.sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l)))))));
} else {
tmp = Math.asin((l * (Math.sqrt(0.5) / t)));
}
return tmp;
}
t = abs(t) def code(t, l, Om, Omc): tmp = 0 if (t / l) <= 5e+123: tmp = math.asin(math.sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l))))))) else: tmp = math.asin((l * (math.sqrt(0.5) / t))) return tmp
t = abs(t) function code(t, l, Om, Omc) tmp = 0.0 if (Float64(t / l) <= 5e+123) tmp = asin(sqrt(Float64(Float64(1.0 - Float64(Float64(Om / Omc) * Float64(Om / Omc))) / Float64(1.0 + Float64(2.0 * Float64(Float64(t / l) * Float64(t / l))))))); else tmp = asin(Float64(l * Float64(sqrt(0.5) / t))); end return tmp end
t = abs(t) function tmp_2 = code(t, l, Om, Omc) tmp = 0.0; if ((t / l) <= 5e+123) tmp = asin(sqrt(((1.0 - ((Om / Omc) * (Om / Omc))) / (1.0 + (2.0 * ((t / l) * (t / l))))))); else tmp = asin((l * (sqrt(0.5) / t))); end tmp_2 = tmp; end
NOTE: t should be positive before calling this function code[t_, l_, Om_, Omc_] := If[LessEqual[N[(t / l), $MachinePrecision], 5e+123], N[ArcSin[N[Sqrt[N[(N[(1.0 - N[(N[(Om / Omc), $MachinePrecision] * N[(Om / Omc), $MachinePrecision]), $MachinePrecision]), $MachinePrecision] / N[(1.0 + N[(2.0 * N[(N[(t / l), $MachinePrecision] * N[(t / l), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision], N[ArcSin[N[(l * N[(N[Sqrt[0.5], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
t = |t|\\
\\
\begin{array}{l}
\mathbf{if}\;\frac{t}{\ell} \leq 5 \cdot 10^{+123}:\\
\;\;\;\;\sin^{-1} \left(\sqrt{\frac{1 - \frac{Om}{Omc} \cdot \frac{Om}{Omc}}{1 + 2 \cdot \left(\frac{t}{\ell} \cdot \frac{t}{\ell}\right)}}\right)\\
\mathbf{else}:\\
\;\;\;\;\sin^{-1} \left(\ell \cdot \frac{\sqrt{0.5}}{t}\right)\\
\end{array}
\end{array}
if (/.f64 t l) < 4.99999999999999974e123Initial program 92.8%
unpow292.8%
Applied egg-rr92.8%
unpow292.8%
Applied egg-rr92.8%
if 4.99999999999999974e123 < (/.f64 t l) Initial program 54.2%
Taylor expanded in t around inf 38.8%
associate-/l*38.8%
unpow238.8%
unpow238.8%
unpow238.8%
unpow238.8%
Simplified38.8%
Taylor expanded in Om around 0 99.5%
associate-/l*99.0%
Simplified99.0%
associate-/r/99.6%
Applied egg-rr99.6%
Final simplification94.0%
NOTE: t should be positive before calling this function
(FPCore (t l Om Omc)
:precision binary64
(if (<= (/ t l) -10000.0)
(asin (sqrt (* 0.5 (* (/ l t) (/ l t)))))
(if (<= (/ t l) 5e-10)
(asin (sqrt (- 1.0 (/ (* Om Om) (* Omc Omc)))))
(asin (* l (/ (sqrt 0.5) t))))))t = abs(t);
double code(double t, double l, double Om, double Omc) {
double tmp;
if ((t / l) <= -10000.0) {
tmp = asin(sqrt((0.5 * ((l / t) * (l / t)))));
} else if ((t / l) <= 5e-10) {
tmp = asin(sqrt((1.0 - ((Om * Om) / (Omc * Omc)))));
} else {
tmp = asin((l * (sqrt(0.5) / t)));
}
return tmp;
}
NOTE: t should be positive before calling this function
real(8) function code(t, l, om, omc)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: omc
real(8) :: tmp
if ((t / l) <= (-10000.0d0)) then
tmp = asin(sqrt((0.5d0 * ((l / t) * (l / t)))))
else if ((t / l) <= 5d-10) then
tmp = asin(sqrt((1.0d0 - ((om * om) / (omc * omc)))))
else
tmp = asin((l * (sqrt(0.5d0) / t)))
end if
code = tmp
end function
t = Math.abs(t);
public static double code(double t, double l, double Om, double Omc) {
double tmp;
if ((t / l) <= -10000.0) {
tmp = Math.asin(Math.sqrt((0.5 * ((l / t) * (l / t)))));
} else if ((t / l) <= 5e-10) {
tmp = Math.asin(Math.sqrt((1.0 - ((Om * Om) / (Omc * Omc)))));
} else {
tmp = Math.asin((l * (Math.sqrt(0.5) / t)));
}
return tmp;
}
t = abs(t) def code(t, l, Om, Omc): tmp = 0 if (t / l) <= -10000.0: tmp = math.asin(math.sqrt((0.5 * ((l / t) * (l / t))))) elif (t / l) <= 5e-10: tmp = math.asin(math.sqrt((1.0 - ((Om * Om) / (Omc * Omc))))) else: tmp = math.asin((l * (math.sqrt(0.5) / t))) return tmp
t = abs(t) function code(t, l, Om, Omc) tmp = 0.0 if (Float64(t / l) <= -10000.0) tmp = asin(sqrt(Float64(0.5 * Float64(Float64(l / t) * Float64(l / t))))); elseif (Float64(t / l) <= 5e-10) tmp = asin(sqrt(Float64(1.0 - Float64(Float64(Om * Om) / Float64(Omc * Omc))))); else tmp = asin(Float64(l * Float64(sqrt(0.5) / t))); end return tmp end
t = abs(t) function tmp_2 = code(t, l, Om, Omc) tmp = 0.0; if ((t / l) <= -10000.0) tmp = asin(sqrt((0.5 * ((l / t) * (l / t))))); elseif ((t / l) <= 5e-10) tmp = asin(sqrt((1.0 - ((Om * Om) / (Omc * Omc))))); else tmp = asin((l * (sqrt(0.5) / t))); end tmp_2 = tmp; end
NOTE: t should be positive before calling this function code[t_, l_, Om_, Omc_] := If[LessEqual[N[(t / l), $MachinePrecision], -10000.0], N[ArcSin[N[Sqrt[N[(0.5 * N[(N[(l / t), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision], If[LessEqual[N[(t / l), $MachinePrecision], 5e-10], N[ArcSin[N[Sqrt[N[(1.0 - N[(N[(Om * Om), $MachinePrecision] / N[(Omc * Omc), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision], N[ArcSin[N[(l * N[(N[Sqrt[0.5], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]]
\begin{array}{l}
t = |t|\\
\\
\begin{array}{l}
\mathbf{if}\;\frac{t}{\ell} \leq -10000:\\
\;\;\;\;\sin^{-1} \left(\sqrt{0.5 \cdot \left(\frac{\ell}{t} \cdot \frac{\ell}{t}\right)}\right)\\
\mathbf{elif}\;\frac{t}{\ell} \leq 5 \cdot 10^{-10}:\\
\;\;\;\;\sin^{-1} \left(\sqrt{1 - \frac{Om \cdot Om}{Omc \cdot Omc}}\right)\\
\mathbf{else}:\\
\;\;\;\;\sin^{-1} \left(\ell \cdot \frac{\sqrt{0.5}}{t}\right)\\
\end{array}
\end{array}
if (/.f64 t l) < -1e4Initial program 80.3%
Taylor expanded in t around inf 43.2%
associate-/l*43.2%
unpow243.2%
unpow243.2%
unpow243.2%
unpow243.2%
Simplified43.2%
Taylor expanded in Om around 0 47.6%
unpow247.6%
unpow247.6%
times-frac80.1%
Simplified80.1%
if -1e4 < (/.f64 t l) < 5.00000000000000031e-10Initial program 98.1%
Taylor expanded in t around 0 85.0%
unpow285.0%
unpow285.0%
Simplified85.0%
if 5.00000000000000031e-10 < (/.f64 t l) Initial program 70.0%
Taylor expanded in t around inf 46.4%
associate-/l*46.4%
unpow246.4%
unpow246.4%
unpow246.4%
unpow246.4%
Simplified46.4%
Taylor expanded in Om around 0 93.5%
associate-/l*93.2%
Simplified93.2%
associate-/r/93.5%
Applied egg-rr93.5%
Final simplification86.3%
NOTE: t should be positive before calling this function (FPCore (t l Om Omc) :precision binary64 (if (<= (/ t l) 5e+123) (asin (sqrt (* 0.5 (* (/ l t) (/ l t))))) (asin (* l (/ (sqrt 0.5) t)))))
t = abs(t);
double code(double t, double l, double Om, double Omc) {
double tmp;
if ((t / l) <= 5e+123) {
tmp = asin(sqrt((0.5 * ((l / t) * (l / t)))));
} else {
tmp = asin((l * (sqrt(0.5) / t)));
}
return tmp;
}
NOTE: t should be positive before calling this function
real(8) function code(t, l, om, omc)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: omc
real(8) :: tmp
if ((t / l) <= 5d+123) then
tmp = asin(sqrt((0.5d0 * ((l / t) * (l / t)))))
else
tmp = asin((l * (sqrt(0.5d0) / t)))
end if
code = tmp
end function
t = Math.abs(t);
public static double code(double t, double l, double Om, double Omc) {
double tmp;
if ((t / l) <= 5e+123) {
tmp = Math.asin(Math.sqrt((0.5 * ((l / t) * (l / t)))));
} else {
tmp = Math.asin((l * (Math.sqrt(0.5) / t)));
}
return tmp;
}
t = abs(t) def code(t, l, Om, Omc): tmp = 0 if (t / l) <= 5e+123: tmp = math.asin(math.sqrt((0.5 * ((l / t) * (l / t))))) else: tmp = math.asin((l * (math.sqrt(0.5) / t))) return tmp
t = abs(t) function code(t, l, Om, Omc) tmp = 0.0 if (Float64(t / l) <= 5e+123) tmp = asin(sqrt(Float64(0.5 * Float64(Float64(l / t) * Float64(l / t))))); else tmp = asin(Float64(l * Float64(sqrt(0.5) / t))); end return tmp end
t = abs(t) function tmp_2 = code(t, l, Om, Omc) tmp = 0.0; if ((t / l) <= 5e+123) tmp = asin(sqrt((0.5 * ((l / t) * (l / t))))); else tmp = asin((l * (sqrt(0.5) / t))); end tmp_2 = tmp; end
NOTE: t should be positive before calling this function code[t_, l_, Om_, Omc_] := If[LessEqual[N[(t / l), $MachinePrecision], 5e+123], N[ArcSin[N[Sqrt[N[(0.5 * N[(N[(l / t), $MachinePrecision] * N[(l / t), $MachinePrecision]), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]], $MachinePrecision], N[ArcSin[N[(l * N[(N[Sqrt[0.5], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]]
\begin{array}{l}
t = |t|\\
\\
\begin{array}{l}
\mathbf{if}\;\frac{t}{\ell} \leq 5 \cdot 10^{+123}:\\
\;\;\;\;\sin^{-1} \left(\sqrt{0.5 \cdot \left(\frac{\ell}{t} \cdot \frac{\ell}{t}\right)}\right)\\
\mathbf{else}:\\
\;\;\;\;\sin^{-1} \left(\ell \cdot \frac{\sqrt{0.5}}{t}\right)\\
\end{array}
\end{array}
if (/.f64 t l) < 4.99999999999999974e123Initial program 92.8%
Taylor expanded in t around inf 19.8%
associate-/l*19.8%
unpow219.8%
unpow219.8%
unpow219.8%
unpow219.8%
Simplified19.8%
Taylor expanded in Om around 0 21.7%
unpow221.7%
unpow221.7%
times-frac33.4%
Simplified33.4%
if 4.99999999999999974e123 < (/.f64 t l) Initial program 54.2%
Taylor expanded in t around inf 38.8%
associate-/l*38.8%
unpow238.8%
unpow238.8%
unpow238.8%
unpow238.8%
Simplified38.8%
Taylor expanded in Om around 0 99.5%
associate-/l*99.0%
Simplified99.0%
associate-/r/99.6%
Applied egg-rr99.6%
Final simplification45.1%
NOTE: t should be positive before calling this function (FPCore (t l Om Omc) :precision binary64 (asin (* (/ l t) (sqrt 0.5))))
t = abs(t);
double code(double t, double l, double Om, double Omc) {
return asin(((l / t) * sqrt(0.5)));
}
NOTE: t should be positive before calling this function
real(8) function code(t, l, om, omc)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: omc
code = asin(((l / t) * sqrt(0.5d0)))
end function
t = Math.abs(t);
public static double code(double t, double l, double Om, double Omc) {
return Math.asin(((l / t) * Math.sqrt(0.5)));
}
t = abs(t) def code(t, l, Om, Omc): return math.asin(((l / t) * math.sqrt(0.5)))
t = abs(t) function code(t, l, Om, Omc) return asin(Float64(Float64(l / t) * sqrt(0.5))) end
t = abs(t) function tmp = code(t, l, Om, Omc) tmp = asin(((l / t) * sqrt(0.5))); end
NOTE: t should be positive before calling this function code[t_, l_, Om_, Omc_] := N[ArcSin[N[(N[(l / t), $MachinePrecision] * N[Sqrt[0.5], $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
t = |t|\\
\\
\sin^{-1} \left(\frac{\ell}{t} \cdot \sqrt{0.5}\right)
\end{array}
Initial program 86.0%
Taylor expanded in t around inf 23.2%
associate-/l*23.2%
unpow223.2%
unpow223.2%
unpow223.2%
unpow223.2%
Simplified23.2%
Taylor expanded in Om around 0 34.0%
associate-/l*34.0%
Simplified34.0%
clear-num33.9%
associate-/r/33.9%
clear-num34.0%
Applied egg-rr34.0%
Final simplification34.0%
NOTE: t should be positive before calling this function (FPCore (t l Om Omc) :precision binary64 (asin (* l (/ (sqrt 0.5) t))))
t = abs(t);
double code(double t, double l, double Om, double Omc) {
return asin((l * (sqrt(0.5) / t)));
}
NOTE: t should be positive before calling this function
real(8) function code(t, l, om, omc)
real(8), intent (in) :: t
real(8), intent (in) :: l
real(8), intent (in) :: om
real(8), intent (in) :: omc
code = asin((l * (sqrt(0.5d0) / t)))
end function
t = Math.abs(t);
public static double code(double t, double l, double Om, double Omc) {
return Math.asin((l * (Math.sqrt(0.5) / t)));
}
t = abs(t) def code(t, l, Om, Omc): return math.asin((l * (math.sqrt(0.5) / t)))
t = abs(t) function code(t, l, Om, Omc) return asin(Float64(l * Float64(sqrt(0.5) / t))) end
t = abs(t) function tmp = code(t, l, Om, Omc) tmp = asin((l * (sqrt(0.5) / t))); end
NOTE: t should be positive before calling this function code[t_, l_, Om_, Omc_] := N[ArcSin[N[(l * N[(N[Sqrt[0.5], $MachinePrecision] / t), $MachinePrecision]), $MachinePrecision]], $MachinePrecision]
\begin{array}{l}
t = |t|\\
\\
\sin^{-1} \left(\ell \cdot \frac{\sqrt{0.5}}{t}\right)
\end{array}
Initial program 86.0%
Taylor expanded in t around inf 23.2%
associate-/l*23.2%
unpow223.2%
unpow223.2%
unpow223.2%
unpow223.2%
Simplified23.2%
Taylor expanded in Om around 0 34.0%
associate-/l*34.0%
Simplified34.0%
associate-/r/34.0%
Applied egg-rr34.0%
Final simplification34.0%
herbie shell --seed 2023255
(FPCore (t l Om Omc)
:name "Toniolo and Linder, Equation (2)"
:precision binary64
(asin (sqrt (/ (- 1.0 (pow (/ Om Omc) 2.0)) (+ 1.0 (* 2.0 (pow (/ t l) 2.0)))))))