RandomFields
Simulation and Analysis of Random Fields

Package index
Search the RandomFields package
Functions
1403
Source code
37
Man pages
215
Home
/
CRAN
/
RandomFields
/
R/RMmodels.R

R/RMmodels.R
In RandomFields: Simulation and Analysis of Random Fields

Defines functions R.sqrt R.pow R.acosh R.acos R.fabs R.erf R.exp R.gamma R.fmin R.fmax R.fdim R.remainder R.lgamma R.erfc R.trunc R.round R.fmod R.floor R.ceil R.cbrt R.hypot R.log2 R.exp2 R.log1p R.expm1 R.log R.tanh R.sinh R.cosh R.atanh R.asinh R.tan R.sin R.cos R.atan2 R.atan R.asin R.is R.c R.p R.const R.mult R.div R.plus R.minus RPt RPchi2 RPsmith RPopitz RPschlather RPpoisson RPgauss RPbernoulli RPbrownresnick RPbrshifted RPbrmixed RPbrorig RPloggaussnormed RPtbm RPspecific RPspectral RPsequential RPnugget RPhyperplane RPdirect RPintrinsic RPcutoff RPcirculant RPcoins RPaverage RPtrend iRFsimulate iRFvariogram iRFpseudovariogra iRFloglikelihood iRFcovmatrix iRFcov RMmppplus RRunif RRspheric RRrectangular RRmcmc RRloc RRgauss RRdeterm RMtruncsupport RMmps RMm3b RMm2r RMsign RMrotation RMrotat RMrational RMpolygon RMtrafo RMid RMetaxxa RMeaxxa iRMcovariate RMball RMangle RMtrend RMnugget RMwhittle RMwave RMvector iRMcov RMsum RMtbm RMstp RMstein RMintrinsic RMstable RMspheric RMsinepower RMdelay RMschur RMscale RMqexp RMqam RMprod RMpower RMaskey RMpenta RMparswm RMnsst RMnatsc RMmultiquad RMmqam RMmatern RMmatrix RMintexp RMma RMmastein RMlgd RMkolmogorov RMidmodel RMiaco RMhyperbolic RMgennsst RMgneiting RMgengneiting RMbicauchy RMgencauchy RMgenfbm RMgauss RMfractgauss RMfbm RMflatpower RMfractdiff RMschlather RMexponential RMexp RMepscauchy RMdivfree RMdewijsian RMderiv RMdampedcos RMdagum RMcutoff RMcurlfree RMcubic RMcoxisham iRMfixcov RMconstant RMcircular RMcauchy RMbubble RMbr2eg RMbr2bg RMbrownresnick RMblend RMbistable RMbiwm RMbernoulli RMbigneiting RMbessel RMlsfbm RMbcw RMave RMS RMmult RMplus

Documented in R.acos R.acosh R.asin R.asinh R.atan R.atan2 R.atanh R.c R.cbrt R.ceil R.const R.cos R.cosh R.div R.erf R.erfc R.exp R.exp2 R.expm1 R.fabs R.fdim R.floor R.fmax R.fmin R.fmod R.gamma R.hypot R.is R.lgamma R.log R.log1p R.log2 RMangle RMaskey RMave RMball RMbcw RMbernoulli RMbessel RMbicauchy RMbigneiting RMbistable RMbiwm RMblend RMbr2bg RMbr2eg RMbrownresnick RMbubble RMcauchy RMcircular RMconstant RMconstant RMcoxisham RMcubic RMcurlfree RMcutoff RMdagum RMdampedcos RMdelay RMderiv RMdewijsian RMdivfree RMeaxxa RMepscauchy RMetaxxa RMexp RMexponential RMexponential RMfbm RMflatpower RMfractdiff RMfractgauss RMgauss RMgencauchy RMgenfbm RMgengneiting RMgennsst RMgneiting RMhyperbolic RMiaco RMid RMidmodel RMintexp RMintrinsic R.minus RMkolmogorov RMlgd RMlsfbm RMm2r RMm3b RMma RMmastein RMmatern RMmatrix RMmppplus RMmps RMmqam RMmqam RMmult RMmultiquad RMnatsc RMnsst RMnugget RMparswm RMpenta RMplus RMpolygon RMpower RMpower RMprod RMqam RMqam RMqexp RMrational RMrotat RMrotation RMS RMscale RMschlather RMschur RMsign RMsinepower RMspheric RMstable RMstein RMstp RMstp RMsum RMtbm RMtrafo RMtrend RMtruncsupport R.mult RMvector RMwave RMwhittle R.p RPaverage RPbernoulli RPbrmixed RPbrorig RPbrownresnick RPbrshifted RPchi2 RPcirculant RPcoins RPcutoff RPdirect RPgauss RPhyperplane RPintrinsic RPloggaussnormed R.plus RPnugget RPopitz R.pow RPpoisson RPschlather RPsequential RPsmith RPspecific RPspectral RPt RPtbm RPtrend RRdeterm R.remainder RRgauss RRloc RRmcmc R.round RRrectangular RRspheric RRunif R.sin R.sinh R.sqrt R.tan R.tanh R.trunc 

## This file has been created automatically by 'rfGenerateModels'.


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))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMplus', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMplus <- new(CLASS_RM, 
	.Data = RMplus,
	type = c('of manifold type'),
	isotropy = c('submodel dependent'),
	domain = c('submodel 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))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMmult', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMmult <- new(CLASS_RM, 
	.Data = RMmult,
	type = c('of manifold type'),
	isotropy = c('submodel dependent'),
	domain = c('submodel 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))) 
	par.model[['var']] <- CheckArg(var, subst, TRUE)
  if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.model[['scale']] <- CheckArg(scale, subst, TRUE)
  if (hasArg('anisoT') && !is.null(subst <- substitute(anisoT))) 
	par.model[['anisoT']] <- CheckArg(anisoT, subst, TRUE)
  if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.model[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
  if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.model[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  
  model <- methods::new('RMmodel', call = cl, name = 'RMS', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMS <- new(CLASS_RM, 
	.Data = RMS,
	type = c('of manifold type', 'of manifold type'),
	isotropy = c('submodel dependent', 'submodel dependent'),
	domain = c('submodel 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))) 
	par.model[['A']] <- CheckArg(A, subst, TRUE)
  if (hasArg('z') && !is.null(subst <- substitute(z))) 
	par.model[['z']] <- CheckArg(z, subst, TRUE)
  if (hasArg('spacetime') && !is.null(subst <- substitute(spacetime))) 
	par.model[['spacetime']] <- CheckArg(spacetime, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMave', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMave <- new(CLASS_RM, 
	.Data = RMave,
	type = c('positive definite'),
	isotropy = c('symmetric'),
	domain = c('single variable'),
	operator = TRUE,
	monotone = 'not monotone',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = 10,
	vdim = 1
	)



RMbcw <- function(alpha, beta, c, var, scale, Aniso, proj) {
  cl <- match.call()
  submodels <- par.general <- par.model <- list() 
  
  if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) 
	par.model[['alpha']] <- CheckArg(alpha, subst, TRUE)
  if (hasArg('beta') && !is.null(subst <- substitute(beta))) 
	par.model[['beta']] <- CheckArg(beta, subst, TRUE)
  if (hasArg('c') && !is.null(subst <- substitute(c))) 
	par.model[['c']] <- CheckArg(c, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMbcw', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMbcw <- new(CLASS_RM, 
	.Data = RMbcw,
	type = c('variogram', 'positive definite', 'tail correlation', 'positive definite'),
	isotropy = c('isotropic', 'isotropic', 'isotropic', 'spherical isotropic'),
	domain = c('single variable'),
	operator = FALSE,
	monotone = 'normal mixture',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = Inf,
	vdim = 1
	)



RMlsfbm <- function(alpha, const, var, scale, Aniso, proj) {
  cl <- match.call()
  submodels <- par.general <- par.model <- list() 
  
  if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) 
	par.model[['alpha']] <- CheckArg(alpha, subst, TRUE)
  if (hasArg('const') && !is.null(subst <- substitute(const))) 
	par.model[['const']] <- CheckArg(const, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMlsfbm', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMlsfbm <- new(CLASS_RM, 
	.Data = RMlsfbm,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('single variable'),
	operator = FALSE,
	monotone = 'monotone',
	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))) 
	par.model[['nu']] <- CheckArg(nu, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMbessel', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMbessel <- new(CLASS_RM, 
	.Data = RMbessel,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('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))) 
	par.model[['kappa']] <- CheckArg(kappa, subst, TRUE)
  if (hasArg('mu') && !is.null(subst <- substitute(mu))) 
	par.model[['mu']] <- CheckArg(mu, subst, TRUE)
  if (hasArg('s') && !is.null(subst <- substitute(s))) 
	par.model[['s']] <- CheckArg(s, subst, TRUE)
  if (hasArg('sred12') && !is.null(subst <- substitute(sred12))) 
	par.model[['sred12']] <- CheckArg(sred12, subst, TRUE)
  if (hasArg('gamma') && !is.null(subst <- substitute(gamma))) 
	par.model[['gamma']] <- CheckArg(gamma, subst, TRUE)
  if (hasArg('cdiag') && !is.null(subst <- substitute(cdiag))) 
	par.model[['cdiag']] <- CheckArg(cdiag, subst, TRUE)
  if (hasArg('rhored') && !is.null(subst <- substitute(rhored))) 
	par.model[['rhored']] <- CheckArg(rhored, subst, TRUE)
  if (hasArg('c') && !is.null(subst <- substitute(c))) 
	par.model[['c']] <- CheckArg(c, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMbigneiting', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMbigneiting <- new(CLASS_RM, 
	.Data = RMbigneiting,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('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))) 
	par.model[['threshold']] <- CheckArg(threshold, subst, TRUE)
  if (hasArg('correlation') && !is.null(subst <- substitute(correlation))) 
	par.model[['correlation']] <- CheckArg(correlation, subst, TRUE)
  if (hasArg('centred') && !is.null(subst <- substitute(centred))) 
	par.model[['centred']] <- CheckArg(centred, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMbernoulli', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMbernoulli <- new(CLASS_RM, 
	.Data = RMbernoulli,
	type = c('tail correlation'),
	isotropy = c('submodel dependent'),
	domain = c('submodel 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))) 
	par.model[['nudiag']] <- CheckArg(nudiag, subst, TRUE)
  if (hasArg('nured12') && !is.null(subst <- substitute(nured12))) 
	par.model[['nured12']] <- CheckArg(nured12, subst, TRUE)
  if (hasArg('nu') && !is.null(subst <- substitute(nu))) 
	par.model[['nu']] <- CheckArg(nu, subst, TRUE)
  if (hasArg('s') && !is.null(subst <- substitute(s))) 
	par.model[['s']] <- CheckArg(s, subst, TRUE)
  if (hasArg('cdiag') && !is.null(subst <- substitute(cdiag))) 
	par.model[['cdiag']] <- CheckArg(cdiag, subst, TRUE)
  if (hasArg('rhored') && !is.null(subst <- substitute(rhored))) 
	par.model[['rhored']] <- CheckArg(rhored, subst, TRUE)
  if (hasArg('c') && !is.null(subst <- substitute(c))) 
	par.model[['c']] <- CheckArg(c, subst, TRUE)
  if (hasArg('notinvnu') && !is.null(subst <- substitute(notinvnu))) 
	par.model[['notinvnu']] <- CheckArg(notinvnu, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMbiwm', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMbiwm <- new(CLASS_RM, 
	.Data = RMbiwm,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('single variable'),
	operator = FALSE,
	monotone = 'not monotone',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = Inf,
	vdim = 2
	)



RMbistable <- function(alpha, s, cdiag, rho, rhored, betared, alphadiag, var, scale, Aniso, proj) {
  cl <- match.call()
  submodels <- par.general <- par.model <- list() 
  
  if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) 
	par.model[['alpha']] <- CheckArg(alpha, subst, TRUE)
  if (hasArg('s') && !is.null(subst <- substitute(s))) 
	par.model[['s']] <- CheckArg(s, subst, TRUE)
  if (hasArg('cdiag') && !is.null(subst <- substitute(cdiag))) 
	par.model[['cdiag']] <- CheckArg(cdiag, subst, TRUE)
  if (hasArg('rho') && !is.null(subst <- substitute(rho))) 
	par.model[['rho']] <- CheckArg(rho, subst, TRUE)
  if (hasArg('rhored') && !is.null(subst <- substitute(rhored))) 
	par.model[['rhored']] <- CheckArg(rhored, subst, TRUE)
  if (hasArg('betared') && !is.null(subst <- substitute(betared))) 
	par.model[['betared']] <- CheckArg(betared, subst, TRUE)
  if (hasArg('alphadiag') && !is.null(subst <- substitute(alphadiag))) 
	par.model[['alphadiag']] <- CheckArg(alphadiag, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMbistable', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMbistable <- new(CLASS_RM, 
	.Data = RMbistable,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('single variable'),
	operator = FALSE,
	monotone = 'monotone',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = 3,
	vdim = 2
	)



RMblend <- function(multi, blend, thresholds, var, scale, Aniso, proj) {
  cl <- match.call()
  submodels <- par.general <- par.model <- list() 
  if (hasArg(multi)) submodels[['multi']] <- multi
  if (hasArg(blend)) submodels[['blend']] <- blend
  
  if (hasArg('thresholds') && !is.null(subst <- substitute(thresholds))) 
	par.model[['thresholds']] <- CheckArg(thresholds, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMblend', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMblend <- new(CLASS_RM, 
	.Data = RMblend,
	type = c('positive definite'),
	isotropy = c('symmetric'),
	domain = c('kernel'),
	operator = TRUE,
	monotone = 'not monotone',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = -3,
	vdim = 1
	)



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))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMbrownresnick', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMbrownresnick <- new(CLASS_RM, 
	.Data = RMbrownresnick,
	type = c('tail correlation'),
	isotropy = c('submodel dependent'),
	domain = c('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))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMbr2bg', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMbr2bg <- new(CLASS_RM, 
	.Data = RMbr2bg,
	type = c('positive definite'),
	isotropy = c('submodel dependent'),
	domain = c('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))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMbr2eg', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMbr2eg <- new(CLASS_RM, 
	.Data = RMbr2eg,
	type = c('positive definite'),
	isotropy = c('submodel dependent'),
	domain = c('single variable'),
	operator = TRUE,
	monotone = 'submodel dependent monotonicity',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = -3,
	vdim = 1
	)



RMbubble <- function(phi, scaling, z, weight, minscale, barycentre, var, scale, Aniso, proj) {
  cl <- match.call()
  submodels <- par.general <- par.model <- list() 
  if (hasArg(phi)) submodels[['phi']] <- phi
  if (hasArg(scaling)) submodels[['scaling']] <- scaling
  
  if (hasArg('z') && !is.null(subst <- substitute(z))) 
	par.model[['z']] <- CheckArg(z, subst, TRUE)
  if (hasArg('weight') && !is.null(subst <- substitute(weight))) 
	par.model[['weight']] <- CheckArg(weight, subst, TRUE)
  if (hasArg('minscale') && !is.null(subst <- substitute(minscale))) 
	par.model[['minscale']] <- CheckArg(minscale, subst, TRUE)
  if (hasArg('barycentre') && !is.null(subst <- substitute(barycentre))) 
	par.model[['barycentre']] <- CheckArg(barycentre, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMbubble', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMbubble <- new(CLASS_RM, 
	.Data = RMbubble,
	type = c('positive definite'),
	isotropy = c('non-dimension-reducing'),
	domain = c('kernel'),
	operator = TRUE,
	monotone = 'not monotone',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = Inf,
	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))) 
	par.model[['gamma']] <- CheckArg(gamma, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMcauchy', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMcauchy <- new(CLASS_RM, 
	.Data = RMcauchy,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('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))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMcircular', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMcircular <- new(CLASS_RM, 
	.Data = RMcircular,
	type = c('tail correlation'),
	isotropy = c('isotropic'),
	domain = c('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))) 
	par.model[['M']] <- CheckArg(M, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
  model <- methods::new('RMmodel', call = cl, name = 'RMconstant', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMconstant <- new(CLASS_RM, 
	.Data = RMconstant,
	type = c('positive definite', 'negative definite'),
	isotropy = c('framework dependent', 'isotropic'),
	domain = c('single variable'),
	operator = FALSE,
	monotone = 'submodel dependent monotonicity',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = Inf,
	vdim = -1
	)



iRMfixcov <- function(norm, M, x, raw, var, proj) {
  cl <- match.call()
  submodels <- par.general <- par.model <- list() 
  if (hasArg(norm)) submodels[['norm']] <- norm
  
  if (hasArg('M') && !is.null(subst <- substitute(M))) 
	par.model[['M']] <- CheckArg(M, subst, TRUE)
  if (hasArg('x') && !is.null(subst <- substitute(x))) 
	par.model[['x']] <- CheckArg(x, subst, TRUE)
  if (hasArg('raw') && !is.null(subst <- substitute(raw))) 
	par.model[['raw']] <- CheckArg(raw, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMfixcov', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

iRMfixcov <- new(CLASS_RM, 
	.Data = iRMfixcov,
	type = c('positive definite', 'positive definite', 'positive definite'),
	isotropy = c('non-dimension-reducing', 'isotropic', 'earth isotropic'),
	domain = c('kernel'),
	operator = TRUE,
	monotone = 'not monotone',
	finiterange = FALSE,
	simpleArguments = FALSE,
	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))) 
	par.model[['mu']] <- CheckArg(mu, subst, TRUE)
  if (hasArg('D') && !is.null(subst <- substitute(D))) 
	par.model[['D']] <- CheckArg(D, subst, TRUE)
  if (hasArg('beta') && !is.null(subst <- substitute(beta))) 
	par.model[['beta']] <- CheckArg(beta, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMcoxisham', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMcoxisham <- new(CLASS_RM, 
	.Data = RMcoxisham,
	type = c('positive definite'),
	isotropy = c('symmetric'),
	domain = c('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))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMcubic', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMcubic <- new(CLASS_RM, 
	.Data = RMcubic,
	type = c('tail correlation'),
	isotropy = c('isotropic'),
	domain = c('single variable'),
	operator = FALSE,
	monotone = 'monotone',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = 3,
	vdim = 1
	)



RMcurlfree <- function(phi, which, var, scale, Aniso, proj) {
  cl <- match.call()
  submodels <- par.general <- par.model <- list() 
  if (hasArg(phi)) submodels[['phi']] <- phi
  
  if (hasArg('which') && !is.null(subst <- substitute(which))) 
	par.model[['which']] <- CheckArg(which, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMcurlfree', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMcurlfree <- new(CLASS_RM, 
	.Data = RMcurlfree,
	type = c('positive definite'),
	isotropy = c('cartesian system'),
	domain = c('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))) 
	par.model[['diameter']] <- CheckArg(diameter, subst, TRUE)
  if (hasArg('a') && !is.null(subst <- substitute(a))) 
	par.model[['a']] <- CheckArg(a, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMcutoff', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMcutoff <- new(CLASS_RM, 
	.Data = RMcutoff,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('single variable'),
	operator = TRUE,
	monotone = 'monotone',
	finiterange = TRUE,
	simpleArguments = TRUE,
	maxdim = 13,
	vdim = -3
	)



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))) 
	par.model[['beta']] <- CheckArg(beta, subst, TRUE)
  if (hasArg('gamma') && !is.null(subst <- substitute(gamma))) 
	par.model[['gamma']] <- CheckArg(gamma, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMdagum', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMdagum <- new(CLASS_RM, 
	.Data = RMdagum,
	type = c('positive definite', 'tail correlation', 'positive definite'),
	isotropy = c('isotropic', 'isotropic', 'spherical isotropic'),
	domain = c('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))) 
	par.model[['lambda']] <- CheckArg(lambda, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMdampedcos', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMdampedcos <- new(CLASS_RM, 
	.Data = RMdampedcos,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('single variable'),
	operator = FALSE,
	monotone = 'not monotone',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = -1,
	vdim = 1
	)



RMderiv <- function(phi, which, var, scale, Aniso, proj) {
  cl <- match.call()
  submodels <- par.general <- par.model <- list() 
  if (hasArg(phi)) submodels[['phi']] <- phi
  
  if (hasArg('which') && !is.null(subst <- substitute(which))) 
	par.model[['which']] <- CheckArg(which, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMderiv', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMderiv <- new(CLASS_RM, 
	.Data = RMderiv,
	type = c('positive definite'),
	isotropy = c('cartesian system'),
	domain = c('single variable'),
	operator = TRUE,
	monotone = 'not monotone',
	finiterange = NA,
	simpleArguments = TRUE,
	maxdim = -3,
	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))) 
	par.model[['alpha']] <- CheckArg(alpha, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMdewijsian', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMdewijsian <- new(CLASS_RM, 
	.Data = RMdewijsian,
	type = c('variogram'),
	isotropy = c('isotropic'),
	domain = c('single variable'),
	operator = FALSE,
	monotone = 'monotone',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = Inf,
	vdim = 1
	)



RMdivfree <- function(phi, which, var, scale, Aniso, proj) {
  cl <- match.call()
  submodels <- par.general <- par.model <- list() 
  if (hasArg(phi)) submodels[['phi']] <- phi
  
  if (hasArg('which') && !is.null(subst <- substitute(which))) 
	par.model[['which']] <- CheckArg(which, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMdivfree', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMdivfree <- new(CLASS_RM, 
	.Data = RMdivfree,
	type = c('positive definite'),
	isotropy = c('cartesian system'),
	domain = c('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))) 
	par.model[['alpha']] <- CheckArg(alpha, subst, TRUE)
  if (hasArg('beta') && !is.null(subst <- substitute(beta))) 
	par.model[['beta']] <- CheckArg(beta, subst, TRUE)
  if (hasArg('eps') && !is.null(subst <- substitute(eps))) 
	par.model[['eps']] <- CheckArg(eps, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMepscauchy', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMepscauchy <- new(CLASS_RM, 
	.Data = RMepscauchy,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('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))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMexp', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMexp <- new(CLASS_RM, 
	.Data = RMexp,
	type = c('tail correlation', 'positive definite'),
	isotropy = c('isotropic', 'spherical isotropic'),
	domain = c('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))) 
	par.model[['n']] <- CheckArg(n, subst, TRUE)
  if (hasArg('standardised') && !is.null(subst <- substitute(standardised))) 
	par.model[['standardised']] <- CheckArg(standardised, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMexponential', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMexponential <- new(CLASS_RM, 
	.Data = RMexponential,
	type = c('positive definite'),
	isotropy = c('submodel dependent'),
	domain = c('submodel 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))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMschlather', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMschlather <- new(CLASS_RM, 
	.Data = RMschlather,
	type = c('tail correlation'),
	isotropy = c('submodel dependent'),
	domain = c('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))) 
	par.model[['a']] <- CheckArg(a, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMfractdiff', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMfractdiff <- new(CLASS_RM, 
	.Data = RMfractdiff,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('single variable'),
	operator = FALSE,
	monotone = 'not monotone',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = 1,
	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))) 
	par.model[['alpha']] <- CheckArg(alpha, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMflatpower', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMflatpower <- new(CLASS_RM, 
	.Data = RMflatpower,
	type = c('variogram'),
	isotropy = c('isotropic'),
	domain = c('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))) 
	par.model[['alpha']] <- CheckArg(alpha, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMfbm', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMfbm <- new(CLASS_RM, 
	.Data = RMfbm,
	type = c('variogram'),
	isotropy = c('isotropic'),
	domain = c('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))) 
	par.model[['alpha']] <- CheckArg(alpha, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMfractgauss', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMfractgauss <- new(CLASS_RM, 
	.Data = RMfractgauss,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('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))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMgauss', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMgauss <- new(CLASS_RM, 
	.Data = RMgauss,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('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))) 
	par.model[['alpha']] <- CheckArg(alpha, subst, TRUE)
  if (hasArg('beta') && !is.null(subst <- substitute(beta))) 
	par.model[['beta']] <- CheckArg(beta, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMgenfbm', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMgenfbm <- new(CLASS_RM, 
	.Data = RMgenfbm,
	type = c('variogram'),
	isotropy = c('isotropic'),
	domain = c('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))) 
	par.model[['alpha']] <- CheckArg(alpha, subst, TRUE)
  if (hasArg('beta') && !is.null(subst <- substitute(beta))) 
	par.model[['beta']] <- CheckArg(beta, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMgencauchy', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMgencauchy <- new(CLASS_RM, 
	.Data = RMgencauchy,
	type = c('positive definite', 'tail correlation', 'positive definite'),
	isotropy = c('isotropic', 'isotropic', 'spherical isotropic'),
	domain = c('single variable'),
	operator = FALSE,
	monotone = 'parameter dependent monotonicity',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = Inf,
	vdim = 1
	)



RMbicauchy <- function(alpha, beta, s, rho, var, scale, Aniso, proj) {
  cl <- match.call()
  submodels <- par.general <- par.model <- list() 
  
  if (hasArg('alpha') && !is.null(subst <- substitute(alpha))) 
	par.model[['alpha']] <- CheckArg(alpha, subst, TRUE)
  if (hasArg('beta') && !is.null(subst <- substitute(beta))) 
	par.model[['beta']] <- CheckArg(beta, subst, TRUE)
  if (hasArg('s') && !is.null(subst <- substitute(s))) 
	par.model[['s']] <- CheckArg(s, subst, TRUE)
  if (hasArg('rho') && !is.null(subst <- substitute(rho))) 
	par.model[['rho']] <- CheckArg(rho, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMbicauchy', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMbicauchy <- new(CLASS_RM, 
	.Data = RMbicauchy,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('single variable'),
	operator = FALSE,
	monotone = 'monotone',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = 3,
	vdim = 2
	)



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))) 
	par.model[['kappa']] <- CheckArg(kappa, subst, TRUE)
  if (hasArg('mu') && !is.null(subst <- substitute(mu))) 
	par.model[['mu']] <- CheckArg(mu, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMgengneiting', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMgengneiting <- new(CLASS_RM, 
	.Data = RMgengneiting,
	type = c('positive definite', 'positive definite', 'positive definite', 'positive definite', 'positive definite', 'positive definite'),
	isotropy = c('isotropic', 'spherical isotropic', 'isotropic', 'spherical isotropic', 'isotropic', 'spherical isotropic'),
	domain = c('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))) 
	par.model[['orig']] <- CheckArg(orig, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMgneiting', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMgneiting <- new(CLASS_RM, 
	.Data = RMgneiting,
	type = c('positive definite', 'positive definite'),
	isotropy = c('isotropic', 'spherical isotropic'),
	domain = c('single variable'),
	operator = FALSE,
	monotone = 'monotone',
	finiterange = TRUE,
	simpleArguments = TRUE,
	maxdim = -1,
	vdim = 1
	)



RMgennsst <- function(phi, psi, dim_u, 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('dim_u') && !is.null(subst <- substitute(dim_u))) 
	par.model[['dim_u']] <- CheckArg(dim_u, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMgennsst', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMgennsst <- new(CLASS_RM, 
	.Data = RMgennsst,
	type = c('positive definite', 'positive definite'),
	isotropy = c('symmetric', 'symmetric'),
	domain = c('submodel dependent'),
	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))) 
	par.model[['nu']] <- CheckArg(nu, subst, TRUE)
  if (hasArg('lambda') && !is.null(subst <- substitute(lambda))) 
	par.model[['lambda']] <- CheckArg(lambda, subst, TRUE)
  if (hasArg('delta') && !is.null(subst <- substitute(delta))) 
	par.model[['delta']] <- CheckArg(delta, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMhyperbolic', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMhyperbolic <- new(CLASS_RM, 
	.Data = RMhyperbolic,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('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))) 
	par.model[['nu']] <- CheckArg(nu, subst, TRUE)
  if (hasArg('lambda') && !is.null(subst <- substitute(lambda))) 
	par.model[['lambda']] <- CheckArg(lambda, subst, TRUE)
  if (hasArg('delta') && !is.null(subst <- substitute(delta))) 
	par.model[['delta']] <- CheckArg(delta, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMiaco', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMiaco <- new(CLASS_RM, 
	.Data = RMiaco,
	type = c('positive definite'),
	isotropy = c('space-isotropic'),
	domain = c('single variable'),
	operator = FALSE,
	monotone = 'not monotone',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = Inf,
	vdim = 1
	)



RMidmodel <- 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))) 
	par.model[['vdim']] <- CheckArg(vdim, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMidmodel', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMidmodel <- new(CLASS_RM, 
	.Data = RMidmodel,
	type = c('of manifold type'),
	isotropy = c('framework dependent'),
	domain = c('single variable', 'kernel'),
	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))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMkolmogorov', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMkolmogorov <- new(CLASS_RM, 
	.Data = RMkolmogorov,
	type = c('variogram'),
	isotropy = c('vector-isotropic'),
	domain = c('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))) 
	par.model[['alpha']] <- CheckArg(alpha, subst, TRUE)
  if (hasArg('beta') && !is.null(subst <- substitute(beta))) 
	par.model[['beta']] <- CheckArg(beta, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMlgd', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMlgd <- new(CLASS_RM, 
	.Data = RMlgd,
	type = c('positive definite'),
	isotropy = c('isotropic'),
	domain = c('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))) 
	par.model[['nu']] <- CheckArg(nu, subst, TRUE)
  if (hasArg('delta') && !is.null(subst <- substitute(delta))) 
	par.model[['delta']] <- CheckArg(delta, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMmastein', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMmastein <- new(CLASS_RM, 
	.Data = RMmastein,
	type = c('positive definite'),
	isotropy = c('space-isotropic'),
	domain = c('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))) 
	par.model[['alpha']] <- CheckArg(alpha, subst, TRUE)
  if (hasArg('theta') && !is.null(subst <- substitute(theta))) 
	par.model[['theta']] <- CheckArg(theta, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMma', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMma <- new(CLASS_RM, 
	.Data = RMma,
	type = c('positive definite'),
	isotropy = c('symmetric'),
	domain = c('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))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMintexp', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMintexp <- new(CLASS_RM, 
	.Data = RMintexp,
	type = c('positive definite'),
	isotropy = c('symmetric'),
	domain = c('single variable'),
	operator = TRUE,
	monotone = 'not monotone',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = -3,
	vdim = 1
	)



RMmatrix <- function(C0, C1, C2, C3, C4, C5, C6, C7, C8, C9, M, vdim, 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('M') && !is.null(subst <- substitute(M))) 
	par.model[['M']] <- CheckArg(M, subst, TRUE)
  if (hasArg('vdim') && !is.null(subst <- substitute(vdim))) 
	par.model[['vdim']] <- CheckArg(vdim, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMmatrix', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMmatrix <- new(CLASS_RM, 
	.Data = RMmatrix,
	type = c('of manifold type'),
	isotropy = c('submodel dependent'),
	domain = c('submodel 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))) 
	par.model[['nu']] <- CheckArg(nu, subst, TRUE)
  if (hasArg('notinvnu') && !is.null(subst <- substitute(notinvnu))) 
	par.model[['notinvnu']] <- CheckArg(notinvnu, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMmatern', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMmatern <- new(CLASS_RM, 
	.Data = RMmatern,
	type = c('positive definite'),
	isotropy = c('parameter dependent'),
	domain = c('parameter dependent'),
	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))) 
	par.model[['theta']] <- CheckArg(theta, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMmqam', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMmqam <- new(CLASS_RM, 
	.Data = RMmqam,
	type = c('positive definite'),
	isotropy = c('symmetric'),
	domain = c('single variable'),
	operator = TRUE,
	monotone = 'not monotone',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = -3,
	vdim = -1
	)



RMmultiquad <- function(delta, tau, var, scale, Aniso, proj) {
  cl <- match.call()
  submodels <- par.general <- par.model <- list() 
  
  if (hasArg('delta') && !is.null(subst <- substitute(delta))) 
	par.model[['delta']] <- CheckArg(delta, subst, TRUE)
  if (hasArg('tau') && !is.null(subst <- substitute(tau))) 
	par.model[['tau']] <- CheckArg(tau, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMmultiquad', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMmultiquad <- new(CLASS_RM, 
	.Data = RMmultiquad,
	type = c('positive definite'),
	isotropy = c('spherical isotropic'),
	domain = c('single variable'),
	operator = FALSE,
	monotone = 'monotone',
	finiterange = FALSE,
	simpleArguments = TRUE,
	maxdim = 2,
	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))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general[['proj']] <- CheckMixed(proj, subst, PROJECTION_NAMES)
  model <- methods::new('RMmodel', call = cl, name = 'RMnatsc', 
  		submodels = submodels, 
  		par.model = par.model, par.general = par.general)
  return(model)
}

RMnatsc <- new(CLASS_RM, 
	.Data = RMnatsc,
	type = c('positive definite', 'tail correlation'),
	isotropy = c('isotropic', 'isotropic'),
	domain = c('single variable'),
	operator = TRUE,
	monotone = 'submodel dependent monotonicity',
	finiterange = NA,
	simpleArguments = TRUE,
	maxdim = -3,
	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))) 
	par.model[['delta']] <- CheckArg(delta, subst, TRUE)
    if (hasArg('var') && !is.null(subst <- substitute(var))) 
	par.general[['var']] <- CheckArg(var, subst, TRUE)
    if (hasArg('scale') && !is.null(subst <- substitute(scale))) 
	par.general[['scale']] <- CheckArg(scale, subst, TRUE)
    if (hasArg('Aniso') && !is.null(subst <- substitute(Aniso))) 
	par.general[['Aniso']] <- CheckArg(Aniso, subst, TRUE)
    if (hasArg('proj') && !is.null(subst <- substitute(proj))) 
	par.general