ChaoticTimeSeries          package:fSeries          R Documentation

_C_h_a_o_t_i_c _T_i_m_e _S_e_r_i_e_s _M_o_d_e_l_l_i_n_g

_D_e_s_c_r_i_p_t_i_o_n:

     A collection and description of functions to  investigate the
     chaotic behavior of time series  processes. Included are functions
     to simulate  different types of chaotic time series maps. 

     Chaotic Time Series Maps:

       'tentSim'      Simulates data from the Tent Map,
       'henonSim'     simulates data from the Henon Map,
       'ikedaSim'     simulates data from the Ikeda Map,
       'logisticSim'  simulates data from the Logistic Map,
       'lorentzSim'   simulates data from the Lorentz Map,
       'roesslerSim'  simulates data from the Roessler Map.

     Functions to Analyse Chaotic Time Series:

       'mutualPlot'      Returns mutual information,
       'falsennPlot'     returns false nearest neigbours,
       'recurrencePlot'  returns a recurrence plot,
       'separationPlot'  returns a space-time separation plot,
       'lyapunovPlot'    computes maximum lyapunov exponent.

_U_s_a_g_e:

     tentSim(n = 1000, n.skip = 100, parms = c(a = 2), start = runif(1), 
             doplot = FALSE)
     henonSim(n = 1000, n.skip = 100, parms = c(a = 1.4, b = 0.3), 
             start = runif(2), doplot = FALSE)
     ikedaSim(n = 1000, n.skip = 100, parms = c(a = 0.4, b = 6.0, c = 0.9), 
             start = runif(2), doplot = FALSE)
     logisticSim(n = 1000, n.skip = 100, parms = c(r = 4), start = runif(1), 
             doplot = FALSE)
     lorentzSim(times = seq(0, 40, by = 0.01), parms = c(sigma = 16, r = 45.92, 
             b = 4), start = c(-14, -13, 47), doplot = TRUE, ...)
     roesslerSim(times = seq(0, 100, by = 0.01), parms = c(a = 0.2, b = 0.2, c = 8.0),
             start = c(-1.894, -9.920, 0.0250), doplot = TRUE, ...)
             
     mutualPlot(x, partitions = 16, lag.max = 20, doplot = TRUE, ...)      
     falsennPlot(x, m, d, t, rt = 10, eps = NULL, doplot = TRUE, ...) 
     recurrencePlot(x, m, d, end.time, eps, nt = 10, ...)
     separationPlot(x, m, d, mdt, idt = 1, doplot = TRUE, ...)
     lyapunovPlot(x, m, d, t, ref, s, eps, k = 1, doplot = TRUE, ...) 

_A_r_g_u_m_e_n_t_s:

       d: [*Plot] - 
           an integer value setting the value of the time delay. 

     eps: [falsennPlot] - 
           a numeric value setting the value of the neighbour diameter.
          If NULL, which is the default value, then the value will be
          automatically setted to 'eps=sd(x)/10'. 
           [lyapunovPlot] - 
           the radius where to find nearest neighbours. 
           [recurrencePlot] - 
           the neighbourhood threshold. 

  doplot: a logical flag. Should a plot be displayed? [*Plot] - 
           By default TRUE. 
           [*Sim] - 
           By default TRUE. 

end.time: [recurrencePlot] - 
           ending time as number of observations. 

     idt: [separationPlot] - 
           an integer value setting the number of observation steps in
          each iterations. By default 1. 

       k: [lyapunovPlot] - 
           an integer setting th enumber of considered neighbours. By
          default 1. 

 lag.max: [mutualPlot] - 
           an integer value setting the number of maximum lags, by 
          default 20. 

       m: [*Plot] - 
           an integer value setting the value of the maximum embedding 
          dimension. 

     mdt: [separationPlot] - 
           an integer value setting the number of iterations. 

n, n.skip: [henonSim][ikedaSim][logisticSim] - 
           the number of chaotic time series points to be generated and
          the  number of initial values to be skipped from the series.  

      nt: [recurrencePlot] - 
           observations in each step which will be plotted, by default
          10. Increasing 'nt' reduces number of points plotted which is
          usefule especially with highly sampled data. 

   parms: the named parameter vector characterizing the chaotic map. 

      rt: [falsennPlot] - 
           an integer value setting the value for the escape factor. By
          default 10. 

partitions: [mutualPlot] - 
           an integer value setting the number of bins, by default 16. 

     ref: [lyapunovPlot] - 
           the number of points to take into account. 

       s: [lyapunovPlot] - 
           the iterations along which follow the neighbours of each
          point. 

   start: the vector of start values to initiate the chaotic map. 

       t: [*Plot] - 
           an integer value setting the value for the Theiler window. 

   times: [lorentzSim][roesslerSim] - 
           the sequence of time series points at which to generate the
          map.  

       x: [*Plot] - 
           a numeric vector, or an object either of class 'ts' or of
          class 'timeSeries'. 

     ...: arguments to be passed. 

_D_e_t_a_i_l_s:

     *Phase Space Representation:* 

        The function 'mutualPlot' estimates and plots the mutual 
     information index of a given time series for a specified number 
     of lags. The joint probability distribution function is estimated 
     with a simple bi-dimensional density histogram. 
           The function 'falsennPlot' uses the Method of false nearest 
     neighbours to help deciding the optimal embedding dimension. 

     *Non-Stationarity:* 

      The funcdtion 'recurrencePlot' creates a recurrence plot as 
     proposed by Eckmann et al. [1987].  
      The function 'separationPlot' creates a space-time separation
     plot qs introduced by Provenzale et al. [1992]. It plots the 
     probability that two points in the reconstructed phase-space have 
     distance smaller than epsilon in function of epsilon and of the 
     time between the points, as iso-lines at levels 10, 20, ..., 100
     percent levels. The plot can be used to decide the Theiler time 
     window. 

     *Lyapunov Exponents:* 

      The function 'lyapunovPlot' evaluates and plots the largest 
     Lyapunov exponent of a dynamic system from a univariate time
     series. The estimate of the Lyapunov exponent uses the algorithm
     of Kantz. In addition, the function computes the regression
     coefficients of  a user specified segment of the sequence given as
     input.  

     *Dimensions and Entropies:* 

      The function 'C2' computes the sample correlation integral on 
     the provided time series for the specified length scale and 
     Theiler window. It uses a naiv algorithm: simply returns the 
     fraction of points pairs nearer than eps. It is prefarable to use 
     the function 'd2', which takes roughly the same time, but 
     computes the correlation sum for multiple length scales and 
     embedding dimensions at once. 
      The function 'd2' computes the sample correlation integral  over
     given length scales 'neps' for embedding dimensions  '1:m' for a
     given Theiler window. The slope of the linear  segment in the
     log-log plot gives an estimate of the correlation  dimension.

_V_a_l_u_e:

     [*Sim] - 
      All functions return invisible a vector of time series data.

_A_u_t_h_o_r(_s):

     Diethelm Wuertz for the Rmetrics R-port.

_R_e_f_e_r_e_n_c_e_s:

     Brock, W.A., Dechert W.D., Sheinkman J.A. (1987);  _A Test of
     Independence Based on the Correlation  Dimension_,  SSRI no. 8702,
     Department of Economics, University of  Wisconsin, Madison.

     Eckmann J.P., Oliffson Kamphorst S., Ruelle D. (1987), 
     _Recurrence plots of dynamical systems_,  Europhys. Letters 4,
     973.

     Hegger R., Kantz H., Schreiber T. (1999); _Practical
     implementation of nonlinear time series  methods: The TISEAN
     package_, CHAOS 9, 413-435.

     Kennel M.B., Brown R., Abarbanel H.D.I. (1992);  _Determining
     embedding dimension for phase-space  reconstruction using a
     geometrical construction_,  Phys. Rev. A45, 3403. 

     Rosenstein M.T., Collins J.J., De Luca C.J. (1993); _A practical
     method for calculating largest Lyapunov  exponents from small data
     sets_,  Physica D 65, 117.

_S_e_e _A_l_s_o:

     'RandomInnovations'.

_E_x_a_m_p_l_e_s:

     ## SOURCE("fSeries1.35A-ChaoticTimeSeries")

     ## bdsTest -
        xmpSeries("\nNext: Brock-Dechert-Sheinkman Test for iid Series >")
        # iid Time Series:
        par(mfrow = c(3, 1))
        x = rnorm(100)
        plot(x, type = "l", main = "iid Time Series")
        bdsTest(x, m = 3)
        # Non Identically Distributed Time Series:
        x = c(rnorm(50), runif(50))
        plot(x, type = "l", main = "Non-iid Time Series")
        bdsTest(x, m = 3)  
        # Non Independent Innovations from Quadratic Map:
        x = rep(0.2, 100)
        for (i in 2:100) x[i] = 4*(1-x[i-1])*x[i-1]
        plot(x, type = "l", main = "Quadratic Map")
        bdsTest(x, m = 3)
        
     ## tnnTest -
        xmpSeries("\nNext: Teraesvirta NN test for Neglected Nonlinearity >")
        # Time Series Non-linear in "mean" regression 
        par(mfrow = c(2, 1))
        n = 1000
        x = runif(1000, -1, 1)  
        tnnTest(x)
        # Generate time series which is nonlinear in "mean"
        x[1] = 0.0
        for (i in (2:n)) {
          x[i] = 0.4*x[i-1] + tanh(x[i-1]) + rnorm (1, sd = 0.5) }
        plot(x, main = "Teraesvirta Test", type = "l")
        tnnTest(x)
        
     ## wnnTest -
        xmpSeries("\nNext: White NN test for Neglected Nonlinearity >")
        # Time Series Non-Linear in "mean" Regression
        par(mfrow = c(2, 1))
        n = 1000
        x = runif(1000, -1, 1)
        wnnTest(x)
        # Generate time series which is nonlinear in "mean"
        x[1] = 0.0
        for (i in (2:n)) {
          x[i] = 0.4*x[i-1] + tanh(x[i-1]) + rnorm (1, sd = 0.5) }
        plot(x, main = "White Test", type = "l")
        wnnTest(x)                     

