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', see Details.

   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', or be
          given in one of the extended forms, see Details

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.

           The model may be defined alternatively in one of the two
           extended ways as introduced in 'CovarianceFct' and
           'GaussRF'. However only a single model may be given! The
           model may be anisotropic.

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

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

     'MaxStableRF' and 'DoSimulateRF' return 'NULL' if an error has
     occurred; 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@cu.lu <URL:
     http://www.cu.lu/~schlathe>

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

     Schlather, M. (2002) Models for stationary max-stable random
     fields. _Extremes_ *5*, 33-44.

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

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

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

      n <- 30 ## nicer, but time consuming if 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)

