MaxStableRF           package:RandomFields           R Documentation

_M_a_x-_S_t_a_b_l_e _R_a_n_d_o_m _F_i_e_l_d_s

_D_e_s_c_r_i_p_t_i_o_n:

     These functions simulate stationary and isotropic max-stable
     random fields with unit Frechet margins.

_U_s_a_g_e:

     MaxStableRF(x, y=NULL, z=NULL, grid, model, param, maxstable,
                 method=NULL, n=1, register=0, gridtriple=FALSE)

     InitMaxStableRF(x, y=NULL, z=NULL, grid, model, param, maxstable,
                    method=NULL, register=0, gridtriple=FALSE)

_A_r_g_u_m_e_n_t_s:

       x: matrix of coordinates, or vector of x coordinates

       y: vector of y coordinates

       z: vector of z coordinates

    grid: logical; determines whether the vectors `x', `y', and `z'
          should be interpreted as a grid definition, see Details.

   model: string; see `CovarianceFct', or type `PrintModelList()' to
          get all options; interpretation depends on the value of
          `maxstable'

   param: parameter vector: `param=c(mean, variance, nugget,
          scale,...)'; the parameters must be given in this order;
          further parameters are to be added in case of a parametrised
          class of covariance functions, see `CovarianceFct'

maxstable: string. Either `"extremalGauss"' or `"BooleanFunction"'; see
          Details.

  method: `NULL' or string; method used for simulating, see
          `RFMethods', or type `PrintMethodList()' to get all options;
          interpretation depends on the value of `maxstable'.

       n: number of realisations to generate

register: 0:9; place where intermediate calculations are stored; the
          numbers are aliases for 10 internal registers

gridtriple: logical;  if `gridtriple==FALSE' ascending sequences for
          the parameters  `x', `y', and `z' are expected; if
          `gridtriple==TRUE' triples of form `c(start,end,step)' 
          expected; this parameter is used only if `grid==TRUE'

_D_e_t_a_i_l_s:

     There are two different kinds of models for max-stable processes
     implemented:

        *  `maxstable="extremalGauss"'
           Gaussian random fields are multiplied by independent random
           factors, and the maximum is taken. The random factors are
           such that the resulting random field has unit Frechet
           margins; the specification of the random factor is uniquely
           given by the specification of the random field. The
           parameter vector `param', the `model', and the `method' are
           interpreted in the same way as for Gaussian random fields,
           see `GaussRF'.

        *  `maxstable="BooleanFunction"'
           Deterministic or random, upper semi-continuous L1-functions
           are randomly centred and multiplied by suitable, independent
           random factors; the pointwise maximum over all these
           functions yields a max-stable random field. The simulation
           technique is related to the random coin method for Gaussian
           random field simulation, see `RFMethods'. Hence, only models
           that are suitable for the random coin method are suitable
           for this technique, see `PrintModelList()' for a complete
           list of suitable covariance models.
           The only value allowed for `method' is `"max.MPP"' (and
           `NULL'), see `PrintMethodList()'. In the parameter list
           `param' the first two entries, namely `mean' and `variance',
           are ignored. If the nugget is positive, for each point an
           additional independent unit Frechet variable with scale
           parameter `nugget' is involved when building the maximum
           over all functions.

_V_a_l_u_e:

     `InitMaxStableRF' returns 0 if no error has occured, and a
     positive value if failed.

     `MaxStableRF' and `DoSimulateRF' return `NULL' if an error has
     occured; otherwise the returned object depends on the parameters:
     `n==1':
     * `grid==FALSE'.  A vector of simulated values is returned
     (independent of the dimension of the random field)
     * `grid==TRUE'.  An array of the dimension of the random field is
     returned.

     `n>1':
     * `grid==FALSE'.  A matrix is returned.  The columns contain the
     repetitions.
     * `grid==TRUE'.  An array of dimension d+1, where d is the
     dimension of the random field, is returned.  The last dimension
     contains the repetitions.

_A_u_t_h_o_r(_s):

     Martin Schlather, Martin.Schlather@uni-bayreuth.de <URL:
     http://www.geo.uni-bayreuth.de/~martin>

_R_e_f_e_r_e_n_c_e_s:

     Schlather, M. (2001) Models for stationary max-stable random
     fields. Submitted.

_S_e_e _A_l_s_o:

     `CovarianceFct', `GaussRF', `RandomFields', `RFMethods',
     `RFparameters', `DoSimulateRF', .

_E_x_a_m_p_l_e_s:

      n <- 100
      x <- y <- 1:n
      ms <- MaxStableRF(x, y, grid=TRUE, model="exponen",
                      param=c(0,1,0,40), maxstable="extr")
      image(x,y,ms)

