gsl/ 0000755 0001762 0000144 00000000000 14364037712 011046 5 ustar ligges users gsl/NAMESPACE 0000644 0001762 0000144 00000013772 14363633553 012303 0 ustar ligges users export("airy_Ai")
export("airy_Ai_deriv")
export("airy_Ai_deriv_scaled")
export("airy_Ai_scaled")
export("airy_Bi")
export("airy_Bi_deriv")
export("airy_Bi_deriv_scaled")
export("airy_Bi_scaled")
export("airy_zero_Ai")
export("airy_zero_Ai_deriv")
export("airy_zero_Bi")
export("airy_zero_Bi_deriv")
export("atanint")
export("bessel_I0")
export("bessel_i0_scaled")
export("bessel_I0_scaled")
export("bessel_I1")
export("bessel_i1_scaled")
export("bessel_I1_scaled")
export("bessel_i2_scaled")
export("bessel_il_scaled")
export("bessel_il_scaled_array")
export("bessel_In")
export("bessel_In_array")
export("bessel_In_scaled")
export("bessel_In_scaled_array")
export("bessel_Inu")
export("bessel_Inu_scaled")
export("bessel_j0")
export("bessel_J0")
export("bessel_j1")
export("bessel_J1")
export("bessel_j2")
export("bessel_jl")
export("bessel_jl_array")
export("bessel_jl_steed_array")
export("bessel_Jn")
export("bessel_Jn_array")
export("bessel_Jnu")
export("bessel_K0")
export("bessel_k0_scaled")
export("bessel_K0_scaled")
export("bessel_K1")
export("bessel_k1_scaled")
export("bessel_K1_scaled")
export("bessel_k2_scaled")
export("bessel_kl_scaled")
export("bessel_kl_scaled_array")
export("bessel_Kn")
export("bessel_Kn_array")
export("bessel_Kn_scaled")
export("bessel_Kn_scaled_array")
export("bessel_Knu")
export("bessel_Knu_scaled")
export("bessel_lnKnu")
export("bessel_sequence_Jnu")
export("bessel_y0")
export("bessel_Y0")
export("bessel_y1")
export("bessel_Y1")
export("bessel_y2")
export("bessel_yl")
export("bessel_yl_array")
export("bessel_Yn")
export("bessel_Yn_array")
export("bessel_Ynu")
export("bessel_zero_J0")
export("bessel_zero_J1")
export("bessel_zero_Jnu")
export("beta_inc")
export("Chi")
export("Ci")
export("clausen")
export("complex_cos")
export("complex_dilog")
export("complex_log")
export("complex_logsin")
export("complex_sin")
export("conicalP_0")
export("conicalP_1")
export("conicalP_cyl_reg")
export("conicalP_half")
export("conicalP_mhalf")
export("conicalP_sph_reg")
export("coulomb_CL")
export("coulomb_CL_array")
export("coulomb_wave_F_array")
export("coulomb_wave_FG")
export("coulomb_wave_FG_array")
export("coulomb_wave_FGp_array")
export("coulomb_wave_sphF_array")
export("coupling_3j")
export("coupling_6j")
export("coupling_9j")
export("dawson")
export("debye_1")
export("debye_2")
export("debye_3")
export("debye_4")
export("deprecated_legendre")
export("dilog")
export("doublefact")
export("ellint_D")
export("ellint_E")
export("ellint_Ecomp")
export("ellint_F")
export("ellint_Kcomp")
export("ellint_P")
export("ellint_RC")
export("ellint_RD")
export("ellint_RF")
export("ellint_RJ")
export("elljac")
export("erf")
export("erf_Q")
export("erf_Z")
export("erfc")
export("eta")
export("eta_int")
export("expint_3")
export("expint_E1")
export("expint_E2")
export("expint_Ei")
export("expint_En")
export("fact")
export("fermi_dirac_0")
export("fermi_dirac_1")
export("fermi_dirac_2")
export("fermi_dirac_3half")
export("fermi_dirac_half")
export("fermi_dirac_inc_0")
export("fermi_dirac_int")
export("fermi_dirac_m1")
export("fermi_dirac_mhalf")
export("gamma_inc")
export("gamma_inc_P")
export("gamma_inc_Q")
export("gammainv")
export("gammastar")
export("gegenpoly_1")
export("gegenpoly_2")
export("gegenpoly_3")
export("gegenpoly_array")
export("gegenpoly_n")
export("gsl_cd")
export("gsl_cn")
export("gsl_cs")
export("gsl_dc")
export("gsl_dn")
export("gsl_ds")
export("gsl_nc")
export("gsl_nd")
export("gsl_ns")
export("gsl_poly")
export("gsl_sc")
export("gsl_sd")
export("gsl_sf_beta")
export("gsl_sf_choose")
export("gsl_sf_cos")
export("gsl_sf_gamma")
export("gsl_sf_log")
export("gsl_sf_sin")
export("gsl_sn")
export("hazard")
export("hydrogenicR")
export("hydrogenicR_1")
export("hyperg_0F1")
export("hyperg_1F1")
export("hyperg_1F1_int")
export("hyperg_2F0")
export("hyperg_2F1")
export("hyperg_2F1_conj")
export("hyperg_2F1_conj_renorm")
export("hyperg_2F1_renorm")
export("hyperg_U")
export("hyperg_U_int")
export("hypot")
export("hzeta")
export("laguerre_1")
export("laguerre_2")
export("laguerre_3")
export("laguerre_n")
export("lambert_W0")
export("lambert_Wm1")
export("legendre_array")
export("legendre_array_index")
export("legendre_array_n")
export("legendre_array_size")
export("legendre_check_args")
export("legendre_deriv_alt_array")
export("legendre_deriv_array")
export("legendre_deriv2_alt_array")
export("legendre_deriv2_array")
export("legendre_H3d")
export("legendre_H3d_0")
export("legendre_H3d_1")
export("legendre_H3d_array")
export("legendre_P1")
export("legendre_P2")
export("legendre_P3")
export("legendre_Pl")
export("legendre_Pl_array")
export("legendre_Plm")
export("legendre_Plm_array")
export("legendre_Plm_deriv_array")
export("legendre_Q0")
export("legendre_Q1")
export("legendre_Ql")
export("legendre_sphPlm")
export("legendre_sphPlm_array")
export("legendre_sphPlm_deriv_array")
export("lnbeta")
export("lnchoose")
export("lncosh")
export("lndoublefact")
export("lnfact")
export("lngamma")
export("lngamma_complex")
export("lngamma_sgn")
export("lnpoch")
export("lnpoch_sgn")
export("lnsinh")
export("log_1plusx")
export("log_1plusx_mx")
export("log_abs")
export("log_erfc")
export("multimin")
export("multimin.fminimizer.size")
export("multimin.init")
export("multimin.iterate")
export("poch")
export("pochrel")
export("pow_int")
export("process.args")
export("psi")
export("psi_1")
export("psi_1_int")
export("psi_1piy")
export("psi_int")
export("psi_n")
export("qrng_alloc")
export("qrng_clone")
export("qrng_get")
export("qrng_init")
export("qrng_name")
export("qrng_size")
export("rng_alloc")
export("rng_clone")
export("rng_get")
export("rng_max")
export("rng_min")
export("rng_name")
export("rng_set")
export("rng_uniform")
export("rng_uniform_int")
export("rng_uniform_pos")
export("Shi")
export("Si")
export("sinc")
export("sn_cn_dn")
export("strictify")
export("synchrotron_1")
export("synchrotron_2")
export("taylorcoeff")
export("transport_2")
export("transport_3")
export("transport_4")
export("transport_5")
export("zeta")
export("zeta_int")
export("zetam1")
export("zetam1_int")
useDynLib(gsl, .registration = TRUE, .fixes= "C_")
gsl/INSTALL 0000644 0001762 0000144 00000001563 14363633553 012110 0 ustar ligges users The gsl R package is a wrapper for the GSL C library (note capitalization).
Installing gsl from source requires you to download and install GSL
first. Ensure that you can compile and run a simple test program such
as the example program near the start of the GSL Reference Manual.
You will need at least GSL version 2.5: using earlier versions will
give errors such as
error: too few arguments to function 'gsl_sf_ellint_D_e'
Some linux users report that is is possoble to go to the Ubuntu
Software Center and install "GNU Scientific Library (GSL) --
development package", which has the name "libgsl0-dev".
If the gsl R package builds successfully but will not load, make sure
to inform your system linker/loader where to find the GSL libraries
used to compile it. That step may be missed when using a manual GSL
installation as opposed to one performed by a package manager. gsl/README.md 0000644 0001762 0000144 00000003534 14363633553 012336 0 ustar ligges users The gsl R package: a wrapper for the GSL C library
================
[](https://CRAN.R-project.org/package=gsl)
[](https://travis-ci.org/RobinHankin/gsl)
[](https://cran.r-project.org/package=gsl)
[](https://codecov.io/gh/RobinHankin/gsl/branch/master)
The gsl R package is a wrapper for the GSL C library (note
capitalization). You can get further information on GSL at
https://www.gnu.org/software/gsl/
# Installation from CRAN
You can install the released version of the gsl R package from
[CRAN](https://CRAN.R-project.org) by typing
`install.packages("gsl")`
`library("gsl")`
at the R command prompt.
# Installation from source
Installing the gsl R package from source requires you to install the
GSL C library first. *About 80% of reports to me about gsl are due to
people not understanding what this means*.
Before reporting any "bugs", ensure that you can compile and run a
simple test program such as the example program near the start of the
GSL Reference Manual. It is not the purpose of this document to show
people how to install GSL: for this, visit
https://www.gnu.org/software/gsl/
You will need at least GSL version 2.5: using earlier versions
generally gives errors such as
error: too few arguments to function 'gsl_sf_ellint_D_e'
*About 20% of reports to me about gsl are due to an insufficient
version of GSL*.
# Further information
For more detail on package structure and design philosophy, see the
package vignette
`vignette("gsl")`
gsl/man/ 0000755 0001762 0000144 00000000000 14363633553 011625 5 ustar ligges users gsl/man/Dawson.Rd 0000644 0001762 0000144 00000001355 14363633553 013353 0 ustar ligges users \name{Dawson}
\alias{Dawson}
\alias{dawson}
\title{Dawson functions}
\description{
Dawson functions as per the Gnu Scientific Library, reference manual
section 7.9. These functions are declared in header file
\code{gsl_sf_dawson.h}
}
\usage{
dawson(x, give=FALSE, strict=TRUE)
}
\arguments{
\item{x}{input: real values}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error}
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
x <- seq(from=0,to=2,by=0.01)
dawson(x) #table 7.5 of Ab and St
}
\keyword{array}
gsl/man/Coupling.Rd 0000644 0001762 0000144 00000002264 14363633553 013700 0 ustar ligges users \name{Coupling}
\alias{Coupling}
\alias{coupling}
\alias{coupling_3j}
\alias{coupling_6j}
\alias{coupling_9j}
\title{Coupling functions}
\description{
Coupling functions as per the Gnu Scientific Library, reference manual
section 7.8. These functions are declared in header file
\code{gsl_sf_coupling.h}
}
\usage{
coupling_3j(two_ja, two_jb, two_jc, two_ma, two_mb, two_mc, give=FALSE, strict=TRUE)
coupling_6j(two_ja, two_jb, two_jc, two_jd, two_je, two_jf, give=FALSE, strict=TRUE)
coupling_9j(two_ja, two_jb, two_jc, two_jd, two_je, two_jf,
two_jg, two_jh, two_ji, give=FALSE, strict=TRUE)
}
\arguments{
\item{two_ja, two_jb, two_jc, two_jd, two_je, two_jf, two_jg, two_jh,
two_ji, two_ma, two_mb, two_mc}{Arguments as per the \acronym{GSL} manual}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error}
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
coupling_3j(1,2,3,4,5,6)
coupling_6j(1,2,3,4,5,6)
coupling_9j(1,2,3,4,5,6,7,8,9)
}
\keyword{array}
gsl/man/Pow_int.Rd 0000644 0001762 0000144 00000001374 14363633553 013540 0 ustar ligges users \name{Powint}
\alias{pow_int}
\alias{Pow_int}
\alias{powint}
\title{Power functions}
\description{
Power functions as per the Gnu Scientific Library reference manual
section 7.27. These functions are declared in the header file
\code{gsl_sf_pow_int.h}
}
\usage{
pow_int(x, n, give=FALSE, strict=TRUE)
}
\arguments{
\item{x}{input: real values}
\item{n}{input: integer values}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error}
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
pow_int(pi/2,1:10)
}
\keyword{array}
gsl/man/Poly.Rd 0000644 0001762 0000144 00000002632 14363633553 013042 0 ustar ligges users \name{Poly}
\alias{Poly}
\alias{poly}
\alias{gsl_poly}
\title{Polynomials}
\description{
Polynomial functions as per the Gnu Scientific Library, reference manual
section 6.1. These functions are defined in header
file \code{gsl_poly.h}
}
\usage{
gsl_poly(c_gsl,x)
}
\arguments{
\item{c_gsl}{Coefficients of the poynomial (\code{c} in the function
definition and the \acronym{GSL} ref manual) starting at the constant term and
ending in the highest power; see details section. This argument is
called \dQuote{\code{c_gsl}} (and not \dQuote{\code{c}}) to avoid
confusion with \R function \code{c()}}
\item{x}{input: real values}
}
\details{
One must be careful to avoid off-by-one errors. In C idiom, the
function evaluates the polynomial
\deqn{c[0]+c[1]x+c[2]x^2+\ldots+c[\mathrm{len}-1]x^{\mathrm{len}-1}}{c[0]+c[1]+...+c[len-1]x^(len-1)}
where len is the second argument of \acronym{GSL} function
\code{gsl_poly_eval()}.
The \R idiom would be
\deqn{c[1]+c[2]x+c[3]x^2+\ldots+c[\mathrm{len}]x^{\mathrm{len}-1}.}{c[1]+c[2]+...+c[len]x^(len-1).}
This section is work-in-progress and more will be added when I have
the time/need for the other functions here.
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
a <- matrix(1:4,2,2)
rownames(a) <- letters[1:2]
(jj <- gsl_poly(1:3,a))
jj-(1 + 2*a + 3*a^2) #should be small
}
\keyword{array}
gsl/man/Psi.Rd 0000644 0001762 0000144 00000002224 14363633553 012647 0 ustar ligges users \name{Psi}
\alias{Psi}
\alias{psi_int}
\alias{psi}
\alias{psi_1piy}
\alias{psi_1_int}
\alias{psi_1}
\alias{psi_n}
\title{Psi (digamma) functions}
\description{
Psi (digamma) functions as per the Gnu Scientific Library, reference
manual section 7.27. These functions are declared in header file
\code{gsl_sf_psi.h}
}
\usage{
psi_int(n, give=FALSE, strict=TRUE)
psi(x, give=FALSE, strict=TRUE)
psi_1piy(y, give=FALSE, strict=TRUE)
psi_1_int(n, give=FALSE, strict=TRUE)
psi_1(x, give=FALSE, strict=TRUE)
psi_n(m, x, give=FALSE, strict=TRUE)
}
\arguments{
\item{m,n}{input: integer values}
\item{x,y}{input: real values}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number}
\item{strict}{Boolean, with default \code{TRUE} meaning to return \code{NaN}
if status is an error}
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
x <- seq(from=1.2,to=1.25,by=0.005)
cbind(x,psi(x),psi_1(x))
#tabe 6.1, p267, bottom bit
psi_int(1:6)
psi(pi+(1:6))
psi_1piy(pi+(1:6))
psi_1_int(1:6)
psi_n(m=5,x=c(1.123,1.6523))
}
\keyword{array}
gsl/man/Elljac.Rd 0000644 0001762 0000144 00000003773 14363633553 013320 0 ustar ligges users \name{Elljac}
\alias{Elljac}
\alias{elljac}
\alias{sn_cn_dn}
\alias{gsl_sn}
\alias{gsl_cn}
\alias{gsl_dn}
\alias{gsl_ns}
\alias{gsl_nc}
\alias{gsl_nd}
\alias{gsl_sc}
\alias{gsl_sd}
\alias{gsl_cs}
\alias{gsl_cd}
\alias{gsl_ds}
\alias{gsl_dc}
\title{Elliptic functions}
\description{
Elljac functions as per the Gnu Scientific Library, reference manual
section 7.14 and AMS-55, chapter 16. These functions are
declared in header file \code{gsl_sf_elljac.h}
}
\usage{
elljac(u, m, give=FALSE, strict=TRUE)
gsl_sn(z,m)
gsl_cn(z,m)
gsl_dn(z,m)
gsl_ns(z,m)
gsl_nc(z,m)
gsl_nd(z,m)
gsl_sc(z,m)
gsl_sd(z,m)
gsl_cs(z,m)
gsl_cd(z,m)
gsl_ds(z,m)
gsl_dc(z,m)
}
\arguments{
\item{u,m}{input: real values}
\item{z}{input: complex values}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error}
}
\details{
A straightforward wrapper for the \code{gsl_sf_elljac_e}
function of the \acronym{GSL} library, except for \code{gsl_sn()}, \code{gsl_cn()}, and
\code{gsl_dn()}, which implement 16.21.1 to 16.21.4 (thus taking complex
arguments); and \code{gsl_ns()} et
seq which are the minor elliptic functions.
Function \code{sn_cn_dn()} is not really intended for the end-user.
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
K <- ellint_F(phi=pi/2,k=sqrt(1/2)) #note the sqrt: m=k^2
u <- seq(from=0,to=4*K,by=K/24)
jj <- elljac(u,1/2)
plot(u,jj$sn,type="l",xaxt="n",yaxt="n",bty="n",ylab="",xlab="",main="Fig 16.1, p570")
lines(u,jj$cn,lty=2)
lines(u,jj$dn,lty=3)
axis(1,pos=0,at=c(K,2*K,3*K,4*K),labels=c("K","2K","3K","4K"))
abline(0,0)
axis(2,pos=0,at=c(-1,1))
text(1.8*K,0.6,"sn u")
text(1.6*K,-0.5,"cn u")
text(2.6*K,0.9,"dn u")
a <- seq(from=-5,to=5,len=100)
jj <- outer(a,a,function(a,b){a})
z <- jj+1i*t(jj)
e <- Re(gsl_cd(z,m=0.2))
e[abs(e)>10] <- NA
contour(a,a,e,nlev=55)
}
\keyword{array}
gsl/man/Ellint.Rd 0000644 0001762 0000144 00000004763 14363633553 013355 0 ustar ligges users \name{Ellint}
\alias{Ellint}
\alias{ellint}
\alias{ellint_Kcomp}
\alias{ellint_Ecomp}
\alias{ellint_F}
\alias{ellint_E}
\alias{ellint_P}
\alias{ellint_D}
\alias{ellint_RC}
\alias{ellint_RD}
\alias{ellint_RF}
\alias{ellint_RJ}
\title{Elliptic functions}
\description{
Elliptic functions as per the Gnu Scientific Library, reference manual
section 7.13 and AMS-55, chapter 17. These functions are
declared in header file \code{gsl_sf_ellint.h}
}
\usage{
ellint_Kcomp(k, mode=0, give=FALSE,strict=TRUE)
ellint_Ecomp(k, mode=0, give=FALSE,strict=TRUE)
ellint_F(phi,k, mode=0, give=FALSE,strict=TRUE)
ellint_E(phi,k, mode=0, give=FALSE,strict=TRUE)
ellint_P(phi,k,n, mode=0, give=FALSE,strict=TRUE)
ellint_D(phi,k, mode=0, give=FALSE,strict=TRUE)
ellint_RC(x, y, mode=0, give=FALSE,strict=TRUE)
ellint_RD(x, y, z, mode=0, give=FALSE,strict=TRUE)
ellint_RF(x, y, z, mode=0, give=FALSE,strict=TRUE)
ellint_RJ(x, y, z, p, mode=0, give=FALSE,strict=TRUE)
}
\arguments{
\item{phi,k,n,p,x,y,z}{input: real values}
\item{give}{Boolean, with default \code{FALSE} meaning to
return just the answers, and \code{TRUE} meaning to return a status
vector as well}
\item{strict}{Boolean}
\item{mode}{input: mode. For \code{GSL_PREC_DOUBLE},
\code{GSL_PREC_SINGLE}, \code{GSL_PREC_APPROX} use \code{0,1,2}
respectively.}
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
ellint_Kcomp(0.3)
ellint_Ecomp(0.3)
ellint_F(0.4,0.7)
ellint_E(0.4,0.7)
ellint_P(0.4,0.7,0.3)
ellint_D(0.4,0.3)
ellint_RC(0.5,0.6)
ellint_RD(0.5,0.6,0.7)
ellint_RF(0.5,0.6,0.7)
ellint_RJ(0.5,0.6,0.7,0.1)
x <- seq(from=0,to=0.5,by=0.01)
col1 <- ellint_Kcomp(sqrt(x))
col2 <- ellint_Kcomp(sqrt(1-x))
col3 <- exp(-pi*col2/col1)
cbind(x,col1,col2,col3) #table 17.1, p608
x <- 0:45
col1 <- ellint_Kcomp(sin(pi/180*x))
col2 <- ellint_Kcomp(sin(pi/2-pi/180*x))
col3 <- exp(-pi*col2/col1)
cbind(x,col1,col2,col3) #table 17.2, p610
x <- seq(from=0,to=90,by=2)
f <- function(a){ellint_F(phi=a*pi/180,sin(x*pi/180))}
g <- function(a){ellint_E(phi=a*pi/180,sin(x*pi/180))}
h <- function(a,n){ellint_P(phi=a*pi/180,sin( a*15*pi/180),n)}
i <- function(x){ellint_P(phi=x*pi/180, k=sin((0:6)*15*pi/180), n= -0.6)}
cbind(x,f(5),f(10),f(15),f(20),f(25),f(30)) #table 17.5, p613
cbind(x,g(5),g(10),g(15),g(20),g(25),g(30)) #table 17.6, p616
cbind(i(15),i(30),i(45),i(60),i(75),i(90)) #table 17.9,
#(BOTTOM OF p625)
}
\keyword{array}
gsl/man/Zeta.Rd 0000644 0001762 0000144 00000002242 14363633553 013017 0 ustar ligges users \name{Zeta}
\alias{Zeta}
\alias{zeta_int}
\alias{zeta}
\alias{zetam1_int}
\alias{zetam1}
\alias{hzeta}
\alias{eta_int}
\alias{eta}
\title{Zeta functions}
\description{
Zeta functions as per the Gnu Scientific Library 7.31 and AMS-55,
section 23.2. These functions are declared in header file
\code{gsl_sf_zeta.h}
}
\usage{
zeta_int(n, give=FALSE, strict=TRUE)
zeta(s, give=FALSE, strict=TRUE)
zetam1_int(n, give=FALSE, strict=TRUE)
zetam1(s, give=FALSE, strict=TRUE)
hzeta(s, q, give=FALSE, strict=TRUE)
eta_int(n, give=FALSE, strict=TRUE)
eta(s, give=FALSE, strict=TRUE)
}
\arguments{
\item{n}{input: integer values}
\item{s,q}{input: real values}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number.}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error.}
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
n <- 1:10
cbind(n,zeta(n),eta(n)) #table 23.3, p 811
zeta_int(1:5)
zeta(c(pi,pi*2))
zetam1_int(1:5)
zetam1(c(pi,pi*2))
hzeta(1.1,1.2)
eta_int(1:5)
eta(c(pi,pi*2))
}
\keyword{array}
gsl/man/Dilog.Rd 0000644 0001762 0000144 00000002562 14363633553 013157 0 ustar ligges users \name{Dilog}
\alias{Dilog}
\alias{dilog}
\alias{polylog}
\alias{complex_dilog}
\title{Dilog functions}
\description{
Dilog functions as per the Gnu Scientific Library reference manual
section 7.11. These functions are declared in header file
\code{gsl_sf_dilog.h}
}
\usage{
dilog(x, give=FALSE, strict=TRUE)
complex_dilog(r, theta, give=FALSE, strict=TRUE)
}
\arguments{
\item{x}{input: real values}
\item{r,theta}{In \code{complex_dilog()}, input
values. If \code{theta} takes its default value of
\code{NULL}, interpret \code{r} as a complex-valued object. If
\code{theta} is non-null, interpret \code{r} as the Modulus,
and \code{theta} as the argument, of the complex object passed to
\code{gsl_sf_complex_dilog_e()}}
\item{give}{Boolean, with default \code{FALSE} meaning to
return just the answers, and \code{TRUE} meaning to return a status
vector as well}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if nonzero status is returned by the \acronym{GSL} function (\code{FALSE}
means to return the value: use with caution)}
}
\details{All functions as documented in the \acronym{GSL} reference manual section
7.11.}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
x <- seq(from=0, to=0.1,by=0.01)
cbind(x,"f(x)"=dilog(1-x)) #table 27.7, p1005
}
\keyword{array}
gsl/man/Misc.Rd 0000644 0001762 0000144 00000005074 14363633553 013015 0 ustar ligges users \name{Misc}
\alias{Misc}
\alias{misc}
\alias{process.args}
\alias{strictify}
\title{Argument processing and general info}
\description{
Various widely used functions in the package
}
\usage{
process.args(...)
strictify(val,status)
}
\arguments{
\item{...}{Argument list to be coerced to the same length}
\item{val}{Value component of \code{&result}}
\item{status}{status integer}
}
\details{
Function \code{process.args()} is an internal function used to
massage the arguments into a form suitable for passing to \code{.C()}.
For example, in function \code{hyperg_0F1(c,x)}, one wants each of
\code{hyperg_0F1(0.1, c(0.3,0.4))} and \code{hyperg_0F1(c(0.1,0.2),
0.3)} and \code{hyperg_0F1(c(0.1,0.2),c(0.3,0.4))} to behave sensibly.
Function \code{process.args()} is used widely in the package, taking an
arbitrary number of arguments and returning a list whose elements are
vectors of the same length. Most of the special functions use
\code{process.args()} to ensure that the returned value takes the
attributes of the input argument with most elements where possible.
Function \code{strictify()} uses the \code{status} value returned by
the \dQuote{error} form of the \acronym{GSL} special functions to make values
returned with a nonzero \code{error} a \code{NaN}. In most of the
special functions, \code{strictify()} is called if argument
\code{strict} takes its default value of \code{TRUE}. Setting it to
\code{FALSE} sometimes returns a numerical value as per the \acronym{GSL}
reference manual.
In most of the special functions, if argument \code{give} takes its
default value of \code{FALSE}, only a numerical value is returned.
If \code{TRUE}, error information and the status (see preceding
paragraph) is also returned.
Following tips found on R-devel:
\enumerate{
\item Download and extract source code of R-package \pkg{gsl}
\item Use \code{gsl-config --libs} to get the path to \acronym{GSL}'s
lib directory
(\code{-L}), use \code{gsl-config --cflags} to get the
path to \code{GSL}'s include directory (\code{-I})
\item Change \code{Makevars} in \code{gsl/src}:
\itemize{
\item Add \code{-L} to \code{PKG_LIBS}
\item Add (new) line: \code{PKG_CPPFLAGS=-I}
}
\item Install \code{gsl} via
\code{LDFLAGS=-L; export LDFLAGS}
\code{CPPFLAGS=-I;export CPPFLAGS}
\code{R CMD INSTALL gsl}
}
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\keyword{array}
gsl/man/Trig.Rd 0000644 0001762 0000144 00000003673 14363633553 013032 0 ustar ligges users \name{Trig}
\alias{Trig}
\alias{trig}
\alias{gsl_sf_sin}
\alias{gsl_sf_cos}
\alias{hypot}
\alias{sinc}
\alias{complex_sin}
\alias{complex_cos}
\alias{complex_logsin}
\alias{lnsinh}
\alias{lncosh}
\title{Trig functions}
\description{
Trig functions as per the Gnu Scientific Library, reference manual
section 7.30. These functions are declared in header file
\code{gsl_sf_trig.h}
}
\usage{
gsl_sf_sin(x, give=FALSE, strict=TRUE)
gsl_sf_cos(x, give=FALSE, strict=TRUE)
hypot(x, y, give=FALSE, strict=TRUE)
sinc(x, give=FALSE, strict=TRUE)
complex_sin(zr, zi=NULL, r.and.i=TRUE, give=FALSE, strict=TRUE)
complex_cos(zr, zi=NULL, r.and.i=TRUE, give=FALSE, strict=TRUE)
lnsinh(x, give=FALSE, strict=TRUE)
lncosh(x, give=FALSE, strict=TRUE)
}
\arguments{
\item{x,y}{input: real values}
\item{zr}{In \code{gamma_complex()}, the real part of the argument}
\item{zi}{In \code{complex_sin()} et seq, the imaginary part of the
argument. If missing (ie takes the default value of \code{NULL}),
interpret \code{zr} as complex, even if real}
\item{r.and.i}{In \code{complex_sin()} et seq, Boolean variable with
default value of \code{TRUE} meaning to return a complex variable as
per the details section below; and \code{FALSE} meaning to return
the values as advertised in the \acronym{GSL} manual}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error}
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
x <- seq(from=0,to=2,by=0.01)
gsl_sf_sin(x) #table xx of Ab and St
gsl_sf_cos(x) #table xx of Ab and St
f <- function(x){abs(sin(x+1)-sin(x)*cos(1)-cos(x)*sin(1))}
g <-
function(x){abs(gsl_sf_sin(x+1)-gsl_sf_sin(x)*gsl_sf_cos(1)-gsl_sf_cos(x)*gsl_sf_sin(1))}
f(100000:100010)
g(100000:100010)
}
\keyword{array}
gsl/man/Gegenbauer.Rd 0000644 0001762 0000144 00000003504 14363633553 014162 0 ustar ligges users \name{Gegenbauer}
\alias{Gegenbauer}
\alias{gegenbauer}
\alias{gegenpoly_1}
\alias{gegenpoly_2}
\alias{gegenpoly_3}
\alias{gegenpoly_n}
\alias{gegenpoly_array}
\title{Gegenbauer functions}
\description{
Gegenbauer functions as per the Gnu Scientific Library reference manual
section 7.20, and AMS-55, chapter 22. These functions are
declared in header file \code{gsl_sf_gegenbauer.h}
}
\usage{
gegenpoly_1(lambda, x, give=FALSE,strict=TRUE)
gegenpoly_2(lambda, x, give=FALSE,strict=TRUE)
gegenpoly_3(lambda, x, give=FALSE,strict=TRUE)
gegenpoly_n(n,lambda, x, give=FALSE,strict=TRUE)
gegenpoly_array(nmax,lambda, x, give=FALSE,strict=TRUE)
}
\arguments{
\item{lambda,x}{input: real values}
\item{n,nmax}{input: integer value}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error}}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
x <- seq(from=-1 ,to=1,len=300)
y <- gegenpoly_array(6,0.5,x)
matplot(x,t(y[-(1:2),]), xlim=c(-1,1.2),ylim=c(-0.5,1.5),
type="l",xaxt="n",yaxt="n",bty="n",xlab="",ylab="",
main="Figure 22.5, p777",col="black")
axis(1,pos=0)
axis(2,pos=0)
plot(x, gegenpoly_n(5,lambda=0.2, x,give=FALSE,strict=TRUE),
xlim=c(-1,1),ylim=c(-1.5,1.5),main="Figure 22.5, p777",
type="n",xaxt="n",yaxt="n",bty="n",xlab="",ylab="")
lines(x, gegenpoly_n(5,lambda=0.2, x,give=FALSE,strict=TRUE))
lines(x, gegenpoly_n(5,lambda=0.4, x,give=FALSE,strict=TRUE))
lines(x, gegenpoly_n(5,lambda=0.6, x,give=FALSE,strict=TRUE))
lines(x, gegenpoly_n(5,lambda=0.8, x,give=FALSE,strict=TRUE))
lines(x, gegenpoly_n(5,lambda=1.0, x,give=FALSE,strict=TRUE))
axis(1,pos=0)
axis(2,pos=0,las=1)
}
\keyword{array}
gsl/man/Gamma.Rd 0000644 0001762 0000144 00000006342 14363633553 013143 0 ustar ligges users \name{Gamma}
\alias{Gamma}
\alias{gamma}
\alias{gsl_sf_gamma}
\alias{lngamma}
\alias{lngamma_sgn}
\alias{gammastar}
\alias{gammainv}
\alias{lngamma_complex}
\alias{taylorcoeff}
\alias{fact}
\alias{doublefact}
\alias{lnfact}
\alias{lndoublefact}
\alias{gsl_sf_choose}
\alias{lnchoose}
\alias{poch}
\alias{lnpoch}
\alias{lnpoch_sgn}
\alias{pochrel}
\alias{gamma_inc_Q}
\alias{gamma_inc_P}
\alias{gamma_inc}
\alias{gsl_sf_beta}
\alias{lnbeta}
\alias{beta_inc}
\title{gamma functions}
\description{
Gamma functions as per the Gnu Scientific Library reference manual
section 7.19. These functions are declared in header file
\code{gsl_sf_gamma.h}
}
\usage{
gsl_sf_gamma(x,give=FALSE,strict=TRUE)
lngamma(x,give=FALSE,strict=TRUE)
lngamma_sgn(x,give=FALSE,strict=TRUE)
gammastar(x,give=FALSE,strict=TRUE)
gammainv(x,give=FALSE,strict=TRUE)
lngamma_complex(zr, zi=NULL, r.and.i=TRUE, give=FALSE, strict=TRUE)
taylorcoeff(n,x,give=FALSE,strict=TRUE)
fact(n,give=FALSE,strict=TRUE)
doublefact(n,give=FALSE,strict=TRUE)
lnfact(n,give=FALSE,strict=TRUE)
lndoublefact(n,give=FALSE,strict=TRUE)
gsl_sf_choose(n,m,give=FALSE,strict=TRUE)
lnchoose(n,m,give=FALSE,strict=TRUE)
poch(a,x,give=FALSE,strict=TRUE)
lnpoch(a,x,give=FALSE,strict=TRUE)
lnpoch_sgn(a,x,give=FALSE,strict=TRUE)
pochrel(a,x,give=FALSE,strict=TRUE)
gamma_inc_Q(a,x,give=FALSE,strict=TRUE)
gamma_inc_P(a,x,give=FALSE,strict=TRUE)
gamma_inc(a,x,give=FALSE,strict=TRUE)
gsl_sf_beta(a,b,give=FALSE,strict=TRUE)
lnbeta(a,b,give=FALSE,strict=TRUE)
beta_inc(a,b,x,give=FALSE,strict=TRUE)
}
\arguments{
\item{x,a,b}{input: real values}
\item{m,n}{input: integer value}
\item{zr}{In \code{gamma_complex()}, the real part of the argument}
\item{zi}{In \code{gamma_complex()}, the imaginary part of the
argument. If missing (ie takes the default value of \code{NULL}),
interpret \code{zr} as complex, even if real}
\item{r.and.i}{In \code{gamma_complex()}, Boolean variable with
default value of \code{TRUE} meaning to return a complex variable as
per the details section below; and \code{FALSE} meaning to return
the values as advertised in the \acronym{GSL} manual}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error}
}
\details{
All functions as documented in the \acronym{GSL} reference manual section 7.19.
Note that \code{gamma_inc_P()} gives the area of the left tail of the
gamma distribution so, for example, \code{gamma_inc_P(1.8, 5) =
pgamma(5, 1.8)} to numerical accuracy.
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
gsl_sf_gamma(3)
lngamma_complex(1+seq(from=0,to=5,by=0.1)*1i) #table 6.7, p 277 (LH col)
#note 2pi phase diff
jj <- expand.grid(1:10,2:5)
x <- taylorcoeff(jj$Var1,jj$Var2)
dim(x) <- c(10,4)
x #table 23.5, p818
jj <- expand.grid(36:50,9:13)
x <- gsl_sf_choose(jj$Var1,jj$Var2)
dim(x) <- c(15,5)
x #table 24.1, p829 (bottom bit)
gamma_inc(1.2,1.3)
beta(1.2, 1.3)
lnbeta(1.2,1.55)
beta_inc(1.2,1.4,1.6)
gamma_inc_P(1.8, 5) - pgamma(5, 1.8) # should be small
}
\keyword{array}
gsl/man/Coulomb.Rd 0000644 0001762 0000144 00000006034 14363633553 013517 0 ustar ligges users \name{Coulomb}
\alias{Coulomb}
\alias{coulomb}
\alias{hydrogenicR_1}
\alias{hydrogenicR}
\alias{coulomb_wave_FG}
\alias{coulomb_wave_F_array}
\alias{coulomb_wave_FG_array}
\alias{coulomb_wave_FGp_array}
\alias{coulomb_wave_sphF_array}
\alias{coulomb_CL}
\alias{coulomb_CL_array}
\title{Coulomb functions}
\description{
Coulomb functions as per the Gnu Scientific Library, reference manual
section 7.7 and AMS-55, chapter 14. These functions are declared
in header file \code{gsl_sf_coulomb.h}
}
\usage{
hydrogenicR_1(Z, r, give=FALSE, strict=TRUE)
hydrogenicR(n, l, Z, r, give=FALSE, strict=TRUE)
coulomb_wave_FG(eta, x, L_F, k, give=FALSE, strict=TRUE)
coulomb_wave_F_array(L_min, kmax, eta, x, give=FALSE,strict=TRUE)
coulomb_wave_FG_array(L_min, kmax, eta, x, give=FALSE,strict=TRUE)
coulomb_wave_FGp_array(L_min, kmax, eta, x, give=FALSE,strict=TRUE)
coulomb_wave_sphF_array(L_min, kmax, eta, x, give=FALSE,strict=TRUE)
coulomb_CL(L,eta, give=FALSE,strict=TRUE)
coulomb_CL_array(L_min, kmax, eta, give=FALSE,strict=TRUE)
}
\arguments{
\item{n,l,kmax}{input: integers}
\item{Z,r,eta,x,L_F,L_min,k,L}{input: real values}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error}
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
x <- seq(from=0,to=14,len=300)
jj <- coulomb_wave_FG(1,10,x,0)
plot(x,jj$val_F,type="l",xaxt="n",yaxt="n",bty="n",xlab="",ylab="",
main="Figure 14.1, p539")
lines(x,jj$val_G,type="l",lty=2)
axis(1,pos=0,at=1:14,
labels=c("","2","","4","","6","","8","","10","","12","","14"))
lines(c(0,1),c(0,0))
axis(2,pos=0)
text(9.5, 0.63, expression(F[L]))
text(8.5, 1.21, expression(G[L]))
x <- seq(from=0,to=24,len=400)
plot(x,coulomb_wave_FG(eta=1,x,L_F=0,k=0)$val_F,type="l",
ylim=c(-1.3,1.7), xlim=c(0,26),
xaxt="n",yaxt="n",bty="n",xlab="",ylab="",main="Figure 14.3, p541",lty=3)
lines(x,coulomb_wave_FG(eta= 0,x,L_F=0,k=0)$val_F,type="l",lty=1)
lines(x,coulomb_wave_FG(eta= 5,x,L_F=0,k=0)$val_F,type="l",lty=6)
lines(x,coulomb_wave_FG(eta=10,x,L_F=0,k=0)$val_F,type="l",lty=6)
lines(x,coulomb_wave_FG(eta=x/2,x,L_F=0,k=0)$val_F,type="l",lty="F3")
axis(1,pos=0,at=1:24,
labels=c("","2","","4","","","","8","","10","","12",
"","14","","","","18","","","","22","","24"))
lines(c(0,26),c(0,0))
axis(2,pos=0,at=0.2*(-6:9),
labels=c("","-1.2","","-.8","","-.4","","0","",".4",
"",".8","","1.2","","1.6"))
text(2.5, -0.8, expression(eta == 0))
text(4.5,1.1,adj=0, expression(eta == 1))
text(14,1.4,adj=0, expression(eta == 5))
text(22,1.4,adj=0, expression(eta == 10))
x <- seq(from=0.5,to=10,by=0.5)
jj <- coulomb_wave_FG(eta=t(matrix(x,20,5)), x=1:5,0,0)
jj.F <- t(jj$val_F)
jj.G <- t(jj$val_G)
colnames(jj.F) <- 1:5
colnames(jj.G) <- 1:5
cbind(x,jj.F) #table 14.1, p 546, top bit.
cbind(x,jj.G) #table 14.1, p 547, top bit.
}
\keyword{array}
gsl/man/Laguerre.Rd 0000644 0001762 0000144 00000002322 14363633553 013661 0 ustar ligges users \name{Laguerre}
\alias{Laguerre}
\alias{laguerre}
\alias{laguerre_1}
\alias{laguerre_2}
\alias{laguerre_3}
\alias{laguerre_n}
\title{Laguerre functions}
\description{
Laguerre functions as per the Gnu Scientific Library reference manual
section 7.22. These functions are declared in header file
\code{gsl_sf_laguerre.h}
}
\usage{
laguerre_1(a, x, give=FALSE, strict=TRUE)
laguerre_2(a, x, give=FALSE, strict=TRUE)
laguerre_3(a, x, give=FALSE, strict=TRUE)
laguerre_n(n, a, x, give=FALSE, strict=TRUE)
}
\arguments{
\item{a,x}{input: real values}
\item{n}{input: integer values}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error}}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
x <- seq(from=0,to=6,len=100)
plot(x,laguerre_n(2,0,x),xlim=c(0,6),ylim=c(-2,3),
type="l",xaxt="n",yaxt="n",bty="n",xlab="",ylab="",
main="Figure 22.9, p780")
lines(x,laguerre_n(3,0,x))
lines(x,laguerre_n(4,0,x))
lines(x,laguerre_n(5,0,x))
axis(1,pos=0)
axis(2,pos=0)
}
\keyword{array}
gsl/man/Fermi-Dirac.Rd 0000644 0001762 0000144 00000002573 14363633553 014205 0 ustar ligges users \name{Fermi-Dirac}
\alias{Fermi_Dirac}
\alias{Fermi}
\alias{fermi_dirac}
\alias{fermi}
\alias{fermi_dirac_m1}
\alias{fermi_dirac_0}
\alias{fermi_dirac_1}
\alias{fermi_dirac_2}
\alias{fermi_dirac_int}
\alias{fermi_dirac_mhalf}
\alias{fermi_dirac_half}
\alias{fermi_dirac_3half}
\alias{fermi_dirac_inc_0}
\title{Fermi-Dirac functions}
\description{
Fermi-Dirac functions as per the Gnu Scientific Library, reference
manual section 7.18. These functions are declared in header file
\code{gsl_sf_fermi_dirac.h}
}
\usage{
fermi_dirac_m1(x, give=FALSE, strict=TRUE)
fermi_dirac_0(x, give=FALSE, strict=TRUE)
fermi_dirac_1(x, give=FALSE, strict=TRUE)
fermi_dirac_2(x, give=FALSE, strict=TRUE)
fermi_dirac_int(j, x, give=FALSE, strict=TRUE)
fermi_dirac_mhalf(x, give=FALSE, strict=TRUE)
fermi_dirac_half(x, give=FALSE, strict=TRUE)
fermi_dirac_3half(x, give=FALSE, strict=TRUE)
fermi_dirac_inc_0(x, b, give=FALSE, strict=TRUE)
}
\arguments{
\item{x,j,b}{input: real values}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error}
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
x <- seq(from=0,to=2,by=0.01)
fermi_dirac_m1(x) #table 7.5 of Ab and St
}
\keyword{array}
gsl/man/Synchrotron.Rd 0000644 0001762 0000144 00000001456 14363633553 014452 0 ustar ligges users \name{Synchrotron}
\alias{Synchrotron}
\alias{synchrotron}
\alias{synchrotron_1}
\alias{synchrotron_2}
\title{Synchrotron functions}
\description{
Synchrotron functions as per the Gnu Scientific Library, reference
section 7.29. These functions are declared in header file
\code{gsl_sf_synchrotron.h}
}
\usage{
synchrotron_1(x, give=FALSE, strict=TRUE)
synchrotron_2(x, give=FALSE, strict=TRUE)
}
\arguments{
\item{x}{input: real values}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error}
}
\author{Robin K. S. Hankin}
\examples{
x <- seq(from=0,to=2,by=0.01)
synchrotron_1(x)
synchrotron_2(x)
}
\keyword{array}
gsl/man/Lambert.Rd 0000644 0001762 0000144 00000001550 14363633553 013503 0 ustar ligges users \name{Lambert}
\alias{Lambert}
\alias{lambert}
\alias{lambert_W0}
\alias{lambert_Wm1}
\alias{Lambert_W0}
\alias{Lambert_Wm1}
\title{Lambert's W function}
\description{
Lambert's W function as per the Gnu Scientific Library reference manual
section 7.23. These functions are declared in header file
\code{gsl_sf_lambert.h}
}
\usage{
lambert_W0(x, give=FALSE, strict=TRUE)
lambert_Wm1(x, give=FALSE,strict=TRUE)
}
\arguments{
\item{x}{input: real values}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error}
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
a <- runif(6)
L <- lambert_W0(a)
print(L*exp(L) - a)
}
\keyword{array}
gsl/man/Error.Rd 0000644 0001762 0000144 00000002426 14363633553 013211 0 ustar ligges users \name{Error}
\alias{error}
\alias{Error}
\alias{Error function}
\alias{erf}
\alias{erfc}
\alias{log_erfc}
\alias{log_erf_Z}
\alias{erf_Q}
\alias{erf_Z}
\alias{hazard}
\title{Error functions}
\description{
Error functions as per the Gnu Scientific Library, reference manual
section 7.15 and AMS-55, chapter 7. Thes functions are declared
in header file \code{gsl_sf_error.h}
}
\usage{
erf(x, mode=0, give=FALSE, strict=TRUE)
erfc(x, mode=0, give=FALSE, strict=TRUE)
log_erfc(x, mode=0, give=FALSE, strict=TRUE)
erf_Q(x, mode=0, give=FALSE, strict=TRUE)
hazard(x, mode=0, give=FALSE, strict=TRUE)
}
\arguments{
\item{x}{input: real values}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number}
\item{mode}{input: mode. For \code{GSL_PREC_DOUBLE} ,
\code{GSL_PREC_SINGLE}, \code{GSL_PREC_APPROX} use \code{0,1,2}
respectively}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error}
}
\details{
The zero functions return a status of \code{GSL_EDOM} and a value of
\code{NA} for \eqn{n\leq 0}{n\leq 0}
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
erf(0.745) # Example 1, page 304
}
\keyword{array}
gsl/man/Transport.Rd 0000644 0001762 0000144 00000001715 14363633553 014114 0 ustar ligges users \name{Transport}
\alias{Transport}
\alias{transport}
\alias{transport_2}
\alias{transport_3}
\alias{transport_4}
\alias{transport_5}
\title{Transport functions}
\description{
Transport functions as per the Gnu Scientific Library, reference manual
section 7.29. These functions are defined in header file
\code{gsl_sf_transport.h}
}
\usage{
transport_2(x, give=FALSE, strict=TRUE)
transport_3(x, give=FALSE, strict=TRUE)
transport_4(x, give=FALSE, strict=TRUE)
transport_5(x, give=FALSE, strict=TRUE)
}
\arguments{
\item{x}{input: real values}
\item{give}{Boolean with \code{TRUE} meaning to return a list of three
items: the value, an estimate of the error, and a status number.}
\item{strict}{Boolean, with \code{TRUE} meaning to return \code{NaN}
if status is an error.}
}
\references{\url{https://www.gnu.org/software/gsl/}}
\author{Robin K. S. Hankin}
\examples{
x <- seq(from=0,to=2,by=0.01)
transport_2(x)
transport_3(x)
}
\keyword{array}
gsl/man/figures/ 0000755 0001762 0000144 00000000000 14363633553 013271 5 ustar ligges users gsl/man/figures/gsl.png 0000644 0001762 0000144 00000045535 14363633553 014600 0 ustar ligges users PNG
IHDR X .' bKGD IDATxyTOU;4tw
"K@11Oy,lfAA%%&fILI'F3IQA\p\@4t7-BSu}Ω~]W_^V}
}}S+ Eh B=:"
$e3 BBtT(
B 8c p UW4uk, 3@@Bh@r Թ1&