"["(x, ...)
"["(x, ...) <- value
"["(x, ...)
acedist.show(X, Y, n, d, timelag)
acedist.noshow(X, Y, n, d)
active.interactions(object)
adaptcoef(new.coef, fitcoef, drop)
adjustthinrange(ur,vstep,vr)
affinexy(X, mat, vec, invert)
affinexypolygon(p, mat, vec, detmat)
ang2rad(ang, unit, start, clockwise)
anycrossing.psp(A,B)
apply23sum(x)
applytolayers(L, FUN, ...)
applyPolyclipArgs(x, p)
Area.xypolygon(polly)
areadelta2(X, r, ..., sparseOK)
areaGain.diri(u, X, r, ..., W, verbose)
areaGain.grid(u, X, r, ..., W, ngrid)
areaLoss.diri(X, r, ..., W, subset)
areaLoss.grid(X, r, ..., W, subset, method = c("count", "distmap"), ngrid = spatstat.options("ngrid.disc"), exact = FALSE)
articlebeforenumber(k)
assemble.plot.objects(xlim, ylim, ..., lines, polygon)
AsymmDistance.psp(X, Y, metric, method)
as.breakpts(...)
"as.character"(x, ...)
"as.data.frame"(x, ...)
"as.data.frame"(x, ...)
"as.double"(x, ...)
"as.list"(x, ...)
as.listof(x)
"as.owin"(W, ...)
as.units(s)
as2vector(x)
asNumericMatrix(x)
assignDFcolumn(x, name, value, ...)
augment.msr(x, ..., sigma)
BartCalc(fY, fK)
badprobability(x, NAvalue)
bbEngine(...)
bermantestEngine(model, covariate, which, alternative, ..., modelname, covname, dataname)
bdrylength.xypolygon(polly)
bdry.mask(W)
bind.ratfv(x, numerator, denominator, labl, desc, preferred, ratio)
blankcoefnames(x)
blockdiagmatrix(...)
blockdiagarray(...)
bounding.box3(...)
break.holes(x, splitby, depth, maxdepth)
breakpts(val, maxi, even = FALSE, npos = NULL, step = NULL)
breakpts.from.r(r)
bt.frame(Q, trend, interaction, ..., covariates, correction, rbord, use.gam, allcovar)
bw.optim(cv, h, iopt, ..., cvname, hname, criterion)
calc.DR(COV, z, Dim)
calc.NNIR(COV, z, pos, Dim)
calc.SAVE(COV, z, Dim)
calc.SIR(COV, z)
calc.TSE(COV, z, pos, Dim1, Dim2)
can.be.formula(x)
cannot.update(...)
cartesian(pp, markset, fac = TRUE)
cat.factor(..., recursive=FALSE)
cellmiddles(W, nx, ny, npix, distances)
censtimeCDFest(o, cc, d, breaks, ..., KM, RS, HAN, RAW, han.denom, tt, pmax)
change.default.expand(x, newdefault)
checkbigmatrix(n, m, fatal, silent)
checkfields(X,L)
checksolve(M, action, descrip, target)
check.finespacing(r, eps, win, rmaxdefault, context, action, rname)
check.finite(x, context, xname, fatal, usergiven)
check.hist.lengths(hist,breaks)
check.in.range(x, r, fatal)
check.mat.mul(A, B, Acols, Brows, fatal)
check.named.list(x, nam, context, namopt, onError)
check.named.vector(x, nam, context, namopt, onError)
check.named.thing(x, nam, namopt, xtitle, valid, type, context, fatal)
check.nvector(v, npoints, fatal, things, naok, warn, vname, oneok)
check.nmatrix(m, npoints, fatal, things, naok, squarematrix, matchto, warn)
check.1.integer(x, context, fatal)
check.1.real(x, context, fatal)
check.1.string(x, context, fatal)
check.range(x, fatal)
check.testfun(f, f1, X)
choptext(..., prefix, indent)
choptextline(st, w, prefix, indent)
circticks(R, at, unit, start, clockwise, labels)
clarkevansCalc(X, correction, clipregion, working)
clip.psp(x, window, check=TRUE)
cliprect.psp(x, window)
clippoly.psp(s, window)
closethresh(X,R,S,twice,...)
"coef"(object, ...)
"coef"(object, ...)
"coef"(object, ...)
coerce.marks.numeric(X, warn)
"compatible"(A, B, ...)
complaining(whinge, fatal, value)
compileCDF(D, B, r, ..., han.denom, check)
conform.ratfv(x)
crosspairquad(Q,rmax,what)
cobble.xy(x, y, f, fatal, ...)
codetime(x, hms, what)
col.args.to.grey(x, ...)
colouroutputs(x)
colouroutputs(x) <- value
commasep(x, join, flatten)
commonPolyclipArgs(..., p)
conform.imagelist(X, Zlist)
countingweights(id, areas, check = TRUE)
CressieReadStatistic(OBS,EXP,lambda)
CressieReadSymbol(lambda)
CressieReadName(lambda)
damaged.ppm(object)
data.mppm(x)
datagen.runifpointOnLines(n, L)
datagen.runifpoisppOnLines(lambda, L)
datagen.rpoisppOnLines(lambda, L, lmax, ..., check)
default.clipwindow(object, epsilon)
default.linnet.tolerance(L)
default.n.tiling(X, nd, ntile, npix, eps, random, quasi, verbose)
default.ntile(X)
deltasuffstat(model, ..., restrict, dataonly, force, quadsub, sparseOK)
Deviation(x, ref, leaveout, n, xi)
dflt.redraw(button, name, env)
densitycrossEngine(Xdata, Xquery, sigma, ..., weights, edge, varcov, diggle, sorted)
densitypointsEngine(x, sigma, ..., kernel, scalekernel, weights, edge, varcov, leaveoneout, diggle, sorted, spill, cutoff)
diagnose.ppm.engine(object, ..., type, typename, opt, sigma, rbord, compute.sd, compute.cts, envelope, nsim, nrank, rv, oldstyle, splineargs, verbose)
diagramobj(X, ...)
digital.volume(range, nval, vside)
dilate.owin(...)
"dim"(x)
"dim"(x)
"dim"(x)
"dim"(x)
"dim"(x)
"dimnames"(x)
"dimnames"(x) <- value
"dimnames"(x)
distpl(p, l)
distppl(p, l)
distppll(p, l, mintype, method, listit)
distppllmin(p, l, big)
distributecbind(x)
dist2dpath(dist, method="C")
divisors(n)
do.as.im(x, action, ..., W, eps, dimyx, xy, na.replace)
do.call.matched(fun, arglist, funargs, extrargs, matchfirst, sieve, skipargs)
do.call.plotfun(fun, arglist, ...)
do.call.without(fun, ..., avoid)
do.istat(panel)
doMultiStraussHard(iradii, hradii, types)
dont.complain.about(...)
dotexpr.to.call(expr, dot, evaluator)
dppmFixIntensity(DPP, lambda, po)
dppmFixAlgorithm(algorithm, changealgorithm, clusters, startpar)
dropifsingle(x)
dround(x)
emptywindow(w)
ensure2vector(x)
ensure3Darray(x)
envelopeEngine(X, fun, simul, nsim, nrank, ..., funargs, funYargs, verbose, clipdata, transform, global, ginterval, use.theory, alternative, scale, clamp, savefuns, savepatterns, saveresultof, weights, nsim2, VARIANCE, nSD, Yname, maxnerr, internal, cl, envir.user, expected.arg, do.pwrong, foreignclass, collectrubbish)
envelopeProgressData(X, fun, ..., exponent, alternative, leaveout, scale, clamp, normalize, deflate, rmin, save.envelope, savefuns, savepatterns)
envelopeTest(X, ..., exponent, alternative, rinterval, leaveout, scale, clamp, tie.rule, interpolate, save.interpolant, save.envelope, savefuns, savepatterns, Xname, verbose)
"envelope"(Y, ..., Yname)
"envelope"(Y, ..., rvals, observed, theory, funX, nsim, nsim2, jsim, jsim.mean, type, alternative, scale, clamp, csr, use.theory, nrank, ginterval, nSD, savefuns, check, Yname, do.pwrong, weights, precomputed)
equalpairs(U, X, marked=FALSE)
equalpairs.quad(Q)
equals.quad(Q)
equalsfun.quad(Q)
equispaced(z, reltol)
eratosthenes(nmax, startset)
erodemask(w,r,strict)
erode.owin(...)
evalCovar(model, covariate, ...)
"evalCovar"(model, covariate, ..., lambdatype, dimyx, eps, jitter, modelname, covname, dataname)
"evalCovar"(model, covariate, ..., lambdatype, eps, nd, jitter, modelname, covname, dataname)
evalCovariate(covariate, locations)
evalInteraction(X,P,E,interaction,correction,...,precomputed,savecomputed)
evalInterEngine(X,P,E,interaction,correction,..., Reach,precomputed,savecomputed)
evalPairPotential(X,P,E,pairpot,potpars,R)
evaluate2Dkernel(kernel, x, y, sigma, varcov, ..., scalekernel)
even.breaks.owin(w)
evenly.spaced(x, tol)
exactdt(X, ...)
exactPdt(w)
exhibitStringList(prefix, strings)
existsSpatstatVariable(name)
expand.polynom(f)
expandSpecialLists(x, special)
expandwinPerfect(W, expand, amount)
explain.ifnot(expr, context)
"extractAIC"(fit, scale = 0, k = 2, ...)
extractAtomicQtests(x)
fakecallstring(fname, parlist)
fakemaintitle(bb, main, ...)
"family"(object, ...)
fave.order(x)
f3engine(x, y, z, box, vside, range, nval, correction)
f3Cengine(x, y, z, box, vside, rmax, nrval)
fasp(fns, which, formulae, dataname, title, rowNames, colNames, checkfv)
fastFindInterval(x, b, labels, reltol)
fill.coefs(coefs, required)
fillseq(x, step)
findbestlegendpos(...)
findCovariate(covname, scope, scopename=NULL)
findcbind(root, depth, maxdepth)
findfirstfactor(x)
firstfactor(x)
fii(interaction, coefs, Vnames, IsOffset)
fillNA(x, value)
flat.deparse(x)
flatfname(x)
flipxypolygon(p)
fontify(x, font)
forbidNA(x, context, xname, fatal, usergiven)
forbid.logi(object)
"format"(x, ..., collapse, modifier)
FormatFaspFormulae(f, argname)
framebottomleft(w)
fvexprmap(x)
fvlabels(x, expand=FALSE)
fvlabels(x) <- value
fvlabelmap(x, dot=TRUE)
fvlegend(object, elang)
g3engine(x, y, z, box, rmax, nrval, correction)
g3Cengine(x, y, z, box, rmax, nrval)
geomseq(from, to, length.out)
greatest.common.divisor(n,m)
getdataname(defaultvalue, ..., dataname)
getdataobjects(nama, envir, datalist, fatal)
getfields(X, L, fatal = TRUE)
getglmdata(object, drop=FALSE)
getglmfit(object)
getglmsubset(object)
getlambda.lpp(lambda, X, ..., update)
getlastshift(X)
getppmdatasubset(object)
getppmOriginalCovariates(object)
getRandomFieldsModelGen(model)
getSpatstatVariable(name)
getSumFun(abbreviation, classname, ismarked, fatal)
geyercounts(U,X,r,sat,Xcounts,EqualPairs)
geyerdelta2(X,r,sat,...,sparseOK)
GLMpredict(fit, data, coefs, changecoef, type)
good.names(nama, defaults, suffices)
good.correction.K(X)
graphicsPars(key)
gridindex(x, y, xrange, yrange, nx, ny)
grid1index(x, xrange, nx)
grokIndexVector(ind, len, nama)
grow.mask(M, xmargin=0, ymargin=xmargin)
gsubdot(replacement, x)
hackglmmPQL(fixed, random, family, data, correlation, weights, control, niter, verbose, subset, ..., reltol)
hasenvelope(X, E)
HermiteCoefs(order)
handle.r.b.args(r = NULL, breaks = NULL, window, pixeps = NULL, rmaxdefault)
handle.rshift.args(W, ..., radius, width, height, edge, clip,
edgedefault)
"head"(x,n,...)
hierarchicalordering(i, s)
hiermat(x, h)
ho.engine(model, ..., nsim, nrmh, start, control, verb)
hsvNA(h, s, v, alpha)
IdenticalRows(i,j,a,b)
identical.formulae(x,y)
idorempty(w, r, caller)
ifelseAB(test, a, b)
ifelseAX(test, a, x)
ifelseXB(test, x, b)
ifelseXY(test, x, y)
ifelse1NA(test)
ifelse0NA(test)
ifelseNegPos(test, x)
illegal.iformula(ifmla, itags, dfvarnames)
implemented.for.K(correction, windowtype, explicit)
impliedpresence(tags, formula, df, extranames=character(0))
impliedcoefficients(object, tag)
indexCartesian(nn)
inject.expr(base, expr)
inpoint(W)
insertinlist(x, i, y)
inside.range(x, r)
inside.triangle(x, y, xx, yy)
inside.xypolygon(pts, polly, test01, method)
instantiate.interact(x, par)
interactionfamilyname(x)
intermaker(f, blank)
intersect.ranges(a,b,fatal)
intX.owin(w)
intX.xypolygon(polly)
intY.owin(w)
intY.xypolygon(polly)
invokeColourmapRule(colfun, x, ..., zlim, colargs)
is.atomicQtest(x)
is.blank(s)
is.cadlag(s)
is.col.argname(x)
is.data(Q)
is.expandable(x)
"is.expandable"(x)
"is.expandable"(x)
is.fv(x)
is.hole.xypolygon(polly)
is.hyperframe(x)
is.infline(x)
is.interact(x)
"is.marked"(...)
"is.marked"(X, ...)
"is.marked"(X, ...)
"is.marked"(X, na.action="warn", ...)
is.mppm(x)
"is.multitype"(X, ...)
"is.multitype"(X, ...)
"is.multitype"(X, na.action="warn", ...)
is.parseable(x)
"is.poisson"(x)
is.pp3(x)
is.ppx(x)
is.prime(n)
is.psp(x)
is.sob(x)
is.tess(x)
k3engine(x, y, z, box, rmax, nrval, correction)
Kborder.engine(X, rmax, nr, correction, weights, ratio)
Knone.engine(X, rmax, nr, weights, ratio)
Krect.engine(X, rmax, nr, correction, weights, ratio, fname)
Kount(dIJ, bI, b, breaks)
Kwtsum(dIJ, bI, wIJ, b, w, breaks)
Kpcf.kppm(model, what)
killinteraction(model)
km.rs.opt(o, cc, d, breaks, KM, RS)
kppmComLik(X, Xname, po, clusters, control, weightfun, rmax, algorithm, DPP, ...)
kppmMinCon(X, Xname, po, clusters, control, statistic, statargs, algorithm, DPP, ...)
kppmPalmLik(X, Xname, po, clusters, control, weightfun, rmax, algorithm, DPP, ...)
kraever(package, fatal)
kraeverRandomFields()
"labels"(object, ...)
least.common.multiple(n,m)
"levels"(x)
"levels"(x) <- value
levelsAsFactor(x)
lhs.of.formula(x)
linearKengine(X, ..., r, reweight, denom, correction, showworking)
linearKmulti(X, I, J, r, ..., correction)
linearKmulti.inhom(X, I, J, lambdaI, lambdaJ, r, ..., correction, normalise)
linearpcfengine(X, ..., r, reweight, denom, correction)
linearpcfmulti(X, I, J, r, ..., correction)
linearpcfmulti.inhom(X, I, J, lambdaI, lambdaJ, r, ..., correction, normalise)
linearKmultiEngine(X, I, J, ..., r, reweight, denom, correction, showworking)
linearPCFmultiEngine(X, I, J, ..., r, reweight, denom, correction, showworking)
listof(...)
localKengine(X, ..., wantL, lambda, correction, verbose, rvalue)
localpcfengine(X, ..., delta, rmax, nr, stoyan, lambda)
localpcfmatrix(X, i, ..., lambda, delta, rmax, nr, stoyan)
local2lpp(L, seg, tp, X, df.only)
logicalIndex(i, nama, len)
logi.dummy(X, dummytype, nd, mark.repeat, ...)
logi.engine(Q, trend, interaction, ..., covariates, subsetexpr, correction, rbord, covfunargs, allcovar, vnamebase, vnameprefix, justQ, savecomputed, precomputed, VB)
"logLik"(object, ...)
lty2char(i)
makeLinnetTolerance
maskLaslett(X, ..., eps, dimyx, xy, oldX, verbose, plotit)
matchNameOrPosition(expected, avail)
match2DkernelName(kernel)
padtowidth(a, b, justify)
parbreak(terse)
passthrough(.Fun, ..., .Fname)
paste.expr(x)
pasteN(...)
plan.legend.layout(B, ..., side, sep, size, sep.frac, size.frac, started, map)
PoisSaddle(beta, fi)
PoisSaddleArea(beta, fi)
PoisSaddleGeyer(beta, fi)
PoisSaddlePairwise(beta, fi)
polyLaslett(X, ..., oldX, verbose, plotit)
polytileareaEngine(P, xrange, yrange, nx, ny)
positiveIndex(i, nama, len)
prettyinside(x, ...)
prettydiscrete(x, n)
"print"(x, ...)
"plot"(x, ...)
putSpatstatVariable(name, value)
"["(x, i, ...)
"["(x, i, drop, ...)
lookup.im(Z, x, y, naok, strict)
lookup2DkernelInfo(kernel)
majorminorversion(v)
make.even.breaks(bmax, npos, bstep)
makefvlabel(op, accent, fname, sub, argname)
make.parseable(x)
makeunits(sing, plur, mul)
mapstrings(x, map)
markappend(...)
markcbind(...)
markformat(x)
"markformat"(x)
"markformat"(x)
"markformat"(x)
"markformat"(x)
mark.scale.default(marx, w, markscale, maxsize, meansize, characters)
markspace.integral(X)
"marks"(x, ...)
"marks"(x, dfok=FALSE, ...)
markappendop(x, y)
x %mapp% y
marksubset(x, index, format)
marksubsetop(x, i)
x %msub% i
markreplicateop(x, n)
x %mrep% n
mask2df(w)
match.kernel(kernel)
matcolall(x)
matcolany(x)
matcolsum(x)
matrixsample(mat, newdim, phase, scale, na.value)
matrowall(x)
matrowany(x)
matrowsum(x)
maxflow(costm)
mctestSigtraceEngine(R, devdata, devsim, ..., interpolate, confint, alpha, exponent, unitname)
meanlistfv(z, ...)
meanX.owin(w)
meanY.owin(w)
model.se.image(fit, W, ..., what)
modelFrameGam(formula, ...)
mpl.engine(Q, trend, interaction, ..., covariates, subsetexpr, covfunargs, correction,
rbord, use.gam, gcontrol, GLM, GLMfamily, GLMcontrol, famille, forcefit, nd, eps, allcovar, callstring, precomputed, savecomputed, preponly, rename.intercept, justQ, weightfactor)
mpl.get.covariates(covariates, locations, type, covfunargs, need.deriv)
mpl.prepare(Q, X, P, trend, interaction, covariates, want.trend, want.inter, correction, rbord, Pname, callstring, ..., subsetexpr, covfunargs, allcovar, precomputed, savecomputed, vnamebase, vnameprefix, warn.illegal, warn.unidentifiable, weightfactor, skip.border)
mpl.usable(x)
MultiPair.checkmatrix(mat, n, matname, naok, zerook, asymmok)
multiplicityNumeric(x)
multiply.only.finite.entries(x, a)
na.handle.im(X, na.replace)
"names"(x) <- value
"names"(x)
"names"(x) <- value
natozero(x)
nearest.pixel(x, y, im)
nearest.valid.pixel(x, y, im)
newformula(old, change, eold, enew)
newstyle.coeff.handling(object)
niceround(x, m)
nncleanEngine(kthNND, k, d, ..., tol, maxit, plothist, lineargs, verbose, Xname)
nndcumfun(X, ..., r)
no.trend.ppm(x)
n.quad(Q)
numalign(i, nmax, zero)
numberwithunit(x, u)
numeric.columns(M, logical, others)
nzpaste(..., sep, collapse)
objsurfEngine(objfun, optpar, objargs, ..., dotargs, objname, ngrid, ratio, verbose)
offsetsinformula(x)
onecolumn(m)
optimStatus(x, call)
printStatus(x, errors.only)
signalStatus(x, errors.only)
orderstats(x, k, decreasing)
orderwhich(x, k, decreasing)
ordinal(k)
ordinalsuffix(k)
a %orifnull% b
outdated.interact(object)
overlap.trapezium(xa, ya, xb, yb, verb = FALSE)
overlap.xypolygon(P, Q)
oversize.quad(Q, ..., nU, nX, p)
owinpolycheck(W, verbose=TRUE)
owinpoly2mask(w, rasta, check=TRUE)
owin2polypath(w)
"pairs"(..., plot=TRUE)
"pairs"(..., plot=TRUE)
param.quad(Q)
paren(x, type)
partialModelMatrix(X,D,model,callstring,...)
pasteFormula(f)
pcf3engine(x, y, z, box, rmax, nrval, correction, delta)
pcfmulti.inhom(X, I, J, lambdaI = NULL, lambdaJ = NULL, ..., r = NULL, breaks = NULL, kernel = "epanechnikov", bw = NULL, stoyan = 0.15, correction = c("translate", "Ripley"), sigma = NULL, varcov = NULL, Iname = "points satisfying condition I", Jname = "points satisfying condition J")
pickoption(what="option", key, keymap, ..., exact=FALSE, list.on.err=TRUE, die=TRUE, multi=FALSE, allow.all=TRUE)
plotEachLayer(x, ..., main, plotargs, add, show.all, do.plot)
ploterodewin(W1, W2, col.edge, col.inside, do.plot, ...)
ploterodeimage(W, Z, ..., Wcol, rangeZ, colsZ, do.plot)
plot3Dpoints(xyz, eye, org, ..., type, xlim, ylim, zlim, add, box, main, cex, box.back, box.front)
plotPolygonBdry(x, ...)
"plot"(x, ..., do.points=FALSE)
"plot"(x, ...)
"plot"(x, ...)
"plot"(x, ..., showopt, optargs)
"plot"(x, ..., shade)
"plot"(x, ...)
"plot"(x, ...)
"plot"(x, addmatch = NULL, main = NULL, ...)
"plot"(x, ...)
"plot"(x, ..., add, main, tag, coeff, xvariable, col, lty, lwd, col.opt, lty.opt, lwd.opt)
"plot"(x, ..., limits=TRUE, monochrome=spatstat.options('monochrome'), limcol=if(monochrome) "black" else "red")
"plot"(x, ..., xlab, ylab)
"plot"(x, fmla, ..., lty = NULL, col = NULL, lwd = NULL, lty.theo = NULL, col.theo = NULL, lwd.theo = NULL, lwd.mean = if (meanonly) 1 else NULL, lty.mean = lty, col.mean = col, separately = FALSE, meanonly = FALSE, main = if (meanonly) "group means" else NULL, xlim = NULL, ylim = NULL, ylab = NULL, legend = !add, legendpos = "topleft", lbox = FALSE, add = FALSE)
polynom(x, ...)
ppllengine(X, Y, action="project", check=FALSE)
"ppm"(Q, trend, interaction, ..., covariates, data, covfunargs, subset, correction, rbord, use.gam, method, forcefit, emend, project, prior.mean, prior.var, nd, eps, gcontrol, nsim, nrmh, start, control, verb, callstring)
ppmCovariates(model)
ppmDerivatives(fit, what, Dcovfun, loc, covfunargs)
ppmInfluenceEngine(fit, what, ..., iScore, iHessian, iArgs, drop, method, precomputed, sparseOK, fitname, multitypeOK)
pppdist.mat(X, Y, cutoff = 1, q = 1, matching = TRUE, precision = 9, approximation = 10)
pppdist.prohorov(X, Y, n, dfix, type, cutoff, matching, ccode, auction, precision, approximation)
ppsubset(X, I, Iname, fatal)
prange(x)
"predict"(object, newdata, type, se.fit, dispersion, terms, na.action, ...)
prefixfv(x, tagprefix, descprefix, lablprefix, whichtags)
prepareTitle(main)
primefactors(n, prmax)
primesbelow(nmax)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, digits, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ..., tight)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ..., family, brief, banner)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ..., prefix=TRUE)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ..., dp=3)
"print"(x, ...)
"print"(x, ..., brief)
"print"(x, ...)
"print"(x, ..., dp)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
"print"(x, ..., brief=FALSE)
"print"(x, ...)
"print"(x, ...)
"print"(x, ...)
project3Dhom(xyz, eye, org, vert)
prolongseq(x, newrange, step)
putlastshift(X, vec)
quad(data, dummy, w, param)
quad.mppm(x)
quadBlockSizes(nX, nD, p, nMAX, announce)
RandomFieldsSafe()
ratfv(df, numer, denom, ..., ratio)
ratiotweak(a, b, overzero, zerozero)
recognise.spatstat.type(x)
rectquadrat.breaks(xr, yr, nx = 5, ny = nx, xbreaks = NULL, ybreaks = NULL)
rectquadrat.countEngine(x, y, xbreaks, ybreaks, weights)
reduceformula(fmla, deletevar, verbose)
reheat(model, invtemp)
relatively.prime(n, m)
RelevantDeviation(x, alternative, clamp, scaling)
repair.image.xycoords(x)
replacementIndex(ii, stuff)
resolveEinfo(x, what, fallback, warn, atomic)
resolve.vargamma.shape(..., nu.ker, nu.pcf, default = FALSE)
rgbNA(red, green, blue, alpha, maxColorValue)
rhs.of.formula(x, tilde)
rhohatEngine(model, covariate, reference, volume, ..., weights, method, horvitz, smoother, resolution, n, bw, adjust, from, to, bwref, covname, covunits, confidence, modelcall, callstring)
rhohatCalc(ZX, Zvalues, lambda, denom, ..., weights, lambdaX, method, horvitz, smoother, n, bw, adjust, from, to, bwref, covname, confidence, covunits, modelcall, callstring, savestuff)
rMaternInhibition(type, kappa, r, win, stationary, ..., nsim, drop)
RmhExpandRule(nama)
rocData(covariate, nullmodel, ..., high)
rocModel(lambda, nullmodel, ..., high)
romansort(x)
rmhsnoop(..., Wsim, Wclip, R, xcoords, ycoords, mlevels, mcodes, irep, itype, proptype, proplocn, propmark, propindx, numerator, denominator)
roseContinuous(ang, rad, unit, ..., start, clockwise, main, labels, at, do.plot)
ruletextline(ch, n, terse)
quadrat.testEngine(X, nx, ny, alternative, method, conditional, CR, ..., nsim, Xcount, xbreaks, ybreaks, tess, fit, Xname, fitname)
quadscheme.replicated(data, dummy, method, ...)
quadscheme.spatial(data, dummy, method, ...)
pointgrid(W, ngrid)
rastersample(X, Y)
rasterx.mask(w, drop)
rastery.mask(w, drop)
rasterxy.mask(w, drop)
rasterx.im(x)
rastery.im(x)
rasterxy.im(x, drop)
rebadge.fv(x, new.ylab, new.fname, tags, new.desc, new.labl, new.yexp, new.dotnames, new.preferred, new.formula, new.tags)
rebadge.as.crossfun(x, main, sub, i, j)
rebadge.as.dotfun(x, main, sub, i)
rebound(x, rect)
"rebound"(x, rect)
"rebound"(x, rect)
"rebound"(x, rect)
"rebound"(x, rect)
reconcile.fv(...)
repair.old.factor.image(x)
reincarnate.interact(object)
resid4plot(RES, plot.neg, plot.smooth, spacing, outer, srange, monochrome, main, xlab, ylab, rlab, col.neg, col.smooth, ...)
resid1plot(RES, opt, plot.neg, plot.smooth, srange, monochrome, main, add, show.all, do.plot, col.neg, col.smooth, ...)
resid1panel(observedX, observedV, theoreticalX, theoreticalV, theoreticalSD, xlab,ylab, ..., do.plot)
resolve.defaults(..., .MatchNull=TRUE, .StripNull=FALSE)
resolve.1.default(.A, ...)
resolve.2D.kernel(..., sigma, varcov, x, mindist, adjust, bwfun, allow.zero)
restrict.mask(M, W)
reverse.xypolygon(p, adjust=FALSE)
reversePolyclipArgs(x, p)
revcumsum(x)
rmax.Rigid(X, g)
rmax.rule(fun, W, lambda)
rotxy(X, angle = pi/2)
rotxypolygon(p, angle = pi/2)
rmhResolveControl(control, model)
rmhResolveExpansion(win, control, imagelist, itype)
rmhResolveTypes(model, start, control)
rmhSnoopEnv(Xinit, Wclip, R)
"rmhcontrol"(...)
"rmhcontrol"(...)
rmhEngine(InfoList, ..., verbose, kitchensink, preponly, snoop, overrideXstart, overrideclip)
"rmhmodel"(model, ...)
"rmhstart"(start, ...)
"rmhstart"(start, ...)
rmpoint.I.allim(n, f, types)
"row.names"(x)
"row.names"(x) <- value
rpoint.multi(n, f, fmax, marks, win, giveup, verbose, warn, nsim, drop)
runifpoispp(lambda, win, ..., nsim, drop)
runifpoisppOnLines(lambda, L, nsim)
runifrect(n, win, nsim, drop)
safedeldir(X)
safelookup(Z, x, factor, warn)
samefunction(f, g)
"scalardilate"(X, f, ...)
"scalardilate"(X, f, ...)
"scalardilate"(X, f, ...)
scanmeasure(X, ...)
"scanmeasure"(X, r, ..., method)
"scanmeasure"(X, r, ...)
scanPoisLRTS(nZ, nG, muZ, muG, alternative)
scanBinomLRTS(nZ, nG, muZ, muG, alternative)
second.moment.calc(x, sigma, edge, what, ..., varcov=NULL, expand=FALSE, debug=FALSE)
second.moment.engine(x, sigma, edge, what, ..., kernel, obswin, varcov, npts, debug)
sensiblevarname(guess, fallback, maxlen)
sewpcf(d, w, denargs, lambda2area, divisor)
sewsmod(d, ff, wt, Ef, rvals, method="smrep", ..., nwtsteps=500)
"shift"(X, ...)
"shift"(X, ...)
"shift"(X, ...)
"shift"(X, ...)
"shift"(X, ...)
"shift"(X, ...)
shiftxy(X, vec = c(0, 0))
shiftxypolygon(p, vec = c(0, 0))
short.deparse(x, maxlen)
simplenumber(x, unit, multiply, tol)
simplify.xypolygon(p, dmin)
"simulate"(object, ...)
simulrecipe(type, expr, envir, csr, pois, constraints)
singlestring(s, coll)
slr.prepare(CallInfo, envir, data, dataAtPoints, splitby, clip)
slrAssemblePixelData(Y, Yname, W, covimages, dataAtPoints, pixelarea)
"Smooth"(X, ...)
smoothcrossEngine(Xdata, Xquery, values, sigma, ..., weights, varcov, sorted)
smoothpointsEngine(x, values, sigma, ..., weights, varcov, leaveoneout, sorted, cutoff)
"sort"(x, ...)
sortalongsegment(df)
spatstat.rawdata.location(...)
spatstat.xy.coords(x, y)
spatstatClusterModelInfo(name, onlyPCP)
spatstatDPPModelInfo(model)
spatstatLocator(n, type, ...)
spatstatRmhInfo(cifname)
spatialCDFframe(model, covariate, ...)
spatialCDFtest(model, covariate, test, ..., dimyx, eps, jitter, nsim, verbose, modelname, covname, dataname)
sphere.volume(range, nval = 10)
splitHybridInteraction(coeffs, inte)
sp.foundclass(cname, inlist, formalname, argsgiven)
sp.foundclasses(cnames, inlist, formalname, argsgiven)
startinrange(x0, dx, r)
store.versionstring.spatstat()
"str"(object, ...)
strausscounts(U,X,r,EqualPairs)
strsplitretain(x, split)
substringcount(x,y)
suffloc(object)
suffstat.generic(model, X, callstring)
suffstat.poisson(model, X, callstring)
summarise.trend(trend, w, a)
"summary"(object,...)
"summary"(object,...)
"summary"(object, ..., brief=FALSE)
"summary"(object, ..., checkdup=FALSE)
"summary"(object, ...)
"summary"(object, ..., brief=FALSE)
"summary"(object, ...)
"summary"(object, ...)
"summary"(object, ...)
"summary"(object, ...)
"summary"(object, ...)
"summary"(object, ...)
sumsymouter(x, w)
superimposeMarks(arglist, nobj)
symbolmaptype(x)
sympoly(x, y, n)
"tail"(x,n,...)
tensor1x1(A,B)
termsinformula(x)
test.crossing.psp(A,B)
test.selfcrossing.psp(A)
there.is.no.try(...)
thinjump(n, p)
tilecentroids(W, nx, ny)
trap.extra.arguments(..., .Context, .Fatal)
trianglediameters(iedge, jedge, edgelength, ..., nvert, dmax, check)
trim.mask(M, R, tolerant)
truncline(x, nc)
tapplysum(x, flist, do.names, na.rm)
tweak.fv.entry(x, current.tag, new.labl, new.desc, new.tag)
tweak.coefs(model, new.coef)
x %unit% u
"unitname"(x)
"unitname"(x) <- value
unparen(x)
"unstack"(x, ...)
"unstack"(x, ...)
unstackFilter(x)
"update"(object, ...)
"update"(object, ..., envir)
"update"(object, ...)
uptrimat(x)
validradius(r, caller)
validate2Dkernel(kernel, fatal)
validate.angles(angles, unit, guess)
validate.lpp.coords(X, fatal, context)
validate.mask(w, fatal=TRUE)
validate.quad(Q, fatal, repair, announce)
validposint(n, caller, fatal)
vanilla.fv(x)
varcountEngine(g, B, lambdaB, f)
variablesinformula(x)
variablesintext(x)
verbalogic(x, op)
versionstring.interact(object)
versionstring.ppm(object)
versionstring.spatstat()
verifyclass(X, C, N = deparse(substitute(X)), fatal = TRUE)
verify.xypolygon(p, fatal=TRUE)
"Window"(X, ...)
"Window"(X, ..., check=TRUE) <- value
"Window"(X, ..., check=TRUE) <- value
warn.ignored.args(..., context)
warn.once(key, ...)
waxlyrical(type, terse)
windows.mppm(x)
w.quad(Q)
x.quad(Q)
y.quad(Q)
xy.grid(xr, yr, nx, ny, dx, dy)
X2testEngine(OBS, EXP, ..., method, CR, df, nsim, conditional, alternative, testname, dataname)
"xtfrm"(x)
xypolyselfint(p, eps, proper, yesorno, checkinternal)
xypolygon2psp(p, w, check)
sparse3Darray(i,j,k,x,dims,dimnames,strict,nonzero)
as.sparse3Darray(x, ...)
"dim"(x)
"dim"(x) <- value
"dimnames"(x)
"dimnames"(x) <- value
"print"(x, ...)
"aperm"(a, perm, resize, ...)
"as.array"(x, ...)
"["(x, i, j, k, drop, ...)
"["(x, i, j, k, ...) <- value
"anyNA"(x, recursive)
RelevantZero(x)
RelevantEmpty(x)
isRelevantZero(x)
unionOfSparseIndices(A,B)
Math(x, ...)
Ops(e1, e2)
Summary(..., na.rm = FALSE)
inside3Darray(d, i, j, k)
SparseEntries(x)
EntriesToSparse(df, dims)
mapSparseEntries(x, margin, values, conform, across)
applySparseEntries(x, f, ...)
sumsymouterSparse(x, w, dbg)
tenseur(A, B, alongA, alongB)
marginSums(X, MARGIN)
rbindCompatibleDataFrames(x)
bind.sparse3Darray(A, B, along)
exceedsMaxArraySize(...)
spatstatDiagnostic(msg)