Replace TeX escape sequences with unicode counterparts

The default KaTeX renderer supports it, and it also clears up the docstrings when viewing in the REPL

Author: abhro

docs/src/functions_overview.md

@@ -8,15 +8,15 @@ Here the *Special Functions* are listed according to the structure of [NIST Digi
 
 | Function | Description |
 |:-------- |:----------- |
-| [`gamma(z)`](@ref SpecialFunctions.gamma(::Number))                  | [gamma function](https://en.wikipedia.org/wiki/Gamma_function) ``\Gamma(z)``                                                                                                                         |
+| [`gamma(z)`](@ref SpecialFunctions.gamma(::Number))                  | [gamma function](https://en.wikipedia.org/wiki/Gamma_function) ``Γ(z)``                                                                                                                              |
 | [`loggamma(x)`](@ref SpecialFunctions.loggamma(::Number))            | accurate `log(gamma(x))` for large `x`                                                                                                                                                               |
 | [`logabsgamma(x)`](@ref SpecialFunctions.logabsgamma)                | accurate `log(abs(gamma(x)))` for large `x`                                                                                                                                                          |
 | [`logfactorial(x)`](@ref SpecialFunctions.logfactorial)              | accurate `log(factorial(x))` for large `x`; same as `loggamma(x+1)` for `x > 1`, zero otherwise                                                                                                      |
 | [`digamma(x)`](@ref SpecialFunctions.digamma)                        | [digamma function](https://en.wikipedia.org/wiki/Digamma_function) (i.e. the derivative of `loggamma` at `x`)                                                                                        |
 | [`invdigamma(x)`](@ref SpecialFunctions.invdigamma)                  | [invdigamma function](http://bariskurt.com/calculating-the-inverse-of-digamma-function/) (i.e. inverse of `digamma` function at `x` using fixed-point iteration algorithm)                           |
 | [`trigamma(x)`](@ref SpecialFunctions.trigamma)                      | [trigamma function](https://en.wikipedia.org/wiki/Trigamma_function) (i.e the logarithmic second derivative of `gamma` at `x`)                                                                       |
 | [`polygamma(m,x)`](@ref SpecialFunctions.polygamma)                  | [polygamma function](https://en.wikipedia.org/wiki/Polygamma_function) (i.e the (m+1)-th derivative of the `loggamma` function at `x`)                                                               |
-| [`gamma(a,z)`](@ref SpecialFunctions.gamma(::Number,::Number))       | [upper incomplete gamma function ``\Gamma(a,z)``](https://en.wikipedia.org/wiki/Incomplete_gamma_function)                                                                                           |
+| [`gamma(a,z)`](@ref SpecialFunctions.gamma(::Number,::Number))       | [upper incomplete gamma function ``Γ(a,z)``](https://en.wikipedia.org/wiki/Incomplete_gamma_function)                                                                                                |
 | [`loggamma(a,z)`](@ref SpecialFunctions.loggamma(::Number,::Number)) | accurate `log(gamma(a,x))` for large arguments                                                                                                                                                       |
 | [`gamma_inc(a,x,IND)`](@ref SpecialFunctions.gamma_inc)              | [incomplete gamma function ratio P(a,x) and Q(a,x)](https://en.wikipedia.org/wiki/Incomplete_gamma_function) (i.e evaluates P(a,x) and Q(a,x) for accuracy specified by IND and returns tuple (p,q)) |
 | [`gamma_inc_inv(a,p,q)`](@ref SpecialFunctions.gamma_inc_inv)        | [inverse of incomplete gamma function ratio P(a,x) and Q(a,x)](https://en.wikipedia.org/wiki/Incomplete_gamma_function) (i.e evaluates x given P(a,x)=p and Q(a,x)=q)                                |
@@ -34,11 +34,11 @@ Here the *Special Functions* are listed according to the structure of [NIST Digi
 
 | Function | Description |
 |:-------- |:----------- |
-| [`expint(ν, z)`](@ref SpecialFunctions.expint) | [exponential integral](https://en.wikipedia.org/wiki/Exponential_integral) ``\operatorname{E}_\nu(z)``            |
-| [`expinti(x)`](@ref SpecialFunctions.expinti)  | [exponential integral](https://en.wikipedia.org/wiki/Exponential_integral) ``\operatorname{Ei}(x)``               |
-| [`expintx(x)`](@ref SpecialFunctions.expintx)  | scaled [exponential integral](https://en.wikipedia.org/wiki/Exponential_integral) ``e^z \operatorname{E}_\nu(z)`` |
-| [`sinint(x)`](@ref SpecialFunctions.sinint)    | [sine integral](https://en.wikipedia.org/wiki/Trigonometric_integral#Sine_integral) ``\operatorname{Si}(x)``      |
-| [`cosint(x)`](@ref SpecialFunctions.cosint)    | [cosine integral](https://en.wikipedia.org/wiki/Trigonometric_integral#Cosine_integral) ``\operatorname{Ci}(x)``  |
+| [`expint(ν, z)`](@ref SpecialFunctions.expint) | [exponential integral](https://en.wikipedia.org/wiki/Exponential_integral) ``\operatorname{E}_ν(z)``             |
+| [`expinti(x)`](@ref SpecialFunctions.expinti)  | [exponential integral](https://en.wikipedia.org/wiki/Exponential_integral) ``\operatorname{Ei}(x)``              |
+| [`expintx(x)`](@ref SpecialFunctions.expintx)  | scaled [exponential integral](https://en.wikipedia.org/wiki/Exponential_integral) ``e^z \operatorname{E}_ν(z)``  |
+| [`sinint(x)`](@ref SpecialFunctions.sinint)    | [sine integral](https://en.wikipedia.org/wiki/Trigonometric_integral#Sine_integral) ``\operatorname{Si}(x)``     |
+| [`cosint(x)`](@ref SpecialFunctions.cosint)    | [cosine integral](https://en.wikipedia.org/wiki/Trigonometric_integral#Cosine_integral) ``\operatorname{Ci}(x)`` |
 
 
 ## Error Functions, Dawson’s and Fresnel Integrals
@@ -56,7 +56,7 @@ Here the *Special Functions* are listed according to the structure of [NIST Digi
 | [`logerfcx(x)`](@ref SpecialFunctions.logerfcx) | log of the scaled complementary error function, i.e. accurate ``\operatorname{ln}(\operatorname{erfcx}(x))`` for large negative ``x`` |
 | [`erfi(x)`](@ref SpecialFunctions.erfi)         | imaginary error function defined as ``-i \operatorname{erf}(ix)`` |
 | [`erfinv(x)`](@ref SpecialFunctions.erfinv)     | inverse function to [`erf()`](@ref SpecialFunctions.erf) |
-| [`dawson(x)`](@ref SpecialFunctions.dawson)     | scaled imaginary error function, a.k.a. Dawson function, i.e. accurate ``\frac{\sqrt{\pi}}{2} e^{-x^2} \operatorname{erfi}(x)`` for large ``x`` |
+| [`dawson(x)`](@ref SpecialFunctions.dawson)     | scaled imaginary error function, a.k.a. Dawson function, i.e. accurate ``\frac{\sqrt{π}}{2} e^{-x^2} \operatorname{erfi}(x)`` for large ``x`` |
 | [`faddeeva(x)`](@ref SpecialFunctions.faddeeva) | [Faddeeva function](https://en.wikipedia.org/wiki/Faddeeva_function), equivalent to ``\operatorname{erfcx}(-ix)`` |
 
 

src/bessel.jl

@@ -465,7 +465,7 @@ end
 @doc raw"""
     besseli(nu, x)
 
-Modified Bessel function of the first kind of order `nu`, ``I_\nu(x)``.
+Modified Bessel function of the first kind of order `nu`, ``I_ν(x)``.
 
 External links:
 [DLMF 10.25.2](https://dlmf.nist.gov/10.25.2),
@@ -486,7 +486,7 @@ end
 @doc raw"""
     besselix(nu, x)
 
-Scaled modified Bessel function of the first kind of order `nu`, ``I_\nu(x) e^{- | \operatorname{Re}(x) |}``.
+Scaled modified Bessel function of the first kind of order `nu`, ``I_ν(x) e^{- | \operatorname{Re}(x) |}``.
 
 External links:
 [DLMF 10.25.2](https://dlmf.nist.gov/10.25.2),
@@ -507,7 +507,7 @@ end
 @doc raw"""
     besselj(nu, x)
 
-Bessel function of the first kind of order `nu`, ``J_\nu(x)``.
+Bessel function of the first kind of order `nu`, ``J_ν(x)``.
 
 External links:
 [DLMF 10.2.2](https://dlmf.nist.gov/10.2.2),
@@ -532,7 +532,7 @@ end
 @doc raw"""
     besseljx(nu, x)
 
-Scaled Bessel function of the first kind of order `nu`, ``J_\nu(x) e^{- | \operatorname{Im}(x) |}``.
+Scaled Bessel function of the first kind of order `nu`, ``J_ν(x) e^{- | \operatorname{Im}(x) |}``.
 
 External links:
 [DLMF 10.2.2](https://dlmf.nist.gov/10.2.2),
@@ -553,7 +553,7 @@ end
 @doc raw"""
     besselk(nu, x)
 
-Modified Bessel function of the second kind of order `nu`, ``K_\nu(x)``.
+Modified Bessel function of the second kind of order `nu`, ``K_ν(x)``.
 
 External links:
 [DLMF 10.25.3](https://dlmf.nist.gov/10.25.3),
@@ -576,7 +576,7 @@ end
 @doc raw"""
     besselkx(nu, x)
 
-Scaled modified Bessel function of the second kind of order `nu`, ``K_\nu(x) e^x``.
+Scaled modified Bessel function of the second kind of order `nu`, ``K_ν(x) e^x``.
 
 External links:
 [DLMF 10.25.3](https://dlmf.nist.gov/10.25.3),
@@ -599,7 +599,7 @@ end
 """
     bessely(nu, x)
 
-Bessel function of the second kind of order `nu`, ``Y_\\nu(x)``.
+Bessel function of the second kind of order `nu`, ``Y_ν(x)``.
 
 External links:
 [DLMF 10.2.3](https://dlmf.nist.gov/10.2.3),
@@ -620,7 +620,7 @@ end
     besselyx(nu, x)
 
 Scaled Bessel function of the second kind of order `nu`,
-``Y_\\nu(x) e^{- | \\operatorname{Im}(x) |}``.
+``Y_ν(x) e^{- | \\operatorname{Im}(x) |}``.
 
 External links:
 [DLMF 10.2.3](https://dlmf.nist.gov/10.2.3),
@@ -784,7 +784,7 @@ sphericalbessely(nu, x::T) where {T} = √((float(T))(π)/2x) * bessely(nu + one
 """
     hankelh1(nu, x)
 
-Bessel function of the third kind of order `nu`, ``H^{(1)}_\\nu(x)``.
+Bessel function of the third kind of order `nu`, ``H^{(1)}_ν(x)``.
 
 External links:
 [DLMF 10.2.5](https://dlmf.nist.gov/10.2.5),
@@ -797,7 +797,7 @@ hankelh1(nu, z) = besselh(nu, 1, z)
 """
     hankelh2(nu, x)
 
-Bessel function of the third kind of order `nu`, ``H^{(2)}_\\nu(x)``.
+Bessel function of the third kind of order `nu`, ``H^{(2)}_ν(x)``.
 
 External links:
 [DLMF 10.2.6](https://dlmf.nist.gov/10.2.6),
@@ -810,7 +810,7 @@ hankelh2(nu, z) = besselh(nu, 2, z)
 """
     hankelh1x(nu, x)
 
-Scaled Bessel function of the third kind of order `nu`, ``H^{(1)}_\\nu(x) e^{-x i}``.
+Scaled Bessel function of the third kind of order `nu`, ``H^{(1)}_ν(x) e^{-x i}``.
 
 External links:
 [DLMF 10.2.5](https://dlmf.nist.gov/10.2.5),
@@ -823,7 +823,7 @@ hankelh1x(nu, z) = besselhx(nu, 1, z)
 @doc raw"""
     hankelh2x(nu, x)
 
-Scaled Bessel function of the third kind of order `nu`, ``H^{(2)}_\nu(x) e^{x i}``.
+Scaled Bessel function of the third kind of order `nu`, ``H^{(2)}_ν(x) e^{x i}``.
 
 External links:
 [DLMF 10.2.6](https://dlmf.nist.gov/10.2.6),
@@ -839,7 +839,7 @@ hankelh2x(nu, z) = besselhx(nu, 2, z)
 Bessel function of the first kind divided by `x`.
 Following convention:
 ```math
-\operatorname{jinc}{x} = \frac{2 J_1({\pi x})}{\pi x}.
+\operatorname{jinc}{x} = \frac{2 J_1({π x})}{π x}.
 ```
 Sometimes known as sombrero or besinc function.
 

src/beta_inc.jl

@@ -7,7 +7,7 @@ const exparg_p =  log(prevfloat(floatmax(Float64)))
 @doc raw"""
     loggammadiv(a,b)
 
-Computes ``\log(\Gamma(b)/\Gamma(a+b))`` when `b >= 8`
+Computes ``\log(Γ(b)/Γ(a+b))`` when `b >= 8`
 """
 loggammadiv(a::Number, b::Number) = _loggammadiv(promote(float(a), float(b))...)
 
@@ -76,7 +76,7 @@ end
 @doc raw"""
     esum(mu,x)
 
-Compute ``e^{\mu+x}``
+Compute ``e^{μ+x}``
 """
 function esum(mu::Float64, x::Float64)
     if x > 0.0
@@ -95,7 +95,7 @@ end
 @doc raw"""
     beta_integrand(a, b, x, y, mu=0.0)
 
-Compute ``e^{\mu} x^a y^b / B(a,b)``
+Compute ``e^{μ} x^a y^b / B(a,b)``
 """
 function beta_integrand(a::Float64, b::Float64, x::Float64, y::Float64, mu::Float64=0.0)
     a0, b0 = minmax(a,b)
@@ -181,7 +181,7 @@ end
     beta_inc_cont_fraction(a,b,x,y,lambda,epps)
 
 Compute ``I_{x}(a,b)`` using continued fraction expansion when `a, b > 1`.
-It is assumed that ``\lambda = (a+b)*y - b``
+It is assumed that ``λ = (a+b)*y - b``
 
 External links:
 [DLMF 8.17.22](https://dlmf.nist.gov/8.17.22),
@@ -251,7 +251,7 @@ end
     beta_inc_asymptotic_symmetric(a,b,lambda,epps)
 
 Compute ``I_{x}(a,b)`` using asymptotic expansion for `a, b >= 15`.
-It is assumed that ``\lambda = (a+b)*y - b``.
+It is assumed that ``λ = (a+b)*y - b``.
 
 External links:
 [DLMF 8.17.22](https://dlmf.nist.gov/8.17.22),
@@ -525,7 +525,7 @@ end
 
 Computes ``I_x(a,b)`` using power series:
 ```math
-I_{x}(a,b) = G(a,b) x^{a}/a \left[1 + a \sum_{j=1}^{\infty} ((1-b)(2-b)\dots(j-b)/j!(a+j)) x^{j}\right]
+I_{x}(a,b) = G(a,b) x^{a}/a \left[1 + a \sum_{j=1}^∞ ((1-b)(2-b)\dots(j-b)/j!(a+j)) x^{j}\right]
 ```
 External links:
 [DLMF 8.17.22](https://dlmf.nist.gov/8.17.22),
@@ -733,9 +733,9 @@ end
 Return a tuple ``(I_{x}(a,b), 1-I_{x}(a,b))`` where ``I_{x}(a,b)`` is the regularized
 incomplete beta function given by
 ```math
-I_{x}(a,b) = \frac{1}{B(a,b)} \int_{0}^{x} t^{a-1}(1-t)^{b-1} \mathrm{d}t,
+I_{x}(a,b) = \frac{1}{B(a,b)} \int_0^x t^{a-1}(1-t)^{b-1} \mathrm{d}t,
 ```
-where ``B(a,b) = \Gamma(a)\Gamma(b)/\Gamma(a+b)``.
+where ``B(a,b) = Γ(a)Γ(b)/Γ(a+b)``.
 
 External links:
 [DLMF 8.17.1](https://dlmf.nist.gov/8.17.1),

src/betanc.jl

@@ -10,9 +10,9 @@ const errmax = 1e-15
 Compute tail of the noncentral beta distribution.
 Uses the recursive relation
 ```math
-I_{x}(a,b+1;0) = I_{x}(a,b;0) - \Gamma(a+b)/\Gamma(a+1)\Gamma(b) x^a (1-x)^b
+I_{x}(a,b+1;0) = I_{x}(a,b;0) - Γ(a+b)/Γ(a+1)Γ(b) x^a (1-x)^b
 ```
-and ``\Gamma(a+1) = a\Gamma(a)`` given in [DLMF 8.17.21](https://dlmf.nist.gov/8.17.21).
+and ``Γ(a+1) = aΓ(a)`` given in [DLMF 8.17.21](https://dlmf.nist.gov/8.17.21).
 """
 function ncbeta_tail(a::Float64, b::Float64, lambda::Float64, x::Float64)
     if x <= 0.0
@@ -55,16 +55,16 @@ end
     ncbeta_poisson(a,b,lambda,x)
 
 Compute CDF of noncentral beta if `lambda >= 54` using:
-First ``\lambda/2`` is calculated and the Poisson term is calculated using
-``P(j-1) = j/\lambda P(j)`` and ``P(j+1) = \lambda/(j+1) P(j)``.
+First ``λ/2`` is calculated and the Poisson term is calculated using
+``P(j-1) = j/λ P(j)`` and ``P(j+1) = λ/(j+1) P(j)``.
 Then backward recurrences are used until either the Poisson weights fall below
 `errmax` or `iterlo` is reached.
 ```math
-I_{x}(a+j-1,b) = I_{x}(a+j,b) + \Gamma(a+b+j-1)/\Gamma(a+j)\Gamma(b)x^{a+j-1}(1-x)^{b}
+I_{x}(a+j-1,b) = I_{x}(a+j,b) + Γ(a+b+j-1)/Γ(a+j)Γ(b) x^{a+j-1} (1-x)^{b}
 ```
 Then forward recurrences are used until error bound falls below `errmax`.
 ```math
-I_{x}(a+j+1,b) = I_{x}(a+j,b) - \Gamma(a+b+j)/\Gamma(a+j)\Gamma(b)x^{a+j}(1-x)^{b}
+I_{x}(a+j+1,b) = I_{x}(a+j,b) - Γ(a+b+j)/Γ(a+j)Γ(b) x^{a+j} (1-x)^{b}
 ```
 """
 function ncbeta_poisson(a::Float64, b::Float64, lambda::Float64, x::Float64)
@@ -147,10 +147,10 @@ end
 
 Compute the CDF of the noncentral beta distribution given by
 ```math
-I_{x}(a,b; \lambda) = \sum_{j=0}^{\infty} q(\lambda/2,j) I_{x}(a+j,b;0)
+I_{x}(a,b; λ) = \sum_{j=0}^∞ q(λ/2,j) I_{x}(a+j,b;0)
 ```
-For ``\lambda < 54`` : algorithm suggested by Lenth(1987) in `ncbeta_tail(a,b,lambda,x)`.
-Else for ``\lambda \geq 54``: modification in Chattamvelli(1997) in
+For ``λ < 54`` : algorithm suggested by Lenth(1987) in `ncbeta_tail(a,b,lambda,x)`.
+Else for ``λ ≥ 54``: modification in Chattamvelli(1997) in
 `ncbeta_poisson(a,b,lambda,x)` by using both forward and backward recurrences.
 """
 function ncbeta(a::Float64, b::Float64, lambda::Float64, x::Float64)
@@ -173,9 +173,9 @@ end
 
 Compute CDF of noncentral F distribution given by:
 ```math
-F(x, v_1, v_2; \lambda) = I_{v_1 x/(v_1 x + v_2)}(v_1/2, v_2/2; \lambda)
+F(x, v_1, v_2; λ) = I_{v_1 x/(v_1 x + v_2)}(v_1/2, v_2/2; λ)
 ```
-where ``I_{x}(a,b; \lambda)`` is the noncentral beta function computed above.
+where ``I_{x}(a,b; λ)`` is the noncentral beta function computed above.
 
 External links:
 [Wikipedia](https://en.wikipedia.org/wiki/Noncentral_F-distribution)

src/ellip.jl

@@ -11,8 +11,8 @@ Computes Complete Elliptic Integral of 1st kind ``K(m)`` for parameter ``m`` giv
 ```math
 \operatorname{ellipk}(m)
 = K(m)
-= \int_0^{ \frac{\pi}{2} } \frac{1}{\sqrt{1 - m \sin^2 \theta}} \, \mathrm{d}\theta
-\quad \text{for} \quad m \in \left( -\infty, 1 \right] \, .
+= \int_0^{ \frac{π}{2} } \frac{1}{\sqrt{1 - m \sin^2 θ}} \, \mathrm{d}θ
+\quad \text{for} \quad m \in \left( -∞, 1 \right] \, .
 ```
 
 External links:
@@ -22,9 +22,9 @@ External links:
 See also: [`ellipe(m)`](@ref SpecialFunctions.ellipe).
 
 # Arguments
-- `m`: parameter ``m``, restricted to the domain ``(-\infty,1]``, is related to
+- `m`: parameter ``m``, restricted to the domain ``(-∞,1]``, is related to
        the elliptic modulus ``k`` by ``k^2=m`` and to the modular angle
-       ``\alpha`` by ``k = \sin \alpha``.
+       ``α`` by ``k = \sin α``.
 
 # Implementation
 Using piecewise approximation polynomial as given in
@@ -40,7 +40,7 @@ For ``m<0``, followed by
 > Journal of Computational and Applied Mathematics. 282.
 > DOI 10.13140/2.1.1946.6245.,
 > <https://www.researchgate.net/publication/267330394>
-As suggested in this paper, the domain is restricted to ``(-\infty,1]``.
+As suggested in this paper, the domain is restricted to ``(-∞,1]``.
 """
 ellipk(m::Real) = _ellipk(float(m))
 
@@ -191,8 +191,8 @@ Computes Complete Elliptic Integral of 2nd kind ``E(m)`` for parameter ``m`` giv
 ```math
 \operatorname{ellipe}(m)
 = E(m)
-= \int_0^{ \frac{\pi}{2} } \sqrt{1 - m \sin^2 \theta} \, \mathrm{d}\theta
-\quad \text{for} \quad m \in \left( -\infty, 1 \right] .
+= \int_0^{ \frac{π}{2} } \sqrt{1 - m \sin^2 θ} \, \mathrm{d}θ
+\quad \text{for} \quad m \in \left( -∞, 1 \right] .
 ```
 
 External links:
@@ -202,9 +202,9 @@ External links:
 See also: [`ellipk(m)`](@ref SpecialFunctions.ellipk).
 
 # Arguments
-- `m`: parameter ``m``, restricted to the domain ``(-\infty,1]``, is related to
+- `m`: parameter ``m``, restricted to the domain ``(-∞,1]``, is related to
        the elliptic modulus ``k`` by ``k^2=m`` and to the modular angle
-       ``\alpha`` by ``k=\sin \alpha``.
+       ``α`` by ``k = \sin α``.
 
 # Implementation
 Using piecewise approximation polynomial as given in
@@ -220,7 +220,7 @@ For ``m<0``, followed by
 > Journal of Computational and Applied Mathematics. 282.
 > DOI 10.13140/2.1.1946.6245.,
 > <https://www.researchgate.net/publication/267330394>
-As suggested in this paper, the domain is restricted to ``(-\infty,1]``.
+As suggested in this paper, the domain is restricted to ``(-∞,1]``.
 """
 ellipe(m::Real) = _ellipe(float(m))
 

src/erf.jl

@@ -82,7 +82,7 @@ end
 Compute the error function of ``x``, defined by
 
 ```math
-\operatorname{erf}(x) = \frac{2}{\sqrt{\pi}} \int_0^x \exp(-t^2) \; \mathrm{d}t
+\operatorname{erf}(x) = \frac{2}{\sqrt{π}} \int_0^x \exp(-t^2) \; \mathrm{d}t
 \quad \text{for} \quad x \in \mathbb{C} \, .
 ```
 
@@ -126,7 +126,7 @@ Compute the complementary error function of ``x``, defined by
 ```math
 \operatorname{erfc}(x)
 = 1 - \operatorname{erf}(x)
-= \frac{2}{\sqrt{\pi}} \int_x^\infty \exp(-t^2) \; \mathrm{d}t
+= \frac{2}{\sqrt{π}} \int_x^∞ \exp(-t^2) \; \mathrm{d}t
 \quad \text{for} \quad x \in \mathbb{C} \, .
 ```
 
@@ -200,11 +200,11 @@ Compute the Dawson function (scaled imaginary error function) of ``x``, defined
 
 ```math
 \operatorname{dawson}(x)
-= \frac{\sqrt{\pi}}{2} e^{-x^2} \operatorname{erfi}(x)
+= \frac{\sqrt{π}}{2} e^{-x^2} \operatorname{erfi}(x)
 \quad \text{for} \quad x \in \mathbb{C} \, .
 ```
 
-This is the accurate version of ``\frac{\sqrt{\pi}}{2} e^{-x^2} \operatorname{erfi}(x)``
+This is the accurate version of ``\frac{\sqrt{π}}{2} e^{-x^2} \operatorname{erfi}(x)``
 for large ``x``.
 
 External links: [DLMF 7.2.5](https://dlmf.nist.gov/7.2.5),