https://github.com/cran/RandomFields
Revision 84ac7774b2385ab164ebf06b957ce2e61978c2e3 authored by Martin Schlather on 02 February 2015, 00:00:00 UTC, committed by Gabor Csardi on 02 February 2015, 00:00:00 UTC
1 parent bc905e7
Tip revision: 84ac7774b2385ab164ebf06b957ce2e61978c2e3 authored by Martin Schlather on 02 February 2015, 00:00:00 UTC
version 3.0.62
version 3.0.62
Tip revision: 84ac777
RMmodels.R
## This file has been created automatically by 'rfGenerateModels'.
RMtrend <- function(mean, plane, polydeg, polycoeff, arbitraryfct, fctcoeff) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('mean') && !is.null(subst <- substitute(mean))) {
u <- try(is.numeric(mean) || is.logical(mean) || is.language(mean)
|| is.list(mean) || is(mean, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mean']] <- mean
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mean']] <- mean
else stop('random parameter not allowed')
}
if (hasArg('plane') && !is.null(subst <- substitute(plane))) {
u <- try(is.numeric(plane) || is.logical(plane) || is.language(plane)
|| is.list(plane) || is(plane, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['plane']] <- plane
else if (substr(deparse(subst), 1, 1)=='R') par.model[['plane']] <- plane
else stop('random parameter not allowed')
}
if (hasArg('polydeg') && !is.null(subst <- substitute(polydeg))) {
u <- try(is.numeric(polydeg) || is.logical(polydeg) || is.language(polydeg)
|| is.list(polydeg) || is(polydeg, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['polydeg']] <- polydeg
else if (substr(deparse(subst), 1, 1)=='R') par.model[['polydeg']] <- polydeg
else stop('random parameter not allowed')
}
if (hasArg('polycoeff') && !is.null(subst <- substitute(polycoeff))) {
u <- try(is.numeric(polycoeff) || is.logical(polycoeff) || is.language(polycoeff)
|| is.list(polycoeff) || is(polycoeff, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['polycoeff']] <- polycoeff
else if (substr(deparse(subst), 1, 1)=='R') par.model[['polycoeff']] <- polycoeff
else stop('random parameter not allowed')
}
if (hasArg('arbitraryfct') && !is.null(subst <- substitute(arbitraryfct))) {
u <- try(is.numeric(arbitraryfct) || is.logical(arbitraryfct) || is.language(arbitraryfct)
|| is.list(arbitraryfct) || is(arbitraryfct, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['arbitraryfct']] <- arbitraryfct
else if (substr(deparse(subst), 1, 1)=='R') par.model[['arbitraryfct']] <- arbitraryfct
else stop('random parameter not allowed')
}
if (hasArg('fctcoeff') && !is.null(subst <- substitute(fctcoeff))) {
u <- try(is.numeric(fctcoeff) || is.logical(fctcoeff) || is.language(fctcoeff)
|| is.list(fctcoeff) || is(fctcoeff, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['fctcoeff']] <- fctcoeff
else if (substr(deparse(subst), 1, 1)=='R') par.model[['fctcoeff']] <- fctcoeff
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RMtrend',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMtrend <- new('RMmodelgenerator',
.Data = RMtrend,
type = c('trend', 'trend'),
isotropy = c('isotropic', 'non-dimension-reducing'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = FALSE,
maxdim = Inf,
vdim = -1
)
RMplus <- function(C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(C0)) submodels[['C0']] <- C0
if (hasArg(C1)) submodels[['C1']] <- C1
if (hasArg(C2)) submodels[['C2']] <- C2
if (hasArg(C3)) submodels[['C3']] <- C3
if (hasArg(C4)) submodels[['C4']] <- C4
if (hasArg(C5)) submodels[['C5']] <- C5
if (hasArg(C6)) submodels[['C6']] <- C6
if (hasArg(C7)) submodels[['C7']] <- C7
if (hasArg(C8)) submodels[['C8']] <- C8
if (hasArg(C9)) submodels[['C9']] <- C9
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMplus',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMplus <- new('RMmodelgenerator',
.Data = RMplus,
type = c('undefined'),
isotropy = c('parameter dependent'),
domain = 'framework dependent',
operator = TRUE,
monotone = 'submodel dependent monotonicity',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = -3
)
RMmult <- function(C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(C0)) submodels[['C0']] <- C0
if (hasArg(C1)) submodels[['C1']] <- C1
if (hasArg(C2)) submodels[['C2']] <- C2
if (hasArg(C3)) submodels[['C3']] <- C3
if (hasArg(C4)) submodels[['C4']] <- C4
if (hasArg(C5)) submodels[['C5']] <- C5
if (hasArg(C6)) submodels[['C6']] <- C6
if (hasArg(C7)) submodels[['C7']] <- C7
if (hasArg(C8)) submodels[['C8']] <- C8
if (hasArg(C9)) submodels[['C9']] <- C9
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMmult',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMmult <- new('RMmodelgenerator',
.Data = RMmult,
type = c('undefined'),
isotropy = c('parameter dependent'),
domain = 'framework dependent',
operator = TRUE,
monotone = 'submodel dependent monotonicity',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = -3
)
RMS <- function(phi, var, scale, Aniso, proj, anisoT) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.model[['var']] <- var
else par.model[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.model[['scale']] <- scale
else par.model[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('anisoT') && !is.null(subst <- substitute(anisoT))) {
u <- try(is.numeric(anisoT) || is.logical(anisoT) || is.language(anisoT)
|| is.list(anisoT) || is(anisoT, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['anisoT']] <- anisoT
else if (substr(deparse(subst), 1, 1)=='R') par.model[['anisoT']] <- anisoT
else par.model[['anisoT']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.model[['Aniso']] <- Aniso
else par.model[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.model[['proj']] <- proj
else par.model[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMS',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMS <- new('RMmodelgenerator',
.Data = RMS,
type = c('undefined', 'undefined'),
isotropy = c('parameter dependent', 'parameter dependent'),
domain = 'framework dependent',
operator = TRUE,
monotone = 'submodel dependent monotonicity',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = -3
)
RMave <- function(phi, A, z, spacetime, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('A') && !is.null(subst <- substitute(A))) {
u <- try(is.numeric(A) || is.logical(A) || is.language(A)
|| is.list(A) || is(A, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['A']] <- A
else if (substr(deparse(subst), 1, 1)=='R') par.model[['A']] <- A
else par.model[['A']] <- do.call('RRdistr', list(subst))
}
if (hasArg('z') && !is.null(subst <- substitute(z))) {
u <- try(is.numeric(z) || is.logical(z) || is.language(z)
|| is.list(z) || is(z, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['z']] <- z
else if (substr(deparse(subst), 1, 1)=='R') par.model[['z']] <- z
else par.model[['z']] <- do.call('RRdistr', list(subst))
}
if (hasArg('spacetime') && !is.null(subst <- substitute(spacetime))) {
u <- try(is.numeric(spacetime) || is.logical(spacetime) || is.language(spacetime)
|| is.list(spacetime) || is(spacetime, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['spacetime']] <- spacetime
else if (substr(deparse(subst), 1, 1)=='R') par.model[['spacetime']] <- spacetime
else par.model[['spacetime']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMave',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMave <- new('RMmodelgenerator',
.Data = RMave,
type = c('positive definite'),
isotropy = c('symmetric'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 10,
vdim = 1
)
RMbcw <- function(alpha, beta, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
if (hasArg('beta') && !is.null(subst <- substitute(beta))) {
u <- try(is.numeric(beta) || is.logical(beta) || is.language(beta)
|| is.list(beta) || is(beta, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['beta']] <- beta
else if (substr(deparse(subst), 1, 1)=='R') par.model[['beta']] <- beta
else par.model[['beta']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMbcw',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMbcw <- new('RMmodelgenerator',
.Data = RMbcw,
type = c('variogram', 'positive definite', 'tail correlation', 'positive definite'),
isotropy = c('isotropic', 'isotropic', 'isotropic', 'spherical isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'normal mixture',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMbessel <- function(nu, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('nu') && !is.null(subst <- substitute(nu))) {
u <- try(is.numeric(nu) || is.logical(nu) || is.language(nu)
|| is.list(nu) || is(nu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['nu']] <- nu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['nu']] <- nu
else par.model[['nu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMbessel',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMbessel <- new('RMmodelgenerator',
.Data = RMbessel,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMbigneiting <- function(kappa, mu, s, sred12, gamma, cdiag, rhored, c, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('kappa') && !is.null(subst <- substitute(kappa))) {
u <- try(is.numeric(kappa) || is.logical(kappa) || is.language(kappa)
|| is.list(kappa) || is(kappa, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['kappa']] <- kappa
else if (substr(deparse(subst), 1, 1)=='R') par.model[['kappa']] <- kappa
else par.model[['kappa']] <- do.call('RRdistr', list(subst))
}
if (hasArg('mu') && !is.null(subst <- substitute(mu))) {
u <- try(is.numeric(mu) || is.logical(mu) || is.language(mu)
|| is.list(mu) || is(mu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mu']] <- mu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mu']] <- mu
else par.model[['mu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('s') && !is.null(subst <- substitute(s))) {
u <- try(is.numeric(s) || is.logical(s) || is.language(s)
|| is.list(s) || is(s, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['s']] <- s
else if (substr(deparse(subst), 1, 1)=='R') par.model[['s']] <- s
else par.model[['s']] <- do.call('RRdistr', list(subst))
}
if (hasArg('sred12') && !is.null(subst <- substitute(sred12))) {
u <- try(is.numeric(sred12) || is.logical(sred12) || is.language(sred12)
|| is.list(sred12) || is(sred12, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['sred12']] <- sred12
else if (substr(deparse(subst), 1, 1)=='R') par.model[['sred12']] <- sred12
else par.model[['sred12']] <- do.call('RRdistr', list(subst))
}
if (hasArg('gamma') && !is.null(subst <- substitute(gamma))) {
u <- try(is.numeric(gamma) || is.logical(gamma) || is.language(gamma)
|| is.list(gamma) || is(gamma, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['gamma']] <- gamma
else if (substr(deparse(subst), 1, 1)=='R') par.model[['gamma']] <- gamma
else par.model[['gamma']] <- do.call('RRdistr', list(subst))
}
if (hasArg('cdiag') && !is.null(subst <- substitute(cdiag))) {
u <- try(is.numeric(cdiag) || is.logical(cdiag) || is.language(cdiag)
|| is.list(cdiag) || is(cdiag, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['cdiag']] <- cdiag
else if (substr(deparse(subst), 1, 1)=='R') par.model[['cdiag']] <- cdiag
else par.model[['cdiag']] <- do.call('RRdistr', list(subst))
}
if (hasArg('rhored') && !is.null(subst <- substitute(rhored))) {
u <- try(is.numeric(rhored) || is.logical(rhored) || is.language(rhored)
|| is.list(rhored) || is(rhored, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['rhored']] <- rhored
else if (substr(deparse(subst), 1, 1)=='R') par.model[['rhored']] <- rhored
else par.model[['rhored']] <- do.call('RRdistr', list(subst))
}
if (hasArg('c') && !is.null(subst <- substitute(c))) {
u <- try(is.numeric(c) || is.logical(c) || is.language(c)
|| is.list(c) || is(c, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['c']] <- c
else if (substr(deparse(subst), 1, 1)=='R') par.model[['c']] <- c
else par.model[['c']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMbigneiting',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMbigneiting <- new('RMmodelgenerator',
.Data = RMbigneiting,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = -1,
vdim = 2
)
RMbernoulli <- function(phi, threshold, correlation, centred, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('threshold') && !is.null(subst <- substitute(threshold))) {
u <- try(is.numeric(threshold) || is.logical(threshold) || is.language(threshold)
|| is.list(threshold) || is(threshold, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['threshold']] <- threshold
else if (substr(deparse(subst), 1, 1)=='R') par.model[['threshold']] <- threshold
else par.model[['threshold']] <- do.call('RRdistr', list(subst))
}
if (hasArg('correlation') && !is.null(subst <- substitute(correlation))) {
u <- try(is.numeric(correlation) || is.logical(correlation) || is.language(correlation)
|| is.list(correlation) || is(correlation, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['correlation']] <- correlation
else if (substr(deparse(subst), 1, 1)=='R') par.model[['correlation']] <- correlation
else par.model[['correlation']] <- do.call('RRdistr', list(subst))
}
if (hasArg('centred') && !is.null(subst <- substitute(centred))) {
u <- try(is.numeric(centred) || is.logical(centred) || is.language(centred)
|| is.list(centred) || is(centred, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['centred']] <- centred
else if (substr(deparse(subst), 1, 1)=='R') par.model[['centred']] <- centred
else par.model[['centred']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMbernoulli',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMbernoulli <- new('RMmodelgenerator',
.Data = RMbernoulli,
type = c('tail correlation'),
isotropy = c('parameter dependent'),
domain = 'framework dependent',
operator = TRUE,
monotone = 'submodel dependent monotonicity',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMbiwm <- function(nudiag, nured12, nu, s, cdiag, rhored, c, notinvnu, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('nudiag') && !is.null(subst <- substitute(nudiag))) {
u <- try(is.numeric(nudiag) || is.logical(nudiag) || is.language(nudiag)
|| is.list(nudiag) || is(nudiag, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['nudiag']] <- nudiag
else if (substr(deparse(subst), 1, 1)=='R') par.model[['nudiag']] <- nudiag
else par.model[['nudiag']] <- do.call('RRdistr', list(subst))
}
if (hasArg('nured12') && !is.null(subst <- substitute(nured12))) {
u <- try(is.numeric(nured12) || is.logical(nured12) || is.language(nured12)
|| is.list(nured12) || is(nured12, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['nured12']] <- nured12
else if (substr(deparse(subst), 1, 1)=='R') par.model[['nured12']] <- nured12
else par.model[['nured12']] <- do.call('RRdistr', list(subst))
}
if (hasArg('nu') && !is.null(subst <- substitute(nu))) {
u <- try(is.numeric(nu) || is.logical(nu) || is.language(nu)
|| is.list(nu) || is(nu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['nu']] <- nu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['nu']] <- nu
else par.model[['nu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('s') && !is.null(subst <- substitute(s))) {
u <- try(is.numeric(s) || is.logical(s) || is.language(s)
|| is.list(s) || is(s, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['s']] <- s
else if (substr(deparse(subst), 1, 1)=='R') par.model[['s']] <- s
else par.model[['s']] <- do.call('RRdistr', list(subst))
}
if (hasArg('cdiag') && !is.null(subst <- substitute(cdiag))) {
u <- try(is.numeric(cdiag) || is.logical(cdiag) || is.language(cdiag)
|| is.list(cdiag) || is(cdiag, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['cdiag']] <- cdiag
else if (substr(deparse(subst), 1, 1)=='R') par.model[['cdiag']] <- cdiag
else par.model[['cdiag']] <- do.call('RRdistr', list(subst))
}
if (hasArg('rhored') && !is.null(subst <- substitute(rhored))) {
u <- try(is.numeric(rhored) || is.logical(rhored) || is.language(rhored)
|| is.list(rhored) || is(rhored, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['rhored']] <- rhored
else if (substr(deparse(subst), 1, 1)=='R') par.model[['rhored']] <- rhored
else par.model[['rhored']] <- do.call('RRdistr', list(subst))
}
if (hasArg('c') && !is.null(subst <- substitute(c))) {
u <- try(is.numeric(c) || is.logical(c) || is.language(c)
|| is.list(c) || is(c, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['c']] <- c
else if (substr(deparse(subst), 1, 1)=='R') par.model[['c']] <- c
else par.model[['c']] <- do.call('RRdistr', list(subst))
}
if (hasArg('notinvnu') && !is.null(subst <- substitute(notinvnu))) {
u <- try(is.numeric(notinvnu) || is.logical(notinvnu) || is.language(notinvnu)
|| is.list(notinvnu) || is(notinvnu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['notinvnu']] <- notinvnu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['notinvnu']] <- notinvnu
else par.model[['notinvnu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMbiwm',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMbiwm <- new('RMmodelgenerator',
.Data = RMbiwm,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 2
)
RMbrownresnick <- function(phi, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMbrownresnick',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMbrownresnick <- new('RMmodelgenerator',
.Data = RMbrownresnick,
type = c('tail correlation'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = TRUE,
monotone = 'submodel dependent monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMbr2bg <- function(phi, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMbr2bg',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMbr2bg <- new('RMmodelgenerator',
.Data = RMbr2bg,
type = c('positive definite'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = TRUE,
monotone = 'submodel dependent monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMbr2eg <- function(phi, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMbr2eg',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMbr2eg <- new('RMmodelgenerator',
.Data = RMbr2eg,
type = c('positive definite'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = TRUE,
monotone = 'submodel dependent monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMcauchy <- function(gamma, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('gamma') && !is.null(subst <- substitute(gamma))) {
u <- try(is.numeric(gamma) || is.logical(gamma) || is.language(gamma)
|| is.list(gamma) || is(gamma, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['gamma']] <- gamma
else if (substr(deparse(subst), 1, 1)=='R') par.model[['gamma']] <- gamma
else par.model[['gamma']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMcauchy',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMcauchy <- new('RMmodelgenerator',
.Data = RMcauchy,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'normal mixture',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMcircular <- function(var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMcircular',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMcircular <- new('RMmodelgenerator',
.Data = RMcircular,
type = c('tail correlation'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'Gneiting-Schaback class',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 2,
vdim = 1
)
RMconstant <- function(M, var) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('M') && !is.null(subst <- substitute(M))) {
u <- try(is.numeric(M) || is.logical(M) || is.language(M)
|| is.list(M) || is(M, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['M']] <- M
else if (substr(deparse(subst), 1, 1)=='R') par.model[['M']] <- M
else stop('random parameter not allowed')
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMconstant',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMconstant <- new('RMmodelgenerator',
.Data = RMconstant,
type = c('negative definite'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'submodel dependent monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -1
)
RMcovariateIntern <- function(norm, c, x, T, grid, factor) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(norm)) submodels[['norm']] <- norm
if (hasArg('c') && !is.null(subst <- substitute(c))) {
u <- try(is.numeric(c) || is.logical(c) || is.language(c)
|| is.list(c) || is(c, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['c']] <- c
else if (substr(deparse(subst), 1, 1)=='R') par.model[['c']] <- c
else par.model[['c']] <- do.call('RRdistr', list(subst))
}
if (hasArg('x') && !is.null(subst <- substitute(x))) {
u <- try(is.numeric(x) || is.logical(x) || is.language(x)
|| is.list(x) || is(x, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['x']] <- x
else if (substr(deparse(subst), 1, 1)=='R') par.model[['x']] <- x
else par.model[['x']] <- do.call('RRdistr', list(subst))
}
if (hasArg('T') && !is.null(subst <- substitute(T))) {
u <- try(is.numeric(T) || is.logical(T) || is.language(T)
|| is.list(T) || is(T, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['T']] <- T
else if (substr(deparse(subst), 1, 1)=='R') par.model[['T']] <- T
else par.model[['T']] <- do.call('RRdistr', list(subst))
}
if (hasArg('grid') && !is.null(subst <- substitute(grid))) {
u <- try(is.numeric(grid) || is.logical(grid) || is.language(grid)
|| is.list(grid) || is(grid, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['grid']] <- grid
else if (substr(deparse(subst), 1, 1)=='R') par.model[['grid']] <- grid
else par.model[['grid']] <- do.call('RRdistr', list(subst))
}
if (hasArg('factor') && !is.null(subst <- substitute(factor))) {
u <- try(is.numeric(factor) || is.logical(factor) || is.language(factor)
|| is.list(factor) || is(factor, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['factor']] <- factor
else if (substr(deparse(subst), 1, 1)=='R') par.model[['factor']] <- factor
else par.model[['factor']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMcovariateIntern',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMcovariateIntern <- new('RMmodelgenerator',
.Data = RMcovariateIntern,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -1
)
RMcoxisham <- function(phi, mu, D, beta, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('mu') && !is.null(subst <- substitute(mu))) {
u <- try(is.numeric(mu) || is.logical(mu) || is.language(mu)
|| is.list(mu) || is(mu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mu']] <- mu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mu']] <- mu
else par.model[['mu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('D') && !is.null(subst <- substitute(D))) {
u <- try(is.numeric(D) || is.logical(D) || is.language(D)
|| is.list(D) || is(D, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['D']] <- D
else if (substr(deparse(subst), 1, 1)=='R') par.model[['D']] <- D
else par.model[['D']] <- do.call('RRdistr', list(subst))
}
if (hasArg('beta') && !is.null(subst <- substitute(beta))) {
u <- try(is.numeric(beta) || is.logical(beta) || is.language(beta)
|| is.list(beta) || is(beta, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['beta']] <- beta
else if (substr(deparse(subst), 1, 1)=='R') par.model[['beta']] <- beta
else par.model[['beta']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMcoxisham',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMcoxisham <- new('RMmodelgenerator',
.Data = RMcoxisham,
type = c('positive definite'),
isotropy = c('zero-space-isotropic'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 3,
vdim = 1
)
RMcubic <- function(var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMcubic',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMcubic <- new('RMmodelgenerator',
.Data = RMcubic,
type = c('tail correlation'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 3,
vdim = 1
)
RMcurlfree <- function(phi, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMcurlfree',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMcurlfree <- new('RMmodelgenerator',
.Data = RMcurlfree,
type = c('positive definite'),
isotropy = c('symmetric'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = -1
)
RMcutoff <- function(phi, diameter, a, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('diameter') && !is.null(subst <- substitute(diameter))) {
u <- try(is.numeric(diameter) || is.logical(diameter) || is.language(diameter)
|| is.list(diameter) || is(diameter, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['diameter']] <- diameter
else if (substr(deparse(subst), 1, 1)=='R') par.model[['diameter']] <- diameter
else par.model[['diameter']] <- do.call('RRdistr', list(subst))
}
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMcutoff',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMcutoff <- new('RMmodelgenerator',
.Data = RMcutoff,
type = c('positive definite', 'positive definite'),
isotropy = c('isotropic', 'spherical isotropic'),
domain = 'single variable',
operator = TRUE,
monotone = 'monotone',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = 13,
vdim = 1
)
RMdagum <- function(beta, gamma, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('beta') && !is.null(subst <- substitute(beta))) {
u <- try(is.numeric(beta) || is.logical(beta) || is.language(beta)
|| is.list(beta) || is(beta, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['beta']] <- beta
else if (substr(deparse(subst), 1, 1)=='R') par.model[['beta']] <- beta
else par.model[['beta']] <- do.call('RRdistr', list(subst))
}
if (hasArg('gamma') && !is.null(subst <- substitute(gamma))) {
u <- try(is.numeric(gamma) || is.logical(gamma) || is.language(gamma)
|| is.list(gamma) || is(gamma, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['gamma']] <- gamma
else if (substr(deparse(subst), 1, 1)=='R') par.model[['gamma']] <- gamma
else par.model[['gamma']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMdagum',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMdagum <- new('RMmodelgenerator',
.Data = RMdagum,
type = c('positive definite', 'tail correlation', 'positive definite'),
isotropy = c('isotropic', 'isotropic', 'spherical isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'parameter dependent monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMdampedcos <- function(lambda, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('lambda') && !is.null(subst <- substitute(lambda))) {
u <- try(is.numeric(lambda) || is.logical(lambda) || is.language(lambda)
|| is.list(lambda) || is(lambda, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['lambda']] <- lambda
else if (substr(deparse(subst), 1, 1)=='R') par.model[['lambda']] <- lambda
else par.model[['lambda']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMdampedcos',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMdampedcos <- new('RMmodelgenerator',
.Data = RMdampedcos,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -1,
vdim = 1
)
RMdewijsian <- function(alpha, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMdewijsian',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMdewijsian <- new('RMmodelgenerator',
.Data = RMdewijsian,
type = c('variogram'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMdivfree <- function(phi, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMdivfree',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMdivfree <- new('RMmodelgenerator',
.Data = RMdivfree,
type = c('positive definite'),
isotropy = c('symmetric'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = -1
)
RMepscauchy <- function(alpha, beta, eps, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
if (hasArg('beta') && !is.null(subst <- substitute(beta))) {
u <- try(is.numeric(beta) || is.logical(beta) || is.language(beta)
|| is.list(beta) || is(beta, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['beta']] <- beta
else if (substr(deparse(subst), 1, 1)=='R') par.model[['beta']] <- beta
else par.model[['beta']] <- do.call('RRdistr', list(subst))
}
if (hasArg('eps') && !is.null(subst <- substitute(eps))) {
u <- try(is.numeric(eps) || is.logical(eps) || is.language(eps)
|| is.list(eps) || is(eps, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['eps']] <- eps
else if (substr(deparse(subst), 1, 1)=='R') par.model[['eps']] <- eps
else par.model[['eps']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMepscauchy',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMepscauchy <- new('RMmodelgenerator',
.Data = RMepscauchy,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'normal mixture',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMexp <- function(var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMexp',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMexp <- new('RMmodelgenerator',
.Data = RMexp,
type = c('tail correlation', 'positive definite'),
isotropy = c('isotropic', 'spherical isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'completely monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMexponential <- function(phi, n, standardised, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('n') && !is.null(subst <- substitute(n))) {
u <- try(is.numeric(n) || is.logical(n) || is.language(n)
|| is.list(n) || is(n, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['n']] <- n
else if (substr(deparse(subst), 1, 1)=='R') par.model[['n']] <- n
else par.model[['n']] <- do.call('RRdistr', list(subst))
}
if (hasArg('standardised') && !is.null(subst <- substitute(standardised))) {
u <- try(is.numeric(standardised) || is.logical(standardised) || is.language(standardised)
|| is.list(standardised) || is(standardised, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['standardised']] <- standardised
else if (substr(deparse(subst), 1, 1)=='R') par.model[['standardised']] <- standardised
else par.model[['standardised']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMexponential',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMexponential <- new('RMmodelgenerator',
.Data = RMexponential,
type = c('positive definite'),
isotropy = c('parameter dependent'),
domain = 'framework dependent',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMschlather <- function(phi, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMschlather',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMschlather <- new('RMmodelgenerator',
.Data = RMschlather,
type = c('tail correlation'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMfractdiff <- function(a, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMfractdiff',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMfractdiff <- new('RMmodelgenerator',
.Data = RMfractdiff,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 1,
vdim = 1
)
RMfixcov <- function(M, vdim, element, var) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('M') && !is.null(subst <- substitute(M))) {
u <- try(is.numeric(M) || is.logical(M) || is.language(M)
|| is.list(M) || is(M, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['M']] <- M
else if (substr(deparse(subst), 1, 1)=='R') par.model[['M']] <- M
else par.model[['M']] <- do.call('RRdistr', list(subst))
}
if (hasArg('vdim') && !is.null(subst <- substitute(vdim))) {
u <- try(is.numeric(vdim) || is.logical(vdim) || is.language(vdim)
|| is.list(vdim) || is(vdim, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['vdim']] <- vdim
else if (substr(deparse(subst), 1, 1)=='R') par.model[['vdim']] <- vdim
else par.model[['vdim']] <- do.call('RRdistr', list(subst))
}
if (hasArg('element') && !is.null(subst <- substitute(element))) {
u <- try(is.numeric(element) || is.logical(element) || is.language(element)
|| is.list(element) || is(element, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['element']] <- element
else if (substr(deparse(subst), 1, 1)=='R') par.model[['element']] <- element
else par.model[['element']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMfixcov',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMfixcov <- new('RMmodelgenerator',
.Data = RMfixcov,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = FALSE,
maxdim = Inf,
vdim = -1
)
RMflatpower <- function(alpha, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMflatpower',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMflatpower <- new('RMmodelgenerator',
.Data = RMflatpower,
type = c('variogram'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'Bernstein',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMfbm <- function(alpha, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMfbm',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMfbm <- new('RMmodelgenerator',
.Data = RMfbm,
type = c('variogram'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'Bernstein',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMfractgauss <- function(alpha, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMfractgauss',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMfractgauss <- new('RMmodelgenerator',
.Data = RMfractgauss,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 1,
vdim = 1
)
RMgauss <- function(var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMgauss',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMgauss <- new('RMmodelgenerator',
.Data = RMgauss,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'normal mixture',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMgenfbm <- function(alpha, beta, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
if (hasArg('beta') && !is.null(subst <- substitute(beta))) {
u <- try(is.numeric(beta) || is.logical(beta) || is.language(beta)
|| is.list(beta) || is(beta, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['beta']] <- beta
else if (substr(deparse(subst), 1, 1)=='R') par.model[['beta']] <- beta
else par.model[['beta']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMgenfbm',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMgenfbm <- new('RMmodelgenerator',
.Data = RMgenfbm,
type = c('variogram'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMgencauchy <- function(alpha, beta, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
if (hasArg('beta') && !is.null(subst <- substitute(beta))) {
u <- try(is.numeric(beta) || is.logical(beta) || is.language(beta)
|| is.list(beta) || is(beta, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['beta']] <- beta
else if (substr(deparse(subst), 1, 1)=='R') par.model[['beta']] <- beta
else par.model[['beta']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMgencauchy',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMgencauchy <- new('RMmodelgenerator',
.Data = RMgencauchy,
type = c('positive definite', 'tail correlation', 'positive definite'),
isotropy = c('isotropic', 'isotropic', 'spherical isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'parameter dependent monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMgengneiting <- function(kappa, mu, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('kappa') && !is.null(subst <- substitute(kappa))) {
u <- try(is.numeric(kappa) || is.logical(kappa) || is.language(kappa)
|| is.list(kappa) || is(kappa, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['kappa']] <- kappa
else if (substr(deparse(subst), 1, 1)=='R') par.model[['kappa']] <- kappa
else par.model[['kappa']] <- do.call('RRdistr', list(subst))
}
if (hasArg('mu') && !is.null(subst <- substitute(mu))) {
u <- try(is.numeric(mu) || is.logical(mu) || is.language(mu)
|| is.list(mu) || is(mu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mu']] <- mu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mu']] <- mu
else par.model[['mu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMgengneiting',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMgengneiting <- new('RMmodelgenerator',
.Data = RMgengneiting,
type = c('positive definite', 'positive definite'),
isotropy = c('isotropic', 'spherical isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'monotone',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMgneiting <- function(orig, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('orig') && !is.null(subst <- substitute(orig))) {
u <- try(is.numeric(orig) || is.logical(orig) || is.language(orig)
|| is.list(orig) || is(orig, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['orig']] <- orig
else if (substr(deparse(subst), 1, 1)=='R') par.model[['orig']] <- orig
else par.model[['orig']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMgneiting',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMgneiting <- new('RMmodelgenerator',
.Data = RMgneiting,
type = c('positive definite', 'positive definite'),
isotropy = c('isotropic', 'spherical isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'monotone',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = -1,
vdim = 1
)
RMgennsst <- function(phi, psi, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg(psi)) submodels[['psi']] <- psi
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMgennsst',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMgennsst <- new('RMmodelgenerator',
.Data = RMgennsst,
type = c('positive definite'),
isotropy = c('parameter dependent'),
domain = 'kernel',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMhyperbolic <- function(nu, lambda, delta, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('nu') && !is.null(subst <- substitute(nu))) {
u <- try(is.numeric(nu) || is.logical(nu) || is.language(nu)
|| is.list(nu) || is(nu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['nu']] <- nu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['nu']] <- nu
else par.model[['nu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('lambda') && !is.null(subst <- substitute(lambda))) {
u <- try(is.numeric(lambda) || is.logical(lambda) || is.language(lambda)
|| is.list(lambda) || is(lambda, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['lambda']] <- lambda
else if (substr(deparse(subst), 1, 1)=='R') par.model[['lambda']] <- lambda
else par.model[['lambda']] <- do.call('RRdistr', list(subst))
}
if (hasArg('delta') && !is.null(subst <- substitute(delta))) {
u <- try(is.numeric(delta) || is.logical(delta) || is.language(delta)
|| is.list(delta) || is(delta, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['delta']] <- delta
else if (substr(deparse(subst), 1, 1)=='R') par.model[['delta']] <- delta
else par.model[['delta']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMhyperbolic',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMhyperbolic <- new('RMmodelgenerator',
.Data = RMhyperbolic,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'normal mixture',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMiaco <- function(nu, lambda, delta, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('nu') && !is.null(subst <- substitute(nu))) {
u <- try(is.numeric(nu) || is.logical(nu) || is.language(nu)
|| is.list(nu) || is(nu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['nu']] <- nu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['nu']] <- nu
else par.model[['nu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('lambda') && !is.null(subst <- substitute(lambda))) {
u <- try(is.numeric(lambda) || is.logical(lambda) || is.language(lambda)
|| is.list(lambda) || is(lambda, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['lambda']] <- lambda
else if (substr(deparse(subst), 1, 1)=='R') par.model[['lambda']] <- lambda
else par.model[['lambda']] <- do.call('RRdistr', list(subst))
}
if (hasArg('delta') && !is.null(subst <- substitute(delta))) {
u <- try(is.numeric(delta) || is.logical(delta) || is.language(delta)
|| is.list(delta) || is(delta, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['delta']] <- delta
else if (substr(deparse(subst), 1, 1)=='R') par.model[['delta']] <- delta
else par.model[['delta']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMiaco',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMiaco <- new('RMmodelgenerator',
.Data = RMiaco,
type = c('positive definite'),
isotropy = c('space-isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMid <- function(phi, vdim, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('vdim') && !is.null(subst <- substitute(vdim))) {
u <- try(is.numeric(vdim) || is.logical(vdim) || is.language(vdim)
|| is.list(vdim) || is(vdim, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['vdim']] <- vdim
else if (substr(deparse(subst), 1, 1)=='R') par.model[['vdim']] <- vdim
else par.model[['vdim']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMid',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMid <- new('RMmodelgenerator',
.Data = RMid,
type = c('undefined'),
isotropy = c('parameter dependent'),
domain = 'framework dependent',
operator = TRUE,
monotone = 'submodel dependent monotonicity',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = -3
)
RMkolmogorov <- function(var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMkolmogorov',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMkolmogorov <- new('RMmodelgenerator',
.Data = RMkolmogorov,
type = c('variogram'),
isotropy = c('vector-isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 3,
vdim = 3
)
RMlgd <- function(alpha, beta, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
if (hasArg('beta') && !is.null(subst <- substitute(beta))) {
u <- try(is.numeric(beta) || is.logical(beta) || is.language(beta)
|| is.list(beta) || is(beta, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['beta']] <- beta
else if (substr(deparse(subst), 1, 1)=='R') par.model[['beta']] <- beta
else par.model[['beta']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMlgd',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMlgd <- new('RMmodelgenerator',
.Data = RMlgd,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -1,
vdim = 1
)
RMmastein <- function(phi, nu, delta, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('nu') && !is.null(subst <- substitute(nu))) {
u <- try(is.numeric(nu) || is.logical(nu) || is.language(nu)
|| is.list(nu) || is(nu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['nu']] <- nu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['nu']] <- nu
else par.model[['nu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('delta') && !is.null(subst <- substitute(delta))) {
u <- try(is.numeric(delta) || is.logical(delta) || is.language(delta)
|| is.list(delta) || is(delta, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['delta']] <- delta
else if (substr(deparse(subst), 1, 1)=='R') par.model[['delta']] <- delta
else par.model[['delta']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMmastein',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMmastein <- new('RMmodelgenerator',
.Data = RMmastein,
type = c('positive definite'),
isotropy = c('space-isotropic'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMma <- function(phi, alpha, theta, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
if (hasArg('theta') && !is.null(subst <- substitute(theta))) {
u <- try(is.numeric(theta) || is.logical(theta) || is.language(theta)
|| is.list(theta) || is(theta, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['theta']] <- theta
else if (substr(deparse(subst), 1, 1)=='R') par.model[['theta']] <- theta
else par.model[['theta']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMma',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMma <- new('RMmodelgenerator',
.Data = RMma,
type = c('positive definite'),
isotropy = c('symmetric'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMintexp <- function(phi, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMintexp',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMintexp <- new('RMmodelgenerator',
.Data = RMintexp,
type = c('positive definite'),
isotropy = c('symmetric'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMmatrix <- function(phi, M, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('M') && !is.null(subst <- substitute(M))) {
u <- try(is.numeric(M) || is.logical(M) || is.language(M)
|| is.list(M) || is(M, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['M']] <- M
else if (substr(deparse(subst), 1, 1)=='R') par.model[['M']] <- M
else par.model[['M']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMmatrix',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMmatrix <- new('RMmodelgenerator',
.Data = RMmatrix,
type = c('positive definite'),
isotropy = c('parameter dependent'),
domain = 'framework dependent',
operator = TRUE,
monotone = 'not monotone',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = -1
)
RMmatern <- function(nu, notinvnu, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('nu') && !is.null(subst <- substitute(nu))) {
u <- try(is.numeric(nu) || is.logical(nu) || is.language(nu)
|| is.list(nu) || is(nu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['nu']] <- nu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['nu']] <- nu
else par.model[['nu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('notinvnu') && !is.null(subst <- substitute(notinvnu))) {
u <- try(is.numeric(notinvnu) || is.logical(notinvnu) || is.language(notinvnu)
|| is.list(notinvnu) || is(notinvnu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['notinvnu']] <- notinvnu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['notinvnu']] <- notinvnu
else par.model[['notinvnu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMmatern',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMmatern <- new('RMmodelgenerator',
.Data = RMmatern,
type = c('positive definite', 'tail correlation', 'positive definite'),
isotropy = c('isotropic', 'isotropic', 'spherical isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'submodel dependent monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMmqam <- function(phi, C1, C2, C3, C4, C5, C6, C7, C8, C9, theta, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg(C1)) submodels[['C1']] <- C1
if (hasArg(C2)) submodels[['C2']] <- C2
if (hasArg(C3)) submodels[['C3']] <- C3
if (hasArg(C4)) submodels[['C4']] <- C4
if (hasArg(C5)) submodels[['C5']] <- C5
if (hasArg(C6)) submodels[['C6']] <- C6
if (hasArg(C7)) submodels[['C7']] <- C7
if (hasArg(C8)) submodels[['C8']] <- C8
if (hasArg(C9)) submodels[['C9']] <- C9
if (hasArg('theta') && !is.null(subst <- substitute(theta))) {
u <- try(is.numeric(theta) || is.logical(theta) || is.language(theta)
|| is.list(theta) || is(theta, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['theta']] <- theta
else if (substr(deparse(subst), 1, 1)=='R') par.model[['theta']] <- theta
else par.model[['theta']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMmqam',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMmqam <- new('RMmodelgenerator',
.Data = RMmqam,
type = c('positive definite'),
isotropy = c('symmetric'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -3,
vdim = -1
)
RMnatsc <- function(phi, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMnatsc',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMnatsc <- new('RMmodelgenerator',
.Data = RMnatsc,
type = c('tail correlation'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = TRUE,
monotone = 'submodel dependent monotonicity',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMnonstwm <- function(nu, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('nu') && !is.null(subst <- substitute(nu))) {
u <- try(is.numeric(nu) || is.logical(nu) || is.language(nu)
|| is.list(nu) || is(nu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['nu']] <- nu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['nu']] <- nu
else par.model[['nu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMnonstwm',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMnonstwm <- new('RMmodelgenerator',
.Data = RMnonstwm,
type = c('positive definite'),
isotropy = c('symmetric'),
domain = 'kernel',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMnsst <- function(phi, psi, delta, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg(psi)) submodels[['psi']] <- psi
if (hasArg('delta') && !is.null(subst <- substitute(delta))) {
u <- try(is.numeric(delta) || is.logical(delta) || is.language(delta)
|| is.list(delta) || is(delta, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['delta']] <- delta
else if (substr(deparse(subst), 1, 1)=='R') par.model[['delta']] <- delta
else par.model[['delta']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMnsst',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMnsst <- new('RMmodelgenerator',
.Data = RMnsst,
type = c('positive definite'),
isotropy = c('space-isotropic'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMnugget <- function(tol, vdim, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('tol') && !is.null(subst <- substitute(tol))) {
u <- try(is.numeric(tol) || is.logical(tol) || is.language(tol)
|| is.list(tol) || is(tol, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['tol']] <- tol
else if (substr(deparse(subst), 1, 1)=='R') par.model[['tol']] <- tol
else par.model[['tol']] <- do.call('RRdistr', list(subst))
}
if (hasArg('vdim') && !is.null(subst <- substitute(vdim))) {
u <- try(is.numeric(vdim) || is.logical(vdim) || is.language(vdim)
|| is.list(vdim) || is(vdim, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['vdim']] <- vdim
else if (substr(deparse(subst), 1, 1)=='R') par.model[['vdim']] <- vdim
else par.model[['vdim']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMnugget',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMnugget <- new('RMmodelgenerator',
.Data = RMnugget,
type = c('tail correlation', 'tail correlation', 'tail correlation'),
isotropy = c('isotropic', 'earth isotropic', 'spherical isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'monotone',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -2
)
RMparswm <- function(nudiag, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('nudiag') && !is.null(subst <- substitute(nudiag))) {
u <- try(is.numeric(nudiag) || is.logical(nudiag) || is.language(nudiag)
|| is.list(nudiag) || is(nudiag, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['nudiag']] <- nudiag
else if (substr(deparse(subst), 1, 1)=='R') par.model[['nudiag']] <- nudiag
else par.model[['nudiag']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMparswm',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMparswm <- new('RMmodelgenerator',
.Data = RMparswm,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -1
)
RMpenta <- function(var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMpenta',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMpenta <- new('RMmodelgenerator',
.Data = RMpenta,
type = c('positive definite', 'positive definite'),
isotropy = c('isotropic', 'spherical isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'monotone',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = 3,
vdim = 1
)
RMaskey <- function(alpha, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMaskey',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMaskey <- new('RMmodelgenerator',
.Data = RMaskey,
type = c('positive definite', 'positive definite', 'tail correlation'),
isotropy = c('isotropic', 'spherical isotropic', 'isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'monotone',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMpower <- function(phi, alpha, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMpower',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMpower <- new('RMmodelgenerator',
.Data = RMpower,
type = c('positive definite', 'positive definite'),
isotropy = c('parameter dependent', 'parameter dependent'),
domain = 'framework dependent',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMprod <- function(phi, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMprod',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMprod <- new('RMmodelgenerator',
.Data = RMprod,
type = c('positive definite', 'positive definite', 'positive definite'),
isotropy = c('symmetric', 'spherical system', 'earth system'),
domain = 'kernel',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -3
)
RMqam <- function(phi, C1, C2, C3, C4, C5, C6, C7, C8, C9, theta, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg(C1)) submodels[['C1']] <- C1
if (hasArg(C2)) submodels[['C2']] <- C2
if (hasArg(C3)) submodels[['C3']] <- C3
if (hasArg(C4)) submodels[['C4']] <- C4
if (hasArg(C5)) submodels[['C5']] <- C5
if (hasArg(C6)) submodels[['C6']] <- C6
if (hasArg(C7)) submodels[['C7']] <- C7
if (hasArg(C8)) submodels[['C8']] <- C8
if (hasArg(C9)) submodels[['C9']] <- C9
if (hasArg('theta') && !is.null(subst <- substitute(theta))) {
u <- try(is.numeric(theta) || is.logical(theta) || is.language(theta)
|| is.list(theta) || is(theta, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['theta']] <- theta
else if (substr(deparse(subst), 1, 1)=='R') par.model[['theta']] <- theta
else par.model[['theta']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMqam',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMqam <- new('RMmodelgenerator',
.Data = RMqam,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMqexp <- function(alpha, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMqexp',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMqexp <- new('RMmodelgenerator',
.Data = RMqexp,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMschur <- function(phi, M, diag, rhored, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('M') && !is.null(subst <- substitute(M))) {
u <- try(is.numeric(M) || is.logical(M) || is.language(M)
|| is.list(M) || is(M, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['M']] <- M
else if (substr(deparse(subst), 1, 1)=='R') par.model[['M']] <- M
else par.model[['M']] <- do.call('RRdistr', list(subst))
}
if (hasArg('diag') && !is.null(subst <- substitute(diag))) {
u <- try(is.numeric(diag) || is.logical(diag) || is.language(diag)
|| is.list(diag) || is(diag, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['diag']] <- diag
else if (substr(deparse(subst), 1, 1)=='R') par.model[['diag']] <- diag
else par.model[['diag']] <- do.call('RRdistr', list(subst))
}
if (hasArg('rhored') && !is.null(subst <- substitute(rhored))) {
u <- try(is.numeric(rhored) || is.logical(rhored) || is.language(rhored)
|| is.list(rhored) || is(rhored, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['rhored']] <- rhored
else if (substr(deparse(subst), 1, 1)=='R') par.model[['rhored']] <- rhored
else par.model[['rhored']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMschur',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMschur <- new('RMmodelgenerator',
.Data = RMschur,
type = c('positive definite'),
isotropy = c('parameter dependent'),
domain = 'framework dependent',
operator = TRUE,
monotone = 'not monotone',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = -3
)
RMdelay <- function(phi, s, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('s') && !is.null(subst <- substitute(s))) {
u <- try(is.numeric(s) || is.logical(s) || is.language(s)
|| is.list(s) || is(s, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['s']] <- s
else if (substr(deparse(subst), 1, 1)=='R') par.model[['s']] <- s
else par.model[['s']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMdelay',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMdelay <- new('RMmodelgenerator',
.Data = RMdelay,
type = c('positive definite'),
isotropy = c('symmetric'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = -1
)
RMspheric <- function(var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMspheric',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMspheric <- new('RMmodelgenerator',
.Data = RMspheric,
type = c('tail correlation', 'positive definite'),
isotropy = c('isotropic', 'spherical isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'Gneiting-Schaback class',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = 3,
vdim = 1
)
RMstable <- function(alpha, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMstable',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMstable <- new('RMmodelgenerator',
.Data = RMstable,
type = c('positive definite', 'tail correlation', 'positive definite'),
isotropy = c('isotropic', 'isotropic', 'spherical isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'parameter dependent monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMintrinsic <- function(phi, diameter, rawR, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('diameter') && !is.null(subst <- substitute(diameter))) {
u <- try(is.numeric(diameter) || is.logical(diameter) || is.language(diameter)
|| is.list(diameter) || is(diameter, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['diameter']] <- diameter
else if (substr(deparse(subst), 1, 1)=='R') par.model[['diameter']] <- diameter
else par.model[['diameter']] <- do.call('RRdistr', list(subst))
}
if (hasArg('rawR') && !is.null(subst <- substitute(rawR))) {
u <- try(is.numeric(rawR) || is.logical(rawR) || is.language(rawR)
|| is.list(rawR) || is(rawR, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['rawR']] <- rawR
else if (substr(deparse(subst), 1, 1)=='R') par.model[['rawR']] <- rawR
else par.model[['rawR']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMintrinsic',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMintrinsic <- new('RMmodelgenerator',
.Data = RMintrinsic,
type = c('positive definite', 'positive definite'),
isotropy = c('isotropic', 'spherical isotropic'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = 13,
vdim = 1
)
RMstein <- function(nu, z, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('nu') && !is.null(subst <- substitute(nu))) {
u <- try(is.numeric(nu) || is.logical(nu) || is.language(nu)
|| is.list(nu) || is(nu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['nu']] <- nu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['nu']] <- nu
else par.model[['nu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('z') && !is.null(subst <- substitute(z))) {
u <- try(is.numeric(z) || is.logical(z) || is.language(z)
|| is.list(z) || is(z, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['z']] <- z
else if (substr(deparse(subst), 1, 1)=='R') par.model[['z']] <- z
else par.model[['z']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMstein',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMstein <- new('RMmodelgenerator',
.Data = RMstein,
type = c('positive definite'),
isotropy = c('symmetric'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMstp <- function(xi, phi, S, z, M, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(xi)) submodels[['xi']] <- xi
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('S') && !is.null(subst <- substitute(S))) {
u <- try(is.numeric(S) || is.logical(S) || is.language(S)
|| is.list(S) || is(S, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['S']] <- S
else if (substr(deparse(subst), 1, 1)=='R') par.model[['S']] <- S
else par.model[['S']] <- do.call('RRdistr', list(subst))
}
if (hasArg('z') && !is.null(subst <- substitute(z))) {
u <- try(is.numeric(z) || is.logical(z) || is.language(z)
|| is.list(z) || is(z, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['z']] <- z
else if (substr(deparse(subst), 1, 1)=='R') par.model[['z']] <- z
else par.model[['z']] <- do.call('RRdistr', list(subst))
}
if (hasArg('M') && !is.null(subst <- substitute(M))) {
u <- try(is.numeric(M) || is.logical(M) || is.language(M)
|| is.list(M) || is(M, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['M']] <- M
else if (substr(deparse(subst), 1, 1)=='R') par.model[['M']] <- M
else par.model[['M']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMstp',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMstp <- new('RMmodelgenerator',
.Data = RMstp,
type = c('positive definite'),
isotropy = c('symmetric'),
domain = 'kernel',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 10,
vdim = 1
)
RMtbm <- function(phi, fulldim, reduceddim, layers, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('fulldim') && !is.null(subst <- substitute(fulldim))) {
u <- try(is.numeric(fulldim) || is.logical(fulldim) || is.language(fulldim)
|| is.list(fulldim) || is(fulldim, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['fulldim']] <- fulldim
else if (substr(deparse(subst), 1, 1)=='R') par.model[['fulldim']] <- fulldim
else par.model[['fulldim']] <- do.call('RRdistr', list(subst))
}
if (hasArg('reduceddim') && !is.null(subst <- substitute(reduceddim))) {
u <- try(is.numeric(reduceddim) || is.logical(reduceddim) || is.language(reduceddim)
|| is.list(reduceddim) || is(reduceddim, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['reduceddim']] <- reduceddim
else if (substr(deparse(subst), 1, 1)=='R') par.model[['reduceddim']] <- reduceddim
else par.model[['reduceddim']] <- do.call('RRdistr', list(subst))
}
if (hasArg('layers') && !is.null(subst <- substitute(layers))) {
u <- try(is.numeric(layers) || is.logical(layers) || is.language(layers)
|| is.list(layers) || is(layers, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['layers']] <- layers
else if (substr(deparse(subst), 1, 1)=='R') par.model[['layers']] <- layers
else par.model[['layers']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMtbm',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMtbm <- new('RMmodelgenerator',
.Data = RMtbm,
type = c('positive definite'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -1,
vdim = -3
)
RMsum <- function(phi, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMsum',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMsum <- new('RMmodelgenerator',
.Data = RMsum,
type = c('negative definite'),
isotropy = c('symmetric'),
domain = 'kernel',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -3
)
RMvector <- function(phi, a, Dspace, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Dspace') && !is.null(subst <- substitute(Dspace))) {
u <- try(is.numeric(Dspace) || is.logical(Dspace) || is.language(Dspace)
|| is.list(Dspace) || is(Dspace, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['Dspace']] <- Dspace
else if (substr(deparse(subst), 1, 1)=='R') par.model[['Dspace']] <- Dspace
else par.model[['Dspace']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMvector',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMvector <- new('RMmodelgenerator',
.Data = RMvector,
type = c('positive definite', 'positive definite'),
isotropy = c('symmetric', 'symmetric'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = -1
)
RMwave <- function(var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMwave',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMwave <- new('RMmodelgenerator',
.Data = RMwave,
type = c('positive definite'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 3,
vdim = 1
)
RMwhittle <- function(nu, notinvnu, var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('nu') && !is.null(subst <- substitute(nu))) {
u <- try(is.numeric(nu) || is.logical(nu) || is.language(nu)
|| is.list(nu) || is(nu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['nu']] <- nu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['nu']] <- nu
else par.model[['nu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('notinvnu') && !is.null(subst <- substitute(notinvnu))) {
u <- try(is.numeric(notinvnu) || is.logical(notinvnu) || is.language(notinvnu)
|| is.list(notinvnu) || is(notinvnu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['notinvnu']] <- notinvnu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['notinvnu']] <- notinvnu
else par.model[['notinvnu']] <- do.call('RRdistr', list(subst))
}
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMwhittle',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMwhittle <- new('RMmodelgenerator',
.Data = RMwhittle,
type = c('positive definite', 'tail correlation', 'positive definite'),
isotropy = c('isotropic', 'isotropic', 'spherical isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'normal mixture',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMangle <- function(angle, lat.angle, ratio, diag) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('angle') && !is.null(subst <- substitute(angle))) {
u <- try(is.numeric(angle) || is.logical(angle) || is.language(angle)
|| is.list(angle) || is(angle, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['angle']] <- angle
else if (substr(deparse(subst), 1, 1)=='R') par.model[['angle']] <- angle
else par.model[['angle']] <- do.call('RRdistr', list(subst))
}
if (hasArg('lat.angle') && !is.null(subst <- substitute(lat.angle))) {
u <- try(is.numeric(lat.angle) || is.logical(lat.angle) || is.language(lat.angle)
|| is.list(lat.angle) || is(lat.angle, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['lat.angle']] <- lat.angle
else if (substr(deparse(subst), 1, 1)=='R') par.model[['lat.angle']] <- lat.angle
else par.model[['lat.angle']] <- do.call('RRdistr', list(subst))
}
if (hasArg('ratio') && !is.null(subst <- substitute(ratio))) {
u <- try(is.numeric(ratio) || is.logical(ratio) || is.language(ratio)
|| is.list(ratio) || is(ratio, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['ratio']] <- ratio
else if (substr(deparse(subst), 1, 1)=='R') par.model[['ratio']] <- ratio
else par.model[['ratio']] <- do.call('RRdistr', list(subst))
}
if (hasArg('diag') && !is.null(subst <- substitute(diag))) {
u <- try(is.numeric(diag) || is.logical(diag) || is.language(diag)
|| is.list(diag) || is(diag, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['diag']] <- diag
else if (substr(deparse(subst), 1, 1)=='R') par.model[['diag']] <- diag
else par.model[['diag']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMangle',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMangle <- new('RMmodelgenerator',
.Data = RMangle,
type = c('shape function'),
isotropy = c('cartesian system'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -1
)
RMball <- function(var, scale, Aniso, proj) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('var') && !is.null(subst <- substitute(var))) {
u <- try(is.numeric(var) || is.logical(var) || is.language(var)
|| is.list(var) || is(var, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['var']] <- var
else if (substr(deparse(subst), 1, 1)=='R') par.general[['var']] <- var
else par.general[['var']] <- do.call('RRdistr', list(subst))
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.general[['scale']] <- scale
else par.general[['scale']] <- do.call('RRdistr', list(subst))
}
if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) {
u <- try(is.numeric(Aniso) || is.logical(Aniso) || is.language(Aniso)
|| is.list(Aniso) || is(Aniso, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['Aniso']] <- Aniso
else if (substr(deparse(subst), 1, 1)=='R') par.general[['Aniso']] <- Aniso
else par.general[['Aniso']] <- do.call('RRdistr', list(subst))
}
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.general[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.general[['proj']] <- proj
else par.general[['proj']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMball',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMball <- new('RMmodelgenerator',
.Data = RMball,
type = c('shape function'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = FALSE,
monotone = 'monotone',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMeaxxa <- function(E, A) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('E') && !is.null(subst <- substitute(E))) {
u <- try(is.numeric(E) || is.logical(E) || is.language(E)
|| is.list(E) || is(E, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['E']] <- E
else if (substr(deparse(subst), 1, 1)=='R') par.model[['E']] <- E
else par.model[['E']] <- do.call('RRdistr', list(subst))
}
if (hasArg('A') && !is.null(subst <- substitute(A))) {
u <- try(is.numeric(A) || is.logical(A) || is.language(A)
|| is.list(A) || is(A, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['A']] <- A
else if (substr(deparse(subst), 1, 1)=='R') par.model[['A']] <- A
else par.model[['A']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMeaxxa',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMeaxxa <- new('RMmodelgenerator',
.Data = RMeaxxa,
type = c('shape function'),
isotropy = c('cartesian system'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 10,
vdim = -1
)
RMetaxxa <- function(E, A, alpha) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('E') && !is.null(subst <- substitute(E))) {
u <- try(is.numeric(E) || is.logical(E) || is.language(E)
|| is.list(E) || is(E, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['E']] <- E
else if (substr(deparse(subst), 1, 1)=='R') par.model[['E']] <- E
else par.model[['E']] <- do.call('RRdistr', list(subst))
}
if (hasArg('A') && !is.null(subst <- substitute(A))) {
u <- try(is.numeric(A) || is.logical(A) || is.language(A)
|| is.list(A) || is(A, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['A']] <- A
else if (substr(deparse(subst), 1, 1)=='R') par.model[['A']] <- A
else par.model[['A']] <- do.call('RRdistr', list(subst))
}
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else par.model[['alpha']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMetaxxa',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMetaxxa <- new('RMmodelgenerator',
.Data = RMetaxxa,
type = c('shape function'),
isotropy = c('cartesian system'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 10,
vdim = 3
)
RMtrafo <- function(phi, new) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('new') && !is.null(subst <- substitute(new))) {
if (is.character(new)) {par.model[['new']] <- a <- pmatch(new,ISONAMES) - 1
if (any(is.na(a))) stop('unknown string value') } else {
u <- try(is.numeric(new) || is.logical(new) || is.language(new)
|| is.list(new) || is(new, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['new']] <- new
else if (substr(deparse(subst), 1, 1)=='R') par.model[['new']] <- new
else par.model[['new']] <- do.call('RRdistr', list(subst))
}
}
model <- new('RMmodel', call = cl, name = 'RMtrafo',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMtrafo <- new('RMmodelgenerator',
.Data = RMtrafo,
type = c('undefined'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -1
)
RMpolygon <- function(lambda) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('lambda') && !is.null(subst <- substitute(lambda))) {
u <- try(is.numeric(lambda) || is.logical(lambda) || is.language(lambda)
|| is.list(lambda) || is(lambda, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['lambda']] <- lambda
else if (substr(deparse(subst), 1, 1)=='R') par.model[['lambda']] <- lambda
else par.model[['lambda']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMpolygon',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMpolygon <- new('RMmodelgenerator',
.Data = RMpolygon,
type = c('shape function'),
isotropy = c('cartesian system'),
domain = 'single variable',
operator = FALSE,
monotone = 'monotone',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = 2,
vdim = 1
)
RMrational <- function(A, a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('A') && !is.null(subst <- substitute(A))) {
u <- try(is.numeric(A) || is.logical(A) || is.language(A)
|| is.list(A) || is(A, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['A']] <- A
else if (substr(deparse(subst), 1, 1)=='R') par.model[['A']] <- A
else par.model[['A']] <- do.call('RRdistr', list(subst))
}
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMrational',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMrational <- new('RMmodelgenerator',
.Data = RMrational,
type = c('shape function'),
isotropy = c('cartesian system'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RMrotat <- function(speed, phi) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('speed') && !is.null(subst <- substitute(speed))) {
u <- try(is.numeric(speed) || is.logical(speed) || is.language(speed)
|| is.list(speed) || is(speed, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['speed']] <- speed
else if (substr(deparse(subst), 1, 1)=='R') par.model[['speed']] <- speed
else par.model[['speed']] <- do.call('RRdistr', list(subst))
}
if (hasArg('phi') && !is.null(subst <- substitute(phi))) {
u <- try(is.numeric(phi) || is.logical(phi) || is.language(phi)
|| is.list(phi) || is(phi, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['phi']] <- phi
else if (substr(deparse(subst), 1, 1)=='R') par.model[['phi']] <- phi
else par.model[['phi']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMrotat',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMrotat <- new('RMmodelgenerator',
.Data = RMrotat,
type = c('shape function'),
isotropy = c('cartesian system'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 3,
vdim = 1
)
RMrotation <- function(phi) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('phi') && !is.null(subst <- substitute(phi))) {
u <- try(is.numeric(phi) || is.logical(phi) || is.language(phi)
|| is.list(phi) || is(phi, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['phi']] <- phi
else if (substr(deparse(subst), 1, 1)=='R') par.model[['phi']] <- phi
else par.model[['phi']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMrotation',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMrotation <- new('RMmodelgenerator',
.Data = RMrotation,
type = c('shape function'),
isotropy = c('cartesian system'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 3,
vdim = -1
)
RMsign <- function(phi, p) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('p') && !is.null(subst <- substitute(p))) {
u <- try(is.numeric(p) || is.logical(p) || is.language(p)
|| is.list(p) || is(p, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['p']] <- p
else if (substr(deparse(subst), 1, 1)=='R') par.model[['p']] <- p
else par.model[['p']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMsign',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMsign <- new('RMmodelgenerator',
.Data = RMsign,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = TRUE,
monotone = 'not monotone',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RMm2r <- function(phi) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
model <- new('RMmodel', call = cl, name = 'RMm2r',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMm2r <- new('RMmodelgenerator',
.Data = RMm2r,
type = c('shape function'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = TRUE,
monotone = 'submodel dependent monotonicity',
finiterange = NA,
simpleArguments = TRUE,
maxdim = 3,
vdim = 1
)
RMm3b <- function(phi) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
model <- new('RMmodel', call = cl, name = 'RMm3b',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMm3b <- new('RMmodelgenerator',
.Data = RMm3b,
type = c('shape function'),
isotropy = c('isotropic'),
domain = 'single variable',
operator = TRUE,
monotone = 'monotone',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = 3,
vdim = 1
)
RMmps <- function(phi) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
model <- new('RMmodel', call = cl, name = 'RMmps',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMmps <- new('RMmodelgenerator',
.Data = RMmps,
type = c('shape function'),
isotropy = c('cartesian system'),
domain = 'single variable',
operator = TRUE,
monotone = 'monotone',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = 2,
vdim = 1
)
RMtruncsupport <- function(phi, radius) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('radius') && !is.null(subst <- substitute(radius))) {
u <- try(is.numeric(radius) || is.logical(radius) || is.language(radius)
|| is.list(radius) || is(radius, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['radius']] <- radius
else if (substr(deparse(subst), 1, 1)=='R') par.model[['radius']] <- radius
else par.model[['radius']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'RMtruncsupport',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMtruncsupport <- new('RMmodelgenerator',
.Data = RMtruncsupport,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = TRUE,
monotone = 'submodel dependent monotonicity',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = 1
)
RRdeterm <- function(mean) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('mean') && !is.null(subst <- substitute(mean))) {
u <- try(is.numeric(mean) || is.logical(mean) || is.language(mean)
|| is.list(mean) || is(mean, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mean']] <- mean
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mean']] <- mean
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RRdeterm',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RRdeterm <- new('RMmodelgenerator',
.Data = RRdeterm,
type = c('distribution family'),
isotropy = c('cartesian system'),
domain = 'framework dependent',
operator = FALSE,
monotone = 'mismatch in monotonicity',
finiterange = NA,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -3
)
RRgauss <- function(mu, sd, log) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('mu') && !is.null(subst <- substitute(mu))) {
u <- try(is.numeric(mu) || is.logical(mu) || is.language(mu)
|| is.list(mu) || is(mu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mu']] <- mu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mu']] <- mu
else stop('random parameter not allowed')
}
if (hasArg('sd') && !is.null(subst <- substitute(sd))) {
u <- try(is.numeric(sd) || is.logical(sd) || is.language(sd)
|| is.list(sd) || is(sd, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['sd']] <- sd
else if (substr(deparse(subst), 1, 1)=='R') par.model[['sd']] <- sd
else stop('random parameter not allowed')
}
if (hasArg('log') && !is.null(subst <- substitute(log))) {
u <- try(is.numeric(log) || is.logical(log) || is.language(log)
|| is.list(log) || is(log, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['log']] <- log
else if (substr(deparse(subst), 1, 1)=='R') par.model[['log']] <- log
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RRgauss',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RRgauss <- new('RMmodelgenerator',
.Data = RRgauss,
type = c('distribution family'),
isotropy = c('cartesian system'),
domain = 'framework dependent',
operator = FALSE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -1
)
RRloc <- function(phi, mu, scale, pow) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('mu') && !is.null(subst <- substitute(mu))) {
u <- try(is.numeric(mu) || is.logical(mu) || is.language(mu)
|| is.list(mu) || is(mu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mu']] <- mu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mu']] <- mu
else stop('random parameter not allowed')
}
if (hasArg('scale') && !is.null(subst <- substitute(scale))) {
u <- try(is.numeric(scale) || is.logical(scale) || is.language(scale)
|| is.list(scale) || is(scale, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['scale']] <- scale
else if (substr(deparse(subst), 1, 1)=='R') par.model[['scale']] <- scale
else stop('random parameter not allowed')
}
if (hasArg('pow') && !is.null(subst <- substitute(pow))) {
u <- try(is.numeric(pow) || is.logical(pow) || is.language(pow)
|| is.list(pow) || is(pow, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['pow']] <- pow
else if (substr(deparse(subst), 1, 1)=='R') par.model[['pow']] <- pow
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RRloc',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RRloc <- new('RMmodelgenerator',
.Data = RRloc,
type = c('distribution family'),
isotropy = c('cartesian system'),
domain = 'framework dependent',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = -3
)
RRmcmc <- function(phi, mcmc_n, sigma, normed, maxdensity, rand.loc, gibbs) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('mcmc_n') && !is.null(subst <- substitute(mcmc_n))) {
u <- try(is.numeric(mcmc_n) || is.logical(mcmc_n) || is.language(mcmc_n)
|| is.list(mcmc_n) || is(mcmc_n, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mcmc_n']] <- mcmc_n
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mcmc_n']] <- mcmc_n
else stop('random parameter not allowed')
}
if (hasArg('sigma') && !is.null(subst <- substitute(sigma))) {
u <- try(is.numeric(sigma) || is.logical(sigma) || is.language(sigma)
|| is.list(sigma) || is(sigma, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['sigma']] <- sigma
else if (substr(deparse(subst), 1, 1)=='R') par.model[['sigma']] <- sigma
else stop('random parameter not allowed')
}
if (hasArg('normed') && !is.null(subst <- substitute(normed))) {
u <- try(is.numeric(normed) || is.logical(normed) || is.language(normed)
|| is.list(normed) || is(normed, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['normed']] <- normed
else if (substr(deparse(subst), 1, 1)=='R') par.model[['normed']] <- normed
else stop('random parameter not allowed')
}
if (hasArg('maxdensity') && !is.null(subst <- substitute(maxdensity))) {
u <- try(is.numeric(maxdensity) || is.logical(maxdensity) || is.language(maxdensity)
|| is.list(maxdensity) || is(maxdensity, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['maxdensity']] <- maxdensity
else if (substr(deparse(subst), 1, 1)=='R') par.model[['maxdensity']] <- maxdensity
else stop('random parameter not allowed')
}
if (hasArg('rand.loc') && !is.null(subst <- substitute(rand.loc))) {
u <- try(is.numeric(rand.loc) || is.logical(rand.loc) || is.language(rand.loc)
|| is.list(rand.loc) || is(rand.loc, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['rand.loc']] <- rand.loc
else if (substr(deparse(subst), 1, 1)=='R') par.model[['rand.loc']] <- rand.loc
else stop('random parameter not allowed')
}
if (hasArg('gibbs') && !is.null(subst <- substitute(gibbs))) {
u <- try(is.numeric(gibbs) || is.logical(gibbs) || is.language(gibbs)
|| is.list(gibbs) || is(gibbs, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['gibbs']] <- gibbs
else if (substr(deparse(subst), 1, 1)=='R') par.model[['gibbs']] <- gibbs
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RRmcmc',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RRmcmc <- new('RMmodelgenerator',
.Data = RRmcmc,
type = c('distribution family'),
isotropy = c('cartesian system'),
domain = 'framework dependent',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -1
)
RRrectangular <- function(phi, safety, minsteplen, maxsteps, parts, maxit, innermin, outermax, mcmc_n, normed, approx, onesided) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('safety') && !is.null(subst <- substitute(safety))) {
u <- try(is.numeric(safety) || is.logical(safety) || is.language(safety)
|| is.list(safety) || is(safety, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['safety']] <- safety
else if (substr(deparse(subst), 1, 1)=='R') par.model[['safety']] <- safety
else stop('random parameter not allowed')
}
if (hasArg('minsteplen') && !is.null(subst <- substitute(minsteplen))) {
u <- try(is.numeric(minsteplen) || is.logical(minsteplen) || is.language(minsteplen)
|| is.list(minsteplen) || is(minsteplen, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['minsteplen']] <- minsteplen
else if (substr(deparse(subst), 1, 1)=='R') par.model[['minsteplen']] <- minsteplen
else stop('random parameter not allowed')
}
if (hasArg('maxsteps') && !is.null(subst <- substitute(maxsteps))) {
u <- try(is.numeric(maxsteps) || is.logical(maxsteps) || is.language(maxsteps)
|| is.list(maxsteps) || is(maxsteps, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['maxsteps']] <- maxsteps
else if (substr(deparse(subst), 1, 1)=='R') par.model[['maxsteps']] <- maxsteps
else stop('random parameter not allowed')
}
if (hasArg('parts') && !is.null(subst <- substitute(parts))) {
u <- try(is.numeric(parts) || is.logical(parts) || is.language(parts)
|| is.list(parts) || is(parts, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['parts']] <- parts
else if (substr(deparse(subst), 1, 1)=='R') par.model[['parts']] <- parts
else stop('random parameter not allowed')
}
if (hasArg('maxit') && !is.null(subst <- substitute(maxit))) {
u <- try(is.numeric(maxit) || is.logical(maxit) || is.language(maxit)
|| is.list(maxit) || is(maxit, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['maxit']] <- maxit
else if (substr(deparse(subst), 1, 1)=='R') par.model[['maxit']] <- maxit
else stop('random parameter not allowed')
}
if (hasArg('innermin') && !is.null(subst <- substitute(innermin))) {
u <- try(is.numeric(innermin) || is.logical(innermin) || is.language(innermin)
|| is.list(innermin) || is(innermin, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['innermin']] <- innermin
else if (substr(deparse(subst), 1, 1)=='R') par.model[['innermin']] <- innermin
else stop('random parameter not allowed')
}
if (hasArg('outermax') && !is.null(subst <- substitute(outermax))) {
u <- try(is.numeric(outermax) || is.logical(outermax) || is.language(outermax)
|| is.list(outermax) || is(outermax, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['outermax']] <- outermax
else if (substr(deparse(subst), 1, 1)=='R') par.model[['outermax']] <- outermax
else stop('random parameter not allowed')
}
if (hasArg('mcmc_n') && !is.null(subst <- substitute(mcmc_n))) {
u <- try(is.numeric(mcmc_n) || is.logical(mcmc_n) || is.language(mcmc_n)
|| is.list(mcmc_n) || is(mcmc_n, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mcmc_n']] <- mcmc_n
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mcmc_n']] <- mcmc_n
else stop('random parameter not allowed')
}
if (hasArg('normed') && !is.null(subst <- substitute(normed))) {
u <- try(is.numeric(normed) || is.logical(normed) || is.language(normed)
|| is.list(normed) || is(normed, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['normed']] <- normed
else if (substr(deparse(subst), 1, 1)=='R') par.model[['normed']] <- normed
else stop('random parameter not allowed')
}
if (hasArg('approx') && !is.null(subst <- substitute(approx))) {
u <- try(is.numeric(approx) || is.logical(approx) || is.language(approx)
|| is.list(approx) || is(approx, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['approx']] <- approx
else if (substr(deparse(subst), 1, 1)=='R') par.model[['approx']] <- approx
else stop('random parameter not allowed')
}
if (hasArg('onesided') && !is.null(subst <- substitute(onesided))) {
u <- try(is.numeric(onesided) || is.logical(onesided) || is.language(onesided)
|| is.list(onesided) || is(onesided, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['onesided']] <- onesided
else if (substr(deparse(subst), 1, 1)=='R') par.model[['onesided']] <- onesided
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RRrectangular',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RRrectangular <- new('RMmodelgenerator',
.Data = RRrectangular,
type = c('distribution family'),
isotropy = c('cartesian system'),
domain = 'framework dependent',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -1
)
RRspheric <- function(spacedim, balldim, R) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('spacedim') && !is.null(subst <- substitute(spacedim))) {
u <- try(is.numeric(spacedim) || is.logical(spacedim) || is.language(spacedim)
|| is.list(spacedim) || is(spacedim, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['spacedim']] <- spacedim
else if (substr(deparse(subst), 1, 1)=='R') par.model[['spacedim']] <- spacedim
else stop('random parameter not allowed')
}
if (hasArg('balldim') && !is.null(subst <- substitute(balldim))) {
u <- try(is.numeric(balldim) || is.logical(balldim) || is.language(balldim)
|| is.list(balldim) || is(balldim, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['balldim']] <- balldim
else if (substr(deparse(subst), 1, 1)=='R') par.model[['balldim']] <- balldim
else stop('random parameter not allowed')
}
if (hasArg('R') && !is.null(subst <- substitute(R))) {
u <- try(is.numeric(R) || is.logical(R) || is.language(R)
|| is.list(R) || is(R, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['R']] <- R
else if (substr(deparse(subst), 1, 1)=='R') par.model[['R']] <- R
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RRspheric',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RRspheric <- new('RMmodelgenerator',
.Data = RRspheric,
type = c('distribution family'),
isotropy = c('cartesian system'),
domain = 'single variable',
operator = FALSE,
monotone = 'mismatch in monotonicity',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = 1,
vdim = 1
)
RRunif <- function(min, max, normed) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('min') && !is.null(subst <- substitute(min))) {
u <- try(is.numeric(min) || is.logical(min) || is.language(min)
|| is.list(min) || is(min, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['min']] <- min
else if (substr(deparse(subst), 1, 1)=='R') par.model[['min']] <- min
else stop('random parameter not allowed')
}
if (hasArg('max') && !is.null(subst <- substitute(max))) {
u <- try(is.numeric(max) || is.logical(max) || is.language(max)
|| is.list(max) || is(max, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['max']] <- max
else if (substr(deparse(subst), 1, 1)=='R') par.model[['max']] <- max
else stop('random parameter not allowed')
}
if (hasArg('normed') && !is.null(subst <- substitute(normed))) {
u <- try(is.numeric(normed) || is.logical(normed) || is.language(normed)
|| is.list(normed) || is(normed, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['normed']] <- normed
else if (substr(deparse(subst), 1, 1)=='R') par.model[['normed']] <- normed
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RRunif',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RRunif <- new('RMmodelgenerator',
.Data = RRunif,
type = c('distribution family'),
isotropy = c('cartesian system'),
domain = 'framework dependent',
operator = FALSE,
monotone = 'mismatch in monotonicity',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -1
)
RMmppplus <- function(C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, p) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(C0)) submodels[['C0']] <- C0
if (hasArg(C1)) submodels[['C1']] <- C1
if (hasArg(C2)) submodels[['C2']] <- C2
if (hasArg(C3)) submodels[['C3']] <- C3
if (hasArg(C4)) submodels[['C4']] <- C4
if (hasArg(C5)) submodels[['C5']] <- C5
if (hasArg(C6)) submodels[['C6']] <- C6
if (hasArg(C7)) submodels[['C7']] <- C7
if (hasArg(C8)) submodels[['C8']] <- C8
if (hasArg(C9)) submodels[['C9']] <- C9
if (hasArg('p') && !is.null(subst <- substitute(p))) {
u <- try(is.numeric(p) || is.logical(p) || is.language(p)
|| is.list(p) || is(p, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['p']] <- p
else if (substr(deparse(subst), 1, 1)=='R') par.model[['p']] <- p
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RMmppplus',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RMmppplus <- new('RMmodelgenerator',
.Data = RMmppplus,
type = c('point-shape function'),
isotropy = c('parameter dependent'),
domain = 'framework dependent',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = NA,
simpleArguments = TRUE,
maxdim = -3,
vdim = -3
)
RPaverage <- function(phi, shape, intensity, method) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg(shape)) submodels[['shape']] <- shape
if (hasArg('intensity') && !is.null(subst <- substitute(intensity))) {
u <- try(is.numeric(intensity) || is.logical(intensity) || is.language(intensity)
|| is.list(intensity) || is(intensity, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['intensity']] <- intensity
else if (substr(deparse(subst), 1, 1)=='R') par.model[['intensity']] <- intensity
else stop('random parameter not allowed')
}
if (hasArg('method') && !is.null(subst <- substitute(method))) {
u <- try(is.numeric(method) || is.logical(method) || is.language(method)
|| is.list(method) || is(method, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['method']] <- method
else if (substr(deparse(subst), 1, 1)=='R') par.model[['method']] <- method
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPaverage',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPaverage <- new('RMmodelgenerator',
.Data = RPaverage,
type = c('method for Gauss process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 4,
vdim = 1
)
RPcirculant <- function(phi, force, mmin, strategy, maxGB, maxmem, tolIm, tolRe, trials, useprimes, dependent, approx_step, approx_maxgrid) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('force') && !is.null(subst <- substitute(force))) {
u <- try(is.numeric(force) || is.logical(force) || is.language(force)
|| is.list(force) || is(force, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['force']] <- force
else if (substr(deparse(subst), 1, 1)=='R') par.model[['force']] <- force
else stop('random parameter not allowed')
}
if (hasArg('mmin') && !is.null(subst <- substitute(mmin))) {
u <- try(is.numeric(mmin) || is.logical(mmin) || is.language(mmin)
|| is.list(mmin) || is(mmin, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mmin']] <- mmin
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mmin']] <- mmin
else stop('random parameter not allowed')
}
if (hasArg('strategy') && !is.null(subst <- substitute(strategy))) {
u <- try(is.numeric(strategy) || is.logical(strategy) || is.language(strategy)
|| is.list(strategy) || is(strategy, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['strategy']] <- strategy
else if (substr(deparse(subst), 1, 1)=='R') par.model[['strategy']] <- strategy
else stop('random parameter not allowed')
}
if (hasArg('maxGB') && !is.null(subst <- substitute(maxGB))) {
u <- try(is.numeric(maxGB) || is.logical(maxGB) || is.language(maxGB)
|| is.list(maxGB) || is(maxGB, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['maxGB']] <- maxGB
else if (substr(deparse(subst), 1, 1)=='R') par.model[['maxGB']] <- maxGB
else stop('random parameter not allowed')
}
if (hasArg('maxmem') && !is.null(subst <- substitute(maxmem))) {
u <- try(is.numeric(maxmem) || is.logical(maxmem) || is.language(maxmem)
|| is.list(maxmem) || is(maxmem, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['maxmem']] <- maxmem
else if (substr(deparse(subst), 1, 1)=='R') par.model[['maxmem']] <- maxmem
else stop('random parameter not allowed')
}
if (hasArg('tolIm') && !is.null(subst <- substitute(tolIm))) {
u <- try(is.numeric(tolIm) || is.logical(tolIm) || is.language(tolIm)
|| is.list(tolIm) || is(tolIm, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['tolIm']] <- tolIm
else if (substr(deparse(subst), 1, 1)=='R') par.model[['tolIm']] <- tolIm
else stop('random parameter not allowed')
}
if (hasArg('tolRe') && !is.null(subst <- substitute(tolRe))) {
u <- try(is.numeric(tolRe) || is.logical(tolRe) || is.language(tolRe)
|| is.list(tolRe) || is(tolRe, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['tolRe']] <- tolRe
else if (substr(deparse(subst), 1, 1)=='R') par.model[['tolRe']] <- tolRe
else stop('random parameter not allowed')
}
if (hasArg('trials') && !is.null(subst <- substitute(trials))) {
u <- try(is.numeric(trials) || is.logical(trials) || is.language(trials)
|| is.list(trials) || is(trials, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['trials']] <- trials
else if (substr(deparse(subst), 1, 1)=='R') par.model[['trials']] <- trials
else stop('random parameter not allowed')
}
if (hasArg('useprimes') && !is.null(subst <- substitute(useprimes))) {
u <- try(is.numeric(useprimes) || is.logical(useprimes) || is.language(useprimes)
|| is.list(useprimes) || is(useprimes, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['useprimes']] <- useprimes
else if (substr(deparse(subst), 1, 1)=='R') par.model[['useprimes']] <- useprimes
else stop('random parameter not allowed')
}
if (hasArg('dependent') && !is.null(subst <- substitute(dependent))) {
u <- try(is.numeric(dependent) || is.logical(dependent) || is.language(dependent)
|| is.list(dependent) || is(dependent, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['dependent']] <- dependent
else if (substr(deparse(subst), 1, 1)=='R') par.model[['dependent']] <- dependent
else stop('random parameter not allowed')
}
if (hasArg('approx_step') && !is.null(subst <- substitute(approx_step))) {
u <- try(is.numeric(approx_step) || is.logical(approx_step) || is.language(approx_step)
|| is.list(approx_step) || is(approx_step, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['approx_step']] <- approx_step
else if (substr(deparse(subst), 1, 1)=='R') par.model[['approx_step']] <- approx_step
else stop('random parameter not allowed')
}
if (hasArg('approx_maxgrid') && !is.null(subst <- substitute(approx_maxgrid))) {
u <- try(is.numeric(approx_maxgrid) || is.logical(approx_maxgrid) || is.language(approx_maxgrid)
|| is.list(approx_maxgrid) || is(approx_maxgrid, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['approx_maxgrid']] <- approx_maxgrid
else if (substr(deparse(subst), 1, 1)=='R') par.model[['approx_maxgrid']] <- approx_maxgrid
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPcirculant',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPcirculant <- new('RMmodelgenerator',
.Data = RPcirculant,
type = c('method for Gauss process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 13,
vdim = -3
)
RPcutoff <- function(phi, force, mmin, strategy, maxGB, maxmem, tolIm, tolRe, trials, useprimes, dependent, approx_step, approx_maxgrid, diameter, a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('force') && !is.null(subst <- substitute(force))) {
u <- try(is.numeric(force) || is.logical(force) || is.language(force)
|| is.list(force) || is(force, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['force']] <- force
else if (substr(deparse(subst), 1, 1)=='R') par.model[['force']] <- force
else stop('random parameter not allowed')
}
if (hasArg('mmin') && !is.null(subst <- substitute(mmin))) {
u <- try(is.numeric(mmin) || is.logical(mmin) || is.language(mmin)
|| is.list(mmin) || is(mmin, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mmin']] <- mmin
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mmin']] <- mmin
else stop('random parameter not allowed')
}
if (hasArg('strategy') && !is.null(subst <- substitute(strategy))) {
u <- try(is.numeric(strategy) || is.logical(strategy) || is.language(strategy)
|| is.list(strategy) || is(strategy, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['strategy']] <- strategy
else if (substr(deparse(subst), 1, 1)=='R') par.model[['strategy']] <- strategy
else stop('random parameter not allowed')
}
if (hasArg('maxGB') && !is.null(subst <- substitute(maxGB))) {
u <- try(is.numeric(maxGB) || is.logical(maxGB) || is.language(maxGB)
|| is.list(maxGB) || is(maxGB, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['maxGB']] <- maxGB
else if (substr(deparse(subst), 1, 1)=='R') par.model[['maxGB']] <- maxGB
else stop('random parameter not allowed')
}
if (hasArg('maxmem') && !is.null(subst <- substitute(maxmem))) {
u <- try(is.numeric(maxmem) || is.logical(maxmem) || is.language(maxmem)
|| is.list(maxmem) || is(maxmem, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['maxmem']] <- maxmem
else if (substr(deparse(subst), 1, 1)=='R') par.model[['maxmem']] <- maxmem
else stop('random parameter not allowed')
}
if (hasArg('tolIm') && !is.null(subst <- substitute(tolIm))) {
u <- try(is.numeric(tolIm) || is.logical(tolIm) || is.language(tolIm)
|| is.list(tolIm) || is(tolIm, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['tolIm']] <- tolIm
else if (substr(deparse(subst), 1, 1)=='R') par.model[['tolIm']] <- tolIm
else stop('random parameter not allowed')
}
if (hasArg('tolRe') && !is.null(subst <- substitute(tolRe))) {
u <- try(is.numeric(tolRe) || is.logical(tolRe) || is.language(tolRe)
|| is.list(tolRe) || is(tolRe, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['tolRe']] <- tolRe
else if (substr(deparse(subst), 1, 1)=='R') par.model[['tolRe']] <- tolRe
else stop('random parameter not allowed')
}
if (hasArg('trials') && !is.null(subst <- substitute(trials))) {
u <- try(is.numeric(trials) || is.logical(trials) || is.language(trials)
|| is.list(trials) || is(trials, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['trials']] <- trials
else if (substr(deparse(subst), 1, 1)=='R') par.model[['trials']] <- trials
else stop('random parameter not allowed')
}
if (hasArg('useprimes') && !is.null(subst <- substitute(useprimes))) {
u <- try(is.numeric(useprimes) || is.logical(useprimes) || is.language(useprimes)
|| is.list(useprimes) || is(useprimes, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['useprimes']] <- useprimes
else if (substr(deparse(subst), 1, 1)=='R') par.model[['useprimes']] <- useprimes
else stop('random parameter not allowed')
}
if (hasArg('dependent') && !is.null(subst <- substitute(dependent))) {
u <- try(is.numeric(dependent) || is.logical(dependent) || is.language(dependent)
|| is.list(dependent) || is(dependent, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['dependent']] <- dependent
else if (substr(deparse(subst), 1, 1)=='R') par.model[['dependent']] <- dependent
else stop('random parameter not allowed')
}
if (hasArg('approx_step') && !is.null(subst <- substitute(approx_step))) {
u <- try(is.numeric(approx_step) || is.logical(approx_step) || is.language(approx_step)
|| is.list(approx_step) || is(approx_step, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['approx_step']] <- approx_step
else if (substr(deparse(subst), 1, 1)=='R') par.model[['approx_step']] <- approx_step
else stop('random parameter not allowed')
}
if (hasArg('approx_maxgrid') && !is.null(subst <- substitute(approx_maxgrid))) {
u <- try(is.numeric(approx_maxgrid) || is.logical(approx_maxgrid) || is.language(approx_maxgrid)
|| is.list(approx_maxgrid) || is(approx_maxgrid, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['approx_maxgrid']] <- approx_maxgrid
else if (substr(deparse(subst), 1, 1)=='R') par.model[['approx_maxgrid']] <- approx_maxgrid
else stop('random parameter not allowed')
}
if (hasArg('diameter') && !is.null(subst <- substitute(diameter))) {
u <- try(is.numeric(diameter) || is.logical(diameter) || is.language(diameter)
|| is.list(diameter) || is(diameter, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['diameter']] <- diameter
else if (substr(deparse(subst), 1, 1)=='R') par.model[['diameter']] <- diameter
else stop('random parameter not allowed')
}
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPcutoff',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPcutoff <- new('RMmodelgenerator',
.Data = RPcutoff,
type = c('method for Gauss process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 13,
vdim = 1
)
RPintrinsic <- function(phi, force, mmin, strategy, maxGB, maxmem, tolIm, tolRe, trials, useprimes, dependent, approx_step, approx_maxgrid, diameter, rawR) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('force') && !is.null(subst <- substitute(force))) {
u <- try(is.numeric(force) || is.logical(force) || is.language(force)
|| is.list(force) || is(force, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['force']] <- force
else if (substr(deparse(subst), 1, 1)=='R') par.model[['force']] <- force
else stop('random parameter not allowed')
}
if (hasArg('mmin') && !is.null(subst <- substitute(mmin))) {
u <- try(is.numeric(mmin) || is.logical(mmin) || is.language(mmin)
|| is.list(mmin) || is(mmin, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mmin']] <- mmin
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mmin']] <- mmin
else stop('random parameter not allowed')
}
if (hasArg('strategy') && !is.null(subst <- substitute(strategy))) {
u <- try(is.numeric(strategy) || is.logical(strategy) || is.language(strategy)
|| is.list(strategy) || is(strategy, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['strategy']] <- strategy
else if (substr(deparse(subst), 1, 1)=='R') par.model[['strategy']] <- strategy
else stop('random parameter not allowed')
}
if (hasArg('maxGB') && !is.null(subst <- substitute(maxGB))) {
u <- try(is.numeric(maxGB) || is.logical(maxGB) || is.language(maxGB)
|| is.list(maxGB) || is(maxGB, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['maxGB']] <- maxGB
else if (substr(deparse(subst), 1, 1)=='R') par.model[['maxGB']] <- maxGB
else stop('random parameter not allowed')
}
if (hasArg('maxmem') && !is.null(subst <- substitute(maxmem))) {
u <- try(is.numeric(maxmem) || is.logical(maxmem) || is.language(maxmem)
|| is.list(maxmem) || is(maxmem, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['maxmem']] <- maxmem
else if (substr(deparse(subst), 1, 1)=='R') par.model[['maxmem']] <- maxmem
else stop('random parameter not allowed')
}
if (hasArg('tolIm') && !is.null(subst <- substitute(tolIm))) {
u <- try(is.numeric(tolIm) || is.logical(tolIm) || is.language(tolIm)
|| is.list(tolIm) || is(tolIm, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['tolIm']] <- tolIm
else if (substr(deparse(subst), 1, 1)=='R') par.model[['tolIm']] <- tolIm
else stop('random parameter not allowed')
}
if (hasArg('tolRe') && !is.null(subst <- substitute(tolRe))) {
u <- try(is.numeric(tolRe) || is.logical(tolRe) || is.language(tolRe)
|| is.list(tolRe) || is(tolRe, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['tolRe']] <- tolRe
else if (substr(deparse(subst), 1, 1)=='R') par.model[['tolRe']] <- tolRe
else stop('random parameter not allowed')
}
if (hasArg('trials') && !is.null(subst <- substitute(trials))) {
u <- try(is.numeric(trials) || is.logical(trials) || is.language(trials)
|| is.list(trials) || is(trials, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['trials']] <- trials
else if (substr(deparse(subst), 1, 1)=='R') par.model[['trials']] <- trials
else stop('random parameter not allowed')
}
if (hasArg('useprimes') && !is.null(subst <- substitute(useprimes))) {
u <- try(is.numeric(useprimes) || is.logical(useprimes) || is.language(useprimes)
|| is.list(useprimes) || is(useprimes, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['useprimes']] <- useprimes
else if (substr(deparse(subst), 1, 1)=='R') par.model[['useprimes']] <- useprimes
else stop('random parameter not allowed')
}
if (hasArg('dependent') && !is.null(subst <- substitute(dependent))) {
u <- try(is.numeric(dependent) || is.logical(dependent) || is.language(dependent)
|| is.list(dependent) || is(dependent, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['dependent']] <- dependent
else if (substr(deparse(subst), 1, 1)=='R') par.model[['dependent']] <- dependent
else stop('random parameter not allowed')
}
if (hasArg('approx_step') && !is.null(subst <- substitute(approx_step))) {
u <- try(is.numeric(approx_step) || is.logical(approx_step) || is.language(approx_step)
|| is.list(approx_step) || is(approx_step, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['approx_step']] <- approx_step
else if (substr(deparse(subst), 1, 1)=='R') par.model[['approx_step']] <- approx_step
else stop('random parameter not allowed')
}
if (hasArg('approx_maxgrid') && !is.null(subst <- substitute(approx_maxgrid))) {
u <- try(is.numeric(approx_maxgrid) || is.logical(approx_maxgrid) || is.language(approx_maxgrid)
|| is.list(approx_maxgrid) || is(approx_maxgrid, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['approx_maxgrid']] <- approx_maxgrid
else if (substr(deparse(subst), 1, 1)=='R') par.model[['approx_maxgrid']] <- approx_maxgrid
else stop('random parameter not allowed')
}
if (hasArg('diameter') && !is.null(subst <- substitute(diameter))) {
u <- try(is.numeric(diameter) || is.logical(diameter) || is.language(diameter)
|| is.list(diameter) || is(diameter, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['diameter']] <- diameter
else if (substr(deparse(subst), 1, 1)=='R') par.model[['diameter']] <- diameter
else stop('random parameter not allowed')
}
if (hasArg('rawR') && !is.null(subst <- substitute(rawR))) {
u <- try(is.numeric(rawR) || is.logical(rawR) || is.language(rawR)
|| is.list(rawR) || is(rawR, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['rawR']] <- rawR
else if (substr(deparse(subst), 1, 1)=='R') par.model[['rawR']] <- rawR
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPintrinsic',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPintrinsic <- new('RMmodelgenerator',
.Data = RPintrinsic,
type = c('method for Gauss process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 13,
vdim = 1
)
RPdirect <- function(phi, root_method, svdtolerance, max_variab) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('root_method') && !is.null(subst <- substitute(root_method))) {
u <- try(is.numeric(root_method) || is.logical(root_method) || is.language(root_method)
|| is.list(root_method) || is(root_method, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['root_method']] <- root_method
else if (substr(deparse(subst), 1, 1)=='R') par.model[['root_method']] <- root_method
else stop('random parameter not allowed')
}
if (hasArg('svdtolerance') && !is.null(subst <- substitute(svdtolerance))) {
u <- try(is.numeric(svdtolerance) || is.logical(svdtolerance) || is.language(svdtolerance)
|| is.list(svdtolerance) || is(svdtolerance, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['svdtolerance']] <- svdtolerance
else if (substr(deparse(subst), 1, 1)=='R') par.model[['svdtolerance']] <- svdtolerance
else stop('random parameter not allowed')
}
if (hasArg('max_variab') && !is.null(subst <- substitute(max_variab))) {
u <- try(is.numeric(max_variab) || is.logical(max_variab) || is.language(max_variab)
|| is.list(max_variab) || is(max_variab, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['max_variab']] <- max_variab
else if (substr(deparse(subst), 1, 1)=='R') par.model[['max_variab']] <- max_variab
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPdirect',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPdirect <- new('RMmodelgenerator',
.Data = RPdirect,
type = c('method for Gauss process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -3
)
RPhyperplane <- function(phi, superpos, maxlines, mar_distr, mar_param, additive) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('superpos') && !is.null(subst <- substitute(superpos))) {
u <- try(is.numeric(superpos) || is.logical(superpos) || is.language(superpos)
|| is.list(superpos) || is(superpos, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['superpos']] <- superpos
else if (substr(deparse(subst), 1, 1)=='R') par.model[['superpos']] <- superpos
else stop('random parameter not allowed')
}
if (hasArg('maxlines') && !is.null(subst <- substitute(maxlines))) {
u <- try(is.numeric(maxlines) || is.logical(maxlines) || is.language(maxlines)
|| is.list(maxlines) || is(maxlines, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['maxlines']] <- maxlines
else if (substr(deparse(subst), 1, 1)=='R') par.model[['maxlines']] <- maxlines
else stop('random parameter not allowed')
}
if (hasArg('mar_distr') && !is.null(subst <- substitute(mar_distr))) {
u <- try(is.numeric(mar_distr) || is.logical(mar_distr) || is.language(mar_distr)
|| is.list(mar_distr) || is(mar_distr, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mar_distr']] <- mar_distr
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mar_distr']] <- mar_distr
else stop('random parameter not allowed')
}
if (hasArg('mar_param') && !is.null(subst <- substitute(mar_param))) {
u <- try(is.numeric(mar_param) || is.logical(mar_param) || is.language(mar_param)
|| is.list(mar_param) || is(mar_param, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mar_param']] <- mar_param
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mar_param']] <- mar_param
else stop('random parameter not allowed')
}
if (hasArg('additive') && !is.null(subst <- substitute(additive))) {
u <- try(is.numeric(additive) || is.logical(additive) || is.language(additive)
|| is.list(additive) || is(additive, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['additive']] <- additive
else if (substr(deparse(subst), 1, 1)=='R') par.model[['additive']] <- additive
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPhyperplane',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPhyperplane <- new('RMmodelgenerator',
.Data = RPhyperplane,
type = c('method for Gauss process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 2,
vdim = 1
)
RPnugget <- function(phi, tol, vdim) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('tol') && !is.null(subst <- substitute(tol))) {
u <- try(is.numeric(tol) || is.logical(tol) || is.language(tol)
|| is.list(tol) || is(tol, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['tol']] <- tol
else if (substr(deparse(subst), 1, 1)=='R') par.model[['tol']] <- tol
else stop('random parameter not allowed')
}
if (hasArg('vdim') && !is.null(subst <- substitute(vdim))) {
u <- try(is.numeric(vdim) || is.logical(vdim) || is.language(vdim)
|| is.list(vdim) || is(vdim, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['vdim']] <- vdim
else if (substr(deparse(subst), 1, 1)=='R') par.model[['vdim']] <- vdim
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPnugget',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPnugget <- new('RMmodelgenerator',
.Data = RPnugget,
type = c('method for Gauss process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = TRUE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -2
)
RPcoins <- function(phi, shape, intensity, method) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg(shape)) submodels[['shape']] <- shape
if (hasArg('intensity') && !is.null(subst <- substitute(intensity))) {
u <- try(is.numeric(intensity) || is.logical(intensity) || is.language(intensity)
|| is.list(intensity) || is(intensity, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['intensity']] <- intensity
else if (substr(deparse(subst), 1, 1)=='R') par.model[['intensity']] <- intensity
else stop('random parameter not allowed')
}
if (hasArg('method') && !is.null(subst <- substitute(method))) {
u <- try(is.numeric(method) || is.logical(method) || is.language(method)
|| is.list(method) || is(method, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['method']] <- method
else if (substr(deparse(subst), 1, 1)=='R') par.model[['method']] <- method
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPcoins',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPcoins <- new('RMmodelgenerator',
.Data = RPcoins,
type = c('method for Gauss process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 4,
vdim = 1
)
RPsequential <- function(phi, max_variables, back_steps, initial) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('max_variables') && !is.null(subst <- substitute(max_variables))) {
u <- try(is.numeric(max_variables) || is.logical(max_variables) || is.language(max_variables)
|| is.list(max_variables) || is(max_variables, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['max_variables']] <- max_variables
else if (substr(deparse(subst), 1, 1)=='R') par.model[['max_variables']] <- max_variables
else stop('random parameter not allowed')
}
if (hasArg('back_steps') && !is.null(subst <- substitute(back_steps))) {
u <- try(is.numeric(back_steps) || is.logical(back_steps) || is.language(back_steps)
|| is.list(back_steps) || is(back_steps, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['back_steps']] <- back_steps
else if (substr(deparse(subst), 1, 1)=='R') par.model[['back_steps']] <- back_steps
else stop('random parameter not allowed')
}
if (hasArg('initial') && !is.null(subst <- substitute(initial))) {
u <- try(is.numeric(initial) || is.logical(initial) || is.language(initial)
|| is.list(initial) || is(initial, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['initial']] <- initial
else if (substr(deparse(subst), 1, 1)=='R') par.model[['initial']] <- initial
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPsequential',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPsequential <- new('RMmodelgenerator',
.Data = RPsequential,
type = c('method for Gauss process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
RPspectral <- function(phi, sp_lines, sp_grid, prop_factor, sigma) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('sp_lines') && !is.null(subst <- substitute(sp_lines))) {
u <- try(is.numeric(sp_lines) || is.logical(sp_lines) || is.language(sp_lines)
|| is.list(sp_lines) || is(sp_lines, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['sp_lines']] <- sp_lines
else if (substr(deparse(subst), 1, 1)=='R') par.model[['sp_lines']] <- sp_lines
else stop('random parameter not allowed')
}
if (hasArg('sp_grid') && !is.null(subst <- substitute(sp_grid))) {
u <- try(is.numeric(sp_grid) || is.logical(sp_grid) || is.language(sp_grid)
|| is.list(sp_grid) || is(sp_grid, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['sp_grid']] <- sp_grid
else if (substr(deparse(subst), 1, 1)=='R') par.model[['sp_grid']] <- sp_grid
else stop('random parameter not allowed')
}
if (hasArg('prop_factor') && !is.null(subst <- substitute(prop_factor))) {
u <- try(is.numeric(prop_factor) || is.logical(prop_factor) || is.language(prop_factor)
|| is.list(prop_factor) || is(prop_factor, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['prop_factor']] <- prop_factor
else if (substr(deparse(subst), 1, 1)=='R') par.model[['prop_factor']] <- prop_factor
else stop('random parameter not allowed')
}
if (hasArg('sigma') && !is.null(subst <- substitute(sigma))) {
u <- try(is.numeric(sigma) || is.logical(sigma) || is.language(sigma)
|| is.list(sigma) || is(sigma, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['sigma']] <- sigma
else if (substr(deparse(subst), 1, 1)=='R') par.model[['sigma']] <- sigma
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPspectral',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPspectral <- new('RMmodelgenerator',
.Data = RPspectral,
type = c('method for Gauss process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 4,
vdim = 1
)
RPspecific <- function(phi) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
model <- new('RMmodel', call = cl, name = 'RPspecific',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPspecific <- new('RMmodelgenerator',
.Data = RPspecific,
type = c('method for Gauss process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 4,
vdim = -3
)
RPtbm <- function(phi, fulldim, reduceddim, layers, lines, linessimufactor, linesimustep, center, points) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('fulldim') && !is.null(subst <- substitute(fulldim))) {
u <- try(is.numeric(fulldim) || is.logical(fulldim) || is.language(fulldim)
|| is.list(fulldim) || is(fulldim, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['fulldim']] <- fulldim
else if (substr(deparse(subst), 1, 1)=='R') par.model[['fulldim']] <- fulldim
else stop('random parameter not allowed')
}
if (hasArg('reduceddim') && !is.null(subst <- substitute(reduceddim))) {
u <- try(is.numeric(reduceddim) || is.logical(reduceddim) || is.language(reduceddim)
|| is.list(reduceddim) || is(reduceddim, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['reduceddim']] <- reduceddim
else if (substr(deparse(subst), 1, 1)=='R') par.model[['reduceddim']] <- reduceddim
else stop('random parameter not allowed')
}
if (hasArg('layers') && !is.null(subst <- substitute(layers))) {
u <- try(is.numeric(layers) || is.logical(layers) || is.language(layers)
|| is.list(layers) || is(layers, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['layers']] <- layers
else if (substr(deparse(subst), 1, 1)=='R') par.model[['layers']] <- layers
else stop('random parameter not allowed')
}
if (hasArg('lines') && !is.null(subst <- substitute(lines))) {
u <- try(is.numeric(lines) || is.logical(lines) || is.language(lines)
|| is.list(lines) || is(lines, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['lines']] <- lines
else if (substr(deparse(subst), 1, 1)=='R') par.model[['lines']] <- lines
else stop('random parameter not allowed')
}
if (hasArg('linessimufactor') && !is.null(subst <- substitute(linessimufactor))) {
u <- try(is.numeric(linessimufactor) || is.logical(linessimufactor) || is.language(linessimufactor)
|| is.list(linessimufactor) || is(linessimufactor, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['linessimufactor']] <- linessimufactor
else if (substr(deparse(subst), 1, 1)=='R') par.model[['linessimufactor']] <- linessimufactor
else stop('random parameter not allowed')
}
if (hasArg('linesimustep') && !is.null(subst <- substitute(linesimustep))) {
u <- try(is.numeric(linesimustep) || is.logical(linesimustep) || is.language(linesimustep)
|| is.list(linesimustep) || is(linesimustep, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['linesimustep']] <- linesimustep
else if (substr(deparse(subst), 1, 1)=='R') par.model[['linesimustep']] <- linesimustep
else stop('random parameter not allowed')
}
if (hasArg('center') && !is.null(subst <- substitute(center))) {
u <- try(is.numeric(center) || is.logical(center) || is.language(center)
|| is.list(center) || is(center, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['center']] <- center
else if (substr(deparse(subst), 1, 1)=='R') par.model[['center']] <- center
else stop('random parameter not allowed')
}
if (hasArg('points') && !is.null(subst <- substitute(points))) {
u <- try(is.numeric(points) || is.logical(points) || is.language(points)
|| is.list(points) || is(points, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['points']] <- points
else if (substr(deparse(subst), 1, 1)=='R') par.model[['points']] <- points
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPtbm',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPtbm <- new('RMmodelgenerator',
.Data = RPtbm,
type = c('method for Gauss process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -3,
vdim = -1
)
RPtrend <- function(phi) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
model <- new('RMmodel', call = cl, name = 'RPtrend',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPtrend <- new('RMmodelgenerator',
.Data = RPtrend,
type = c('method for Gauss process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = -3
)
RPbrorig <- function(phi, tcf, xi, mu, s) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg(tcf)) submodels[['tcf']] <- tcf
if (hasArg('xi') && !is.null(subst <- substitute(xi))) {
u <- try(is.numeric(xi) || is.logical(xi) || is.language(xi)
|| is.list(xi) || is(xi, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['xi']] <- xi
else if (substr(deparse(subst), 1, 1)=='R') par.model[['xi']] <- xi
else stop('random parameter not allowed')
}
if (hasArg('mu') && !is.null(subst <- substitute(mu))) {
u <- try(is.numeric(mu) || is.logical(mu) || is.language(mu)
|| is.list(mu) || is(mu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mu']] <- mu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mu']] <- mu
else stop('random parameter not allowed')
}
if (hasArg('s') && !is.null(subst <- substitute(s))) {
u <- try(is.numeric(s) || is.logical(s) || is.language(s)
|| is.list(s) || is(s, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['s']] <- s
else if (substr(deparse(subst), 1, 1)=='R') par.model[['s']] <- s
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPbrorig',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPbrorig <- new('RMmodelgenerator',
.Data = RPbrorig,
type = c('method for Brown-Resnick process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 4,
vdim = -3
)
RPbrmixed <- function(phi, tcf, xi, mu, s, meshsize, vertnumber, optim_mixed, optim_mixed_tol, optim_mixed_maxpo, lambda, areamat, variobound) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg(tcf)) submodels[['tcf']] <- tcf
if (hasArg('xi') && !is.null(subst <- substitute(xi))) {
u <- try(is.numeric(xi) || is.logical(xi) || is.language(xi)
|| is.list(xi) || is(xi, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['xi']] <- xi
else if (substr(deparse(subst), 1, 1)=='R') par.model[['xi']] <- xi
else stop('random parameter not allowed')
}
if (hasArg('mu') && !is.null(subst <- substitute(mu))) {
u <- try(is.numeric(mu) || is.logical(mu) || is.language(mu)
|| is.list(mu) || is(mu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mu']] <- mu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mu']] <- mu
else stop('random parameter not allowed')
}
if (hasArg('s') && !is.null(subst <- substitute(s))) {
u <- try(is.numeric(s) || is.logical(s) || is.language(s)
|| is.list(s) || is(s, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['s']] <- s
else if (substr(deparse(subst), 1, 1)=='R') par.model[['s']] <- s
else stop('random parameter not allowed')
}
if (hasArg('meshsize') && !is.null(subst <- substitute(meshsize))) {
u <- try(is.numeric(meshsize) || is.logical(meshsize) || is.language(meshsize)
|| is.list(meshsize) || is(meshsize, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['meshsize']] <- meshsize
else if (substr(deparse(subst), 1, 1)=='R') par.model[['meshsize']] <- meshsize
else stop('random parameter not allowed')
}
if (hasArg('vertnumber') && !is.null(subst <- substitute(vertnumber))) {
u <- try(is.numeric(vertnumber) || is.logical(vertnumber) || is.language(vertnumber)
|| is.list(vertnumber) || is(vertnumber, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['vertnumber']] <- vertnumber
else if (substr(deparse(subst), 1, 1)=='R') par.model[['vertnumber']] <- vertnumber
else stop('random parameter not allowed')
}
if (hasArg('optim_mixed') && !is.null(subst <- substitute(optim_mixed))) {
u <- try(is.numeric(optim_mixed) || is.logical(optim_mixed) || is.language(optim_mixed)
|| is.list(optim_mixed) || is(optim_mixed, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['optim_mixed']] <- optim_mixed
else if (substr(deparse(subst), 1, 1)=='R') par.model[['optim_mixed']] <- optim_mixed
else stop('random parameter not allowed')
}
if (hasArg('optim_mixed_tol') && !is.null(subst <- substitute(optim_mixed_tol))) {
u <- try(is.numeric(optim_mixed_tol) || is.logical(optim_mixed_tol) || is.language(optim_mixed_tol)
|| is.list(optim_mixed_tol) || is(optim_mixed_tol, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['optim_mixed_tol']] <- optim_mixed_tol
else if (substr(deparse(subst), 1, 1)=='R') par.model[['optim_mixed_tol']] <- optim_mixed_tol
else stop('random parameter not allowed')
}
if (hasArg('optim_mixed_maxpo') && !is.null(subst <- substitute(optim_mixed_maxpo))) {
u <- try(is.numeric(optim_mixed_maxpo) || is.logical(optim_mixed_maxpo) || is.language(optim_mixed_maxpo)
|| is.list(optim_mixed_maxpo) || is(optim_mixed_maxpo, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['optim_mixed_maxpo']] <- optim_mixed_maxpo
else if (substr(deparse(subst), 1, 1)=='R') par.model[['optim_mixed_maxpo']] <- optim_mixed_maxpo
else stop('random parameter not allowed')
}
if (hasArg('lambda') && !is.null(subst <- substitute(lambda))) {
u <- try(is.numeric(lambda) || is.logical(lambda) || is.language(lambda)
|| is.list(lambda) || is(lambda, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['lambda']] <- lambda
else if (substr(deparse(subst), 1, 1)=='R') par.model[['lambda']] <- lambda
else stop('random parameter not allowed')
}
if (hasArg('areamat') && !is.null(subst <- substitute(areamat))) {
u <- try(is.numeric(areamat) || is.logical(areamat) || is.language(areamat)
|| is.list(areamat) || is(areamat, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['areamat']] <- areamat
else if (substr(deparse(subst), 1, 1)=='R') par.model[['areamat']] <- areamat
else stop('random parameter not allowed')
}
if (hasArg('variobound') && !is.null(subst <- substitute(variobound))) {
u <- try(is.numeric(variobound) || is.logical(variobound) || is.language(variobound)
|| is.list(variobound) || is(variobound, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['variobound']] <- variobound
else if (substr(deparse(subst), 1, 1)=='R') par.model[['variobound']] <- variobound
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPbrmixed',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPbrmixed <- new('RMmodelgenerator',
.Data = RPbrmixed,
type = c('method for Brown-Resnick process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 4,
vdim = -3
)
RPbrshifted <- function(phi, tcf, xi, mu, s) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg(tcf)) submodels[['tcf']] <- tcf
if (hasArg('xi') && !is.null(subst <- substitute(xi))) {
u <- try(is.numeric(xi) || is.logical(xi) || is.language(xi)
|| is.list(xi) || is(xi, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['xi']] <- xi
else if (substr(deparse(subst), 1, 1)=='R') par.model[['xi']] <- xi
else stop('random parameter not allowed')
}
if (hasArg('mu') && !is.null(subst <- substitute(mu))) {
u <- try(is.numeric(mu) || is.logical(mu) || is.language(mu)
|| is.list(mu) || is(mu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mu']] <- mu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mu']] <- mu
else stop('random parameter not allowed')
}
if (hasArg('s') && !is.null(subst <- substitute(s))) {
u <- try(is.numeric(s) || is.logical(s) || is.language(s)
|| is.list(s) || is(s, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['s']] <- s
else if (substr(deparse(subst), 1, 1)=='R') par.model[['s']] <- s
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPbrshifted',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPbrshifted <- new('RMmodelgenerator',
.Data = RPbrshifted,
type = c('method for Brown-Resnick process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 4,
vdim = -3
)
RPbernoulli <- function(phi, stationary_only, threshold) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('stationary_only') && !is.null(subst <- substitute(stationary_only))) {
u <- try(is.numeric(stationary_only) || is.logical(stationary_only) || is.language(stationary_only)
|| is.list(stationary_only) || is(stationary_only, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['stationary_only']] <- stationary_only
else if (substr(deparse(subst), 1, 1)=='R') par.model[['stationary_only']] <- stationary_only
else stop('random parameter not allowed')
}
if (hasArg('threshold') && !is.null(subst <- substitute(threshold))) {
u <- try(is.numeric(threshold) || is.logical(threshold) || is.language(threshold)
|| is.list(threshold) || is(threshold, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['threshold']] <- threshold
else if (substr(deparse(subst), 1, 1)=='R') par.model[['threshold']] <- threshold
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPbernoulli',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPbernoulli <- new('RMmodelgenerator',
.Data = RPbernoulli,
type = c('process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 11000,
vdim = -3
)
RPbrownresnick <- function(phi, tcf, xi, mu, s) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg(tcf)) submodels[['tcf']] <- tcf
if (hasArg('xi') && !is.null(subst <- substitute(xi))) {
u <- try(is.numeric(xi) || is.logical(xi) || is.language(xi)
|| is.list(xi) || is(xi, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['xi']] <- xi
else if (substr(deparse(subst), 1, 1)=='R') par.model[['xi']] <- xi
else stop('random parameter not allowed')
}
if (hasArg('mu') && !is.null(subst <- substitute(mu))) {
u <- try(is.numeric(mu) || is.logical(mu) || is.language(mu)
|| is.list(mu) || is(mu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mu']] <- mu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mu']] <- mu
else stop('random parameter not allowed')
}
if (hasArg('s') && !is.null(subst <- substitute(s))) {
u <- try(is.numeric(s) || is.logical(s) || is.language(s)
|| is.list(s) || is(s, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['s']] <- s
else if (substr(deparse(subst), 1, 1)=='R') par.model[['s']] <- s
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPbrownresnick',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPbrownresnick <- new('RMmodelgenerator',
.Data = RPbrownresnick,
type = c('process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 4,
vdim = -3
)
RPgauss <- function(phi, stationary_only) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('stationary_only') && !is.null(subst <- substitute(stationary_only))) {
u <- try(is.numeric(stationary_only) || is.logical(stationary_only) || is.language(stationary_only)
|| is.list(stationary_only) || is(stationary_only, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['stationary_only']] <- stationary_only
else if (substr(deparse(subst), 1, 1)=='R') par.model[['stationary_only']] <- stationary_only
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPgauss',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPgauss <- new('RMmodelgenerator',
.Data = RPgauss,
type = c('process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 11000,
vdim = -3
)
RPpoisson <- function(phi, intensity) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('intensity') && !is.null(subst <- substitute(intensity))) {
u <- try(is.numeric(intensity) || is.logical(intensity) || is.language(intensity)
|| is.list(intensity) || is(intensity, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['intensity']] <- intensity
else if (substr(deparse(subst), 1, 1)=='R') par.model[['intensity']] <- intensity
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPpoisson',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPpoisson <- new('RMmodelgenerator',
.Data = RPpoisson,
type = c('process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 4,
vdim = -3
)
RPschlather <- function(phi, tcf, xi, mu, s) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg(tcf)) submodels[['tcf']] <- tcf
if (hasArg('xi') && !is.null(subst <- substitute(xi))) {
u <- try(is.numeric(xi) || is.logical(xi) || is.language(xi)
|| is.list(xi) || is(xi, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['xi']] <- xi
else if (substr(deparse(subst), 1, 1)=='R') par.model[['xi']] <- xi
else stop('random parameter not allowed')
}
if (hasArg('mu') && !is.null(subst <- substitute(mu))) {
u <- try(is.numeric(mu) || is.logical(mu) || is.language(mu)
|| is.list(mu) || is(mu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mu']] <- mu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mu']] <- mu
else stop('random parameter not allowed')
}
if (hasArg('s') && !is.null(subst <- substitute(s))) {
u <- try(is.numeric(s) || is.logical(s) || is.language(s)
|| is.list(s) || is(s, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['s']] <- s
else if (substr(deparse(subst), 1, 1)=='R') par.model[['s']] <- s
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPschlather',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPschlather <- new('RMmodelgenerator',
.Data = RPschlather,
type = c('process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 11000,
vdim = 1
)
RPopitz <- function(phi, xi, mu, s, alpha) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('xi') && !is.null(subst <- substitute(xi))) {
u <- try(is.numeric(xi) || is.logical(xi) || is.language(xi)
|| is.list(xi) || is(xi, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['xi']] <- xi
else if (substr(deparse(subst), 1, 1)=='R') par.model[['xi']] <- xi
else stop('random parameter not allowed')
}
if (hasArg('mu') && !is.null(subst <- substitute(mu))) {
u <- try(is.numeric(mu) || is.logical(mu) || is.language(mu)
|| is.list(mu) || is(mu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mu']] <- mu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mu']] <- mu
else stop('random parameter not allowed')
}
if (hasArg('s') && !is.null(subst <- substitute(s))) {
u <- try(is.numeric(s) || is.logical(s) || is.language(s)
|| is.list(s) || is(s, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['s']] <- s
else if (substr(deparse(subst), 1, 1)=='R') par.model[['s']] <- s
else stop('random parameter not allowed')
}
if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) {
u <- try(is.numeric(alpha) || is.logical(alpha) || is.language(alpha)
|| is.list(alpha) || is(alpha, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['alpha']] <- alpha
else if (substr(deparse(subst), 1, 1)=='R') par.model[['alpha']] <- alpha
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPopitz',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPopitz <- new('RMmodelgenerator',
.Data = RPopitz,
type = c('process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 11000,
vdim = 1
)
RPsmith <- function(shape, tcf, xi, mu, s) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(shape)) submodels[['shape']] <- shape
if (hasArg(tcf)) submodels[['tcf']] <- tcf
if (hasArg('xi') && !is.null(subst <- substitute(xi))) {
u <- try(is.numeric(xi) || is.logical(xi) || is.language(xi)
|| is.list(xi) || is(xi, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['xi']] <- xi
else if (substr(deparse(subst), 1, 1)=='R') par.model[['xi']] <- xi
else stop('random parameter not allowed')
}
if (hasArg('mu') && !is.null(subst <- substitute(mu))) {
u <- try(is.numeric(mu) || is.logical(mu) || is.language(mu)
|| is.list(mu) || is(mu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['mu']] <- mu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['mu']] <- mu
else stop('random parameter not allowed')
}
if (hasArg('s') && !is.null(subst <- substitute(s))) {
u <- try(is.numeric(s) || is.logical(s) || is.language(s)
|| is.list(s) || is(s, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['s']] <- s
else if (substr(deparse(subst), 1, 1)=='R') par.model[['s']] <- s
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPsmith',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPsmith <- new('RMmodelgenerator',
.Data = RPsmith,
type = c('process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 4,
vdim = 1
)
RPchi2 <- function(phi, f) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('f') && !is.null(subst <- substitute(f))) {
u <- try(is.numeric(f) || is.logical(f) || is.language(f)
|| is.list(f) || is(f, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['f']] <- f
else if (substr(deparse(subst), 1, 1)=='R') par.model[['f']] <- f
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPchi2',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPchi2 <- new('RMmodelgenerator',
.Data = RPchi2,
type = c('process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 11000,
vdim = -3
)
RPt <- function(phi, nu) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg(phi)) submodels[['phi']] <- phi
if (hasArg('nu') && !is.null(subst <- substitute(nu))) {
u <- try(is.numeric(nu) || is.logical(nu) || is.language(nu)
|| is.list(nu) || is(nu, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['nu']] <- nu
else if (substr(deparse(subst), 1, 1)=='R') par.model[['nu']] <- nu
else stop('random parameter not allowed')
}
model <- new('RMmodel', call = cl, name = 'RPt',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
RPt <- new('RMmodelgenerator',
.Data = RPt,
type = c('process'),
isotropy = c('non-dimension-reducing'),
domain = 'single variable',
operator = TRUE,
monotone = 'mismatch in monotonicity',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 11000,
vdim = -3
)
R.minus <- function(a, b, factor) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
if (hasArg('factor') && !is.null(subst <- substitute(factor))) {
u <- try(is.numeric(factor) || is.logical(factor) || is.language(factor)
|| is.list(factor) || is(factor, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['factor']] <- factor
else if (substr(deparse(subst), 1, 1)=='R') par.model[['factor']] <- factor
else par.model[['factor']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.minus',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.minus <- new('RMmodelgenerator',
.Data = R.minus,
type = c('shape function', 'trend'),
isotropy = c('parameter dependent', 'parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.plus <- function(a, b, factor) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
if (hasArg('factor') && !is.null(subst <- substitute(factor))) {
u <- try(is.numeric(factor) || is.logical(factor) || is.language(factor)
|| is.list(factor) || is(factor, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['factor']] <- factor
else if (substr(deparse(subst), 1, 1)=='R') par.model[['factor']] <- factor
else par.model[['factor']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.plus',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.plus <- new('RMmodelgenerator',
.Data = R.plus,
type = c('shape function', 'trend'),
isotropy = c('parameter dependent', 'parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 1,
vdim = 1
)
R.div <- function(a, b, factor) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
if (hasArg('factor') && !is.null(subst <- substitute(factor))) {
u <- try(is.numeric(factor) || is.logical(factor) || is.language(factor)
|| is.list(factor) || is(factor, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['factor']] <- factor
else if (substr(deparse(subst), 1, 1)=='R') par.model[['factor']] <- factor
else par.model[['factor']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.div',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.div <- new('RMmodelgenerator',
.Data = R.div,
type = c('shape function', 'trend'),
isotropy = c('parameter dependent', 'parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 1,
vdim = 1
)
R.mult <- function(a, b, factor) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
if (hasArg('factor') && !is.null(subst <- substitute(factor))) {
u <- try(is.numeric(factor) || is.logical(factor) || is.language(factor)
|| is.list(factor) || is(factor, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['factor']] <- factor
else if (substr(deparse(subst), 1, 1)=='R') par.model[['factor']] <- factor
else par.model[['factor']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.mult',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.mult <- new('RMmodelgenerator',
.Data = R.mult,
type = c('shape function', 'trend'),
isotropy = c('parameter dependent', 'parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 1,
vdim = 1
)
R.c <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.c',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.c <- new('RMmodelgenerator',
.Data = R.c,
type = c('shape function', 'trend'),
isotropy = c('parameter dependent', 'parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.p <- function(proj, new, factor) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('proj') && !is.null(subst <- substitute(proj))) {
u <- try(is.numeric(proj) || is.logical(proj) || is.language(proj)
|| is.list(proj) || is(proj, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['proj']] <- proj
else if (substr(deparse(subst), 1, 1)=='R') par.model[['proj']] <- proj
else par.model[['proj']] <- do.call('RRdistr', list(subst))
}
if (!(hasArg('new') && !is.null(subst <- substitute(new))))
new <- UNREDUCED
if (is.character(new)) {par.model[['new']] <- a <- pmatch(new,ISONAMES) - 1
if (any(is.na(a))) stop('unknown string value') } else {
u <- try(is.numeric(new) || is.logical(new) || is.language(new)
|| is.list(new) || is(new, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['new']] <- new
else if (substr(deparse(subst), 1, 1)=='R') par.model[['new']] <- new
else par.model[['new']] <- do.call('RRdistr', list(subst))
}
if (hasArg('factor') && !is.null(subst <- substitute(factor))) {
u <- try(is.numeric(factor) || is.logical(factor) || is.language(factor)
|| is.list(factor) || is(factor, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['factor']] <- factor
else if (substr(deparse(subst), 1, 1)=='R') par.model[['factor']] <- factor
else par.model[['factor']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.p',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.p <- new('RMmodelgenerator',
.Data = R.p,
type = c('shape function', 'trend'),
isotropy = c('parameter dependent', 'parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = Inf,
vdim = 1
)
R.bind <- function(a, b, c, d, e, factor) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
if (hasArg('c') && !is.null(subst <- substitute(c))) {
u <- try(is.numeric(c) || is.logical(c) || is.language(c)
|| is.list(c) || is(c, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['c']] <- c
else if (substr(deparse(subst), 1, 1)=='R') par.model[['c']] <- c
else par.model[['c']] <- do.call('RRdistr', list(subst))
}
if (hasArg('d') && !is.null(subst <- substitute(d))) {
u <- try(is.numeric(d) || is.logical(d) || is.language(d)
|| is.list(d) || is(d, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['d']] <- d
else if (substr(deparse(subst), 1, 1)=='R') par.model[['d']] <- d
else par.model[['d']] <- do.call('RRdistr', list(subst))
}
if (hasArg('e') && !is.null(subst <- substitute(e))) {
u <- try(is.numeric(e) || is.logical(e) || is.language(e)
|| is.list(e) || is(e, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['e']] <- e
else if (substr(deparse(subst), 1, 1)=='R') par.model[['e']] <- e
else par.model[['e']] <- do.call('RRdistr', list(subst))
}
if (hasArg('factor') && !is.null(subst <- substitute(factor))) {
u <- try(is.numeric(factor) || is.logical(factor) || is.language(factor)
|| is.list(factor) || is(factor, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['factor']] <- factor
else if (substr(deparse(subst), 1, 1)=='R') par.model[['factor']] <- factor
else par.model[['factor']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.bind',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.bind <- new('RMmodelgenerator',
.Data = R.bind,
type = c('shape function', 'trend'),
isotropy = c('parameter dependent', 'parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = 1,
vdim = 1
)
R.acos <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.acos',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.acos <- new('RMmodelgenerator',
.Data = R.acos,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.asin <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.asin',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.asin <- new('RMmodelgenerator',
.Data = R.asin,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.atan <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.atan',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.atan <- new('RMmodelgenerator',
.Data = R.atan,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.atan2 <- function(a, b) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.atan2',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.atan2 <- new('RMmodelgenerator',
.Data = R.atan2,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.cos <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.cos',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.cos <- new('RMmodelgenerator',
.Data = R.cos,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.sin <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.sin',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.sin <- new('RMmodelgenerator',
.Data = R.sin,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.tan <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.tan',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.tan <- new('RMmodelgenerator',
.Data = R.tan,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.acosh <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.acosh',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.acosh <- new('RMmodelgenerator',
.Data = R.acosh,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.asinh <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.asinh',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.asinh <- new('RMmodelgenerator',
.Data = R.asinh,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.atanh <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.atanh',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.atanh <- new('RMmodelgenerator',
.Data = R.atanh,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.cosh <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.cosh',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.cosh <- new('RMmodelgenerator',
.Data = R.cosh,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.sinh <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.sinh',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.sinh <- new('RMmodelgenerator',
.Data = R.sinh,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.tanh <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.tanh',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.tanh <- new('RMmodelgenerator',
.Data = R.tanh,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.exp <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.exp',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.exp <- new('RMmodelgenerator',
.Data = R.exp,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.log <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.log',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.log <- new('RMmodelgenerator',
.Data = R.log,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.expm1 <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.expm1',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.expm1 <- new('RMmodelgenerator',
.Data = R.expm1,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.log1p <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.log1p',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.log1p <- new('RMmodelgenerator',
.Data = R.log1p,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.logb <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.logb',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.logb <- new('RMmodelgenerator',
.Data = R.logb,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.exp2 <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.exp2',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.exp2 <- new('RMmodelgenerator',
.Data = R.exp2,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.log2 <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.log2',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.log2 <- new('RMmodelgenerator',
.Data = R.log2,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.pow <- function(a, b) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.pow',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.pow <- new('RMmodelgenerator',
.Data = R.pow,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.sqrt <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.sqrt',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.sqrt <- new('RMmodelgenerator',
.Data = R.sqrt,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.hypot <- function(a, b) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.hypot',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.hypot <- new('RMmodelgenerator',
.Data = R.hypot,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.cbrt <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.cbrt',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.cbrt <- new('RMmodelgenerator',
.Data = R.cbrt,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.ceil <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.ceil',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.ceil <- new('RMmodelgenerator',
.Data = R.ceil,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.fabs <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.fabs',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.fabs <- new('RMmodelgenerator',
.Data = R.fabs,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.floor <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.floor',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.floor <- new('RMmodelgenerator',
.Data = R.floor,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.fmod <- function(a, b) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.fmod',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.fmod <- new('RMmodelgenerator',
.Data = R.fmod,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.nearbyint <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.nearbyint',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.nearbyint <- new('RMmodelgenerator',
.Data = R.nearbyint,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.round <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.round',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.round <- new('RMmodelgenerator',
.Data = R.round,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.trunc <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.trunc',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.trunc <- new('RMmodelgenerator',
.Data = R.trunc,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.lrint <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.lrint',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.lrint <- new('RMmodelgenerator',
.Data = R.lrint,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.llrint <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.llrint',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.llrint <- new('RMmodelgenerator',
.Data = R.llrint,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.lround <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.lround',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.lround <- new('RMmodelgenerator',
.Data = R.lround,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.llround <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.llround',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.llround <- new('RMmodelgenerator',
.Data = R.llround,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.copysign <- function(a, b) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.copysign',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.copysign <- new('RMmodelgenerator',
.Data = R.copysign,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.erf <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.erf',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.erf <- new('RMmodelgenerator',
.Data = R.erf,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.erfc <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.erfc',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.erfc <- new('RMmodelgenerator',
.Data = R.erfc,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.tgamma <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.tgamma',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.tgamma <- new('RMmodelgenerator',
.Data = R.tgamma,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.lgamma <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.lgamma',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.lgamma <- new('RMmodelgenerator',
.Data = R.lgamma,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.rint <- function(a) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.rint',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.rint <- new('RMmodelgenerator',
.Data = R.rint,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.nextafter <- function(a, b) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.nextafter',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.nextafter <- new('RMmodelgenerator',
.Data = R.nextafter,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.nexttoward <- function(a, b) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.nexttoward',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.nexttoward <- new('RMmodelgenerator',
.Data = R.nexttoward,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.remainder <- function(a, b) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.remainder',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.remainder <- new('RMmodelgenerator',
.Data = R.remainder,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.fdim <- function(a, b) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.fdim',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.fdim <- new('RMmodelgenerator',
.Data = R.fdim,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.fmax <- function(a, b) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.fmax',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.fmax <- new('RMmodelgenerator',
.Data = R.fmax,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
R.fmin <- function(a, b) {
cl <- match.call()
submodels <- par.general <- par.model <- list()
if (hasArg('a') && !is.null(subst <- substitute(a))) {
u <- try(is.numeric(a) || is.logical(a) || is.language(a)
|| is.list(a) || is(a, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['a']] <- a
else if (substr(deparse(subst), 1, 1)=='R') par.model[['a']] <- a
else par.model[['a']] <- do.call('RRdistr', list(subst))
}
if (hasArg('b') && !is.null(subst <- substitute(b))) {
u <- try(is.numeric(b) || is.logical(b) || is.language(b)
|| is.list(b) || is(b, class2='RMmodel'), silent=TRUE)
if (is.logical(u) && u) par.model[['b']] <- b
else if (substr(deparse(subst), 1, 1)=='R') par.model[['b']] <- b
else par.model[['b']] <- do.call('RRdistr', list(subst))
}
model <- new('RMmodel', call = cl, name = 'R.fmin',
submodels = submodels,
par.model = par.model, par.general = par.general)
return(model)
}
R.fmin <- new('RMmodelgenerator',
.Data = R.fmin,
type = c('shape function'),
isotropy = c('parameter dependent'),
domain = 'single variable',
operator = FALSE,
monotone = 'not monotone',
finiterange = FALSE,
simpleArguments = TRUE,
maxdim = -2,
vdim = 1
)
Computing file changes ...
