RFMethods            package:RandomFields            R Documentation

_S_i_m_u_l_a_t_i_o_n _T_e_c_h_n_i_q_u_e_s

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

     `PrintMethodList' prints the list of currently implemented methods
     for simulating random fields

     `GetMethodNames' returns a list of currently implemented methods

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

     PrintMethodList()

     GetMethodNames()

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

        *  Boolean functions.
           See marked point processes.

        *  `circulant embedding'. 
           Introduced by Dietrich & Newsam (1993) and Wood and Chan
           (1994).  The way the method is implemented in this package
           it only allows for quadratic grids with common grid lengths.

        *  `direct matrix decomposition'.
           This method is based on the well-known method for simulating
           any multivariate Gaussian distribution, using the square
           root of the covariance matrix.  The method is pretty slow
           and limited to about 1000 points, i.e. a 10x10x10 grid in
           three dimensions.  This implementation can use the Cholesky
           decomposition and the singular value decomposition.  It
           allows for arbitrary points and arbitrary grids.

        *  Marked point processes.
           Some methods are based on marked point process P =
           ([x_1,m_1], [x_2,m_2], ...) where the marks m_i are
           deterministic or i.i.d. random functions on R^d.

           *  `add.MPP' (Random coins).
              Here the functions are elements of the intersection (L1
              cap L2) of the Hilbert spaces L1 and L2. A random field Z
              is obtained by adding the marks:

                     Z(.) = sum_i  m_i( . - x_i)

              In this package, only stationary Poisson point fields are
              allowed as underlying unmarked point processes. Thus, if
              the marks m_i are all indicator functions, we obtain a
              Poisson random field. If the intensity of the Poisson
              process is high we obtain an approximate Gaussian random
              field by the central limit theorem - this is the
              `add.mpp' method.

           *  `max.MPP' (Boolean functions).
              If the random functions are multiplied by suitable,
              independent random values, and then the maximum is taken,
              a max-stable random field with unit Frechet margins is
              obtained - this is the `max.mpp' method.


        *  `nugget'.
           One may specify this method (and "nugget" as covariance
           function) to generate a random field of independent Gaussian
           random variables.  However, any other method and any
           covariance function, called with zero variance, generates
           also such a random field (without loss of speed).  This
           method exists mainly for reasons of internal implementation.

        *  Random coins.
           See marked point processes.

        *  `spectral TBM' (Spectral turning bands).
           The principle of `spectral TBM' does not differ from the
           other turning bands methods.  However, line simulations are
           performed by a spectral technique (Mantoglou and Wilson,
           1982); a realisation is given as the cosine with random
           amplitude and random phase.    The implementation allows the
           simulation of 2-dimensional random fields defined on
           arbitrary points or arbitrary grids.

        *  `TBM2', `TBM3' (Turning bands methods).
           It is generally difficult to use the turning bands method
           (`TBM2') directly in the 2-dimensional space. Instead,
           2-dimensional random fields are frequently obtained by
           simulating a 3-dimensional random field (using `TBM3') and
           taking a 2-dimensional cross-section.
           `TBM2' and `TBM3' allow for arbitrary points, and arbitrary
           grids (arbitrary number of points in each direction,
           arbitrary grid length for each direction)

_N_o_t_e:

     Most methods possess additional parameters, see `RFparameters()'
     that control the precision of the result.  The default parameters
     are chosen such that the simulations are fine for many models and
     their parameters.  The example in `EmpiricalVariogram()' shows a
     way of checking the precision.

_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:

     Gneiting, T. and Schlather, M. (2001) Statistical modeling with
     covariance functions. In preparation.

     Schlather, M. (1999) An introduction to positive definite
     functions and to unconditional simulation of random fields.
     Technical report ST 99-10, Dept. of Maths and Statistics,
     Lancaster University. 

     Original work:

        *  Circulant embedding:

           Chan, G. and Wood, A.T.A. (1997) An algorithm for simulating
           stationary Gaussian random fields. J. R. Stat. Soc., Ser. C
           46, 171-181.

           Dietrich, C.R. and Newsam, G.N. (1993) A fast and exact
           method for multidimensional Gaussian stochastic simulations.
           Water Resour. Res. 29, 2861-2869.    

           Wood, A.T.A. and Chan, G. (1994) Simulation of stationary
           Gaussian processes in [0,1]^d J. Comput. Graph. Stat. 3,
           409-432.

        *  Turning bands method (TBM):

           Dietrich, C.R. (1995) A simple and efficient space domain
           implementation of the turning bands method. Water Resour.
           Res. 31, 147-156.

           Mantoglou, A. and Wilson, J.L. (1982) The turning bands
           method for simulation of random fields using line generation
           by a spectral method. Water. Resour. Res. 18, 1379-1394.

           Matheron, G. (1973) The intrinsic random functions and their
           applications. Adv. Appl. Probab. 5, 439-468.

        *  Random coins:

           Matheron, G. (1967) Elements pour une Theorie des Milieux
           Poreux. Paris: Masson.

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

     `GaussRF', `MaxStableRF', and `RandomFields'.

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

      PrintMethodList()

