Package 'quantspec'

Description

Methods to determine, smooth and plot quantile periodograms for univariate and (since v1.2-0) multivariate time series.

Details

Contents

The quantspec package contains a hierachy of S4 classes with corresponding methods and functions serving as constructors. The following class diagrams provide an overview on the structure of the package. In the first and second class diagram the classes implementing the estimators are shown. In the first diagram the classes related to periodogram-based estimation are displayed:

In the second diagram the classes related to lag window-based estimation are displayed:

In the third class diagram the classes implementing model quantities are displayed. A relation to the “empirical classes” is given via the fact that the quantile spectral densities are computed by simulation of quantile periodograms and a common abstract superclass QSpecQuantity which is used to provide a common interface to quantile spectral quantities.

Besides the object-oriented design a few auxiliary functions exists. They serve as parameters or are mostly for internal use. A more detailed description of the framework can be found in the paper on the package (Kley, 2016).

Organization of the source code / files in the /R folder

All of the source code related to the specification of a certain class is contained in a file named Class-[Name_of_the_class].R. This includes, in the following order,

1. all roxygen @include to insure the correctly generated collate for the DESCRIPTION file.

2. \setClass preceded by a meaningful roxygen documentation.

3. specification of an initialize method, where appropriate.

4. all accessor and mutator method (i. e., getter and setter); first the ones returning attributes of the object, then the ones returning associated objects.

5. constructors; use generics if there is more than one of them.

6. show and plot methods.

Coding Conventions

To improve readability of the software and documentation this package was written in the spirit of the “Coding conventions of the Java Programming Language” (Oracle, 2015). In particular, the naming conventions for classes and methods have been adopted, where “Class names should be nouns, in mixed case with the first letter of each internal word capitalized.” and “Methods should be verbs, in mixed case with the first letter lowercase, with the first letter of each internal word capitalized.”

Naming Conventions for the Documentation

To reflect the structure of the contents of the package in the documentation file, the following system for naming of the sections is adopted:

• Documentation of an S4 class is named as the name of the class followed by “-class”. [cf. QuantilePG-class]

• Documentation of a constructor for an S4-class is named as the name of the class followed by “-constructor”. [cf. QuantilePG-constructor]

• Documentation of a method dispaching to an object of a certain S4 class is named by the name of the method, followed by “-”, followed by the name of the Class. [cf. getValues-QuantilePG]

Author(s)

Tobias Kley

References

Kley, T. (2014a). Quantile-Based Spectral Analysis: Asymptotic Theory and Computation. Ph.D. Dissertation, Ruhr University Bochum. http://www-brs.ub.ruhr-uni-bochum.de/netahtml/HSS/Diss/KleyTobias/.

Kley, T. (2016). Quantile-Based Spectral Analysis in an Object-Oriented Framework and a Reference Implementation in R: The quantspec Package. Journal of Statistical Software, 70(3), 1–27.

Dette, H., Hallin, M., Kley, T. & Volgushev, S. (2015). Of Copulas, Quantiles, Ranks and Spectra: an $L_1$-approach to spectral analysis. Bernoulli, 21(2), 781–831. [cf. http://arxiv.org/abs/1111.7205]

Kley, T., Volgushev, S., Dette, H. & Hallin, M. (2016). Quantile Spectral Processes: Asymptotic Analysis and Inference. Bernoulli, 22(3), 1770–1807. [cf. http://arxiv.org/abs/1401.8104]

Barunik, J. & Kley, T. (2015). Quantile Cross-Spectral Measures of Dependence between Economic Variables. [cf. http://arxiv.org/abs/1510.06946]

Oracle (2015). Coding conventions of the Java Programming Language. http://www.oracle.com/technetwork/java/codeconvtoc-136057.html. Accessed 2015-03-25.

Description

BootPos is an S4 class that provides a common interface to different algorithms that can be used for implementation of a block bootstrap procedure in the time domain.

Details

After initialization the bootstrapping can be performed by applying getPositions to the object.

Different block bootstraps are implemented by creating a subclass together with a getPositions method that contains the implementation of the block resampling procedure.

Currently the following implementations are available:

• MovingBlocks and getPositions-MovingBlocks.

Slots

l

the (expected) block length for the block bootstrap methods

N

number of available observations to bootstrap from

References

Lahiri, S. N. (1999). Theoretical Comparisons of Block Bootstrap Methods. The Annals of Statistics, 27(1), 386–404.

Class to calculate copula covariances from a time series with given levels. Calculates for each combination of levels $(\tau_1,\tau_2)$ and for all $k < \code{maxLag}$ the copula covariances $Cov(1_{X_0 < \tau_1},1_{X_k < \tau_2})$ and writes it to values[k] from its superclass LagOperator.

Description

For each lag k = 0, ..., maxLag and combination of levels $(\tau_1, \tau_2)$ from levels.1 x levels.2 the statistic

$\frac{1}{n} \sum_{t=1}^{n-k} ( I\{\hat F_n(Y_t) \leq \tau_1\} - \tau_1) ( I\{\hat F_n(Y_{t+k}) \leq \tau_2\} - \tau_2)$

is determined and stored to the array values.

Details

Currently, the implementation of this class allows only for the analysis of univariate time series.

Create an instance of the ClippedCov class.

Description

Create an instance of the ClippedCov class.

Usage

clippedCov(Y, maxLag = length(Y) - 1, levels.1 = c(0.5),
  levels.2 = levels.1, isRankBased = TRUE, B = 0, l = 0,
  type.boot = c("none", "mbb"))

Arguments

Value

Returns an instance of ClippedCov.

See Also

LagOperator

Examples

ccf <- clippedCov(rnorm(200), maxLag = 25, levels.1 = c(0.1,0.5,0.9))
dim(getValues(ccf))
#print values for levels (.5,.5)
plot(ccf, maxLag = 20)

Description

ClippedFT is an S4 class that implements the necessary calculations to determine the Fourier transform of the clipped time series. As a subclass to FreqRep it inherits slots and methods defined there; it servers as a frequency representation of a time series as described in Kley et. al (2016) for univariate time series and in Barunik & Kley (2015) for multivariate time series.

Details

For each frequency $\omega$ from frequencies and level q from levels the statistic

$\sum_{t=0}^{n-1} I\{Y_{t,i} \leq q\} \mbox{e}^{-\mbox{i} \omega t}$

is determined and stored to the array values. Internally the methods mvfft and fft are used to achieve good performance.

Note that, all remarks made in the documentation of the super-class FreqRep apply.

References

Kley, T., Volgushev, S., Dette, H. & Hallin, M. (2016). Quantile Spectral Processes: Asymptotic Analysis and Inference. Bernoulli, 22(3), 1770–1807. [cf. http://arxiv.org/abs/1401.8104]

Barunik, J. & Kley, T. (2015). Quantile Cross-Spectral Measures of Dependence between Economic Variables. [preprint available from the authors]

See Also

For an example see FreqRep.

Create an instance of the ClippedFT class.

Description

The parameter type.boot can be set to choose a block bootstrapping procedure. If "none" is chosen, a moving blocks bootstrap with l=lenTS(Y) and N=lenTS(Y) would be done. Note that in that case one would also chose B=0 which means that getPositions would never be called. If B>0 then each bootstrap replication would be the undisturbed time series.

Usage

clippedFT(Y, frequencies = 2 * pi/lenTS(Y) * 0:(lenTS(Y) - 1), levels = 0.5,
  isRankBased = TRUE, B = 0, l = 0, type.boot = c("none", "mbb"))

Arguments

Value

Returns an instance of ClippedFT.

See Also

For an example see FreqRep.

Description

For two vectors X and Y a vector of indices I is returned, such that length(Y) and length(I) coincide and X[I[j]] is an element of X which has minimal distance to Y[j], for all j=1,...,length(Y). In case that there are multiple elements with minimal distance, the smallest index (the index of the first element with minimal distance) is returned.

Usage

closest.pos(X, Y)

Arguments

Value

Returns a vector of same length as X, with indices indicating which element in Y is closest.

Examples

X1 <- c(1,2,3)
closest.pos(X1, 1.7)
closest.pos(X1, c(1.3,2.2))

X2 <- c(2,1,3)
closest.pos(X2, 1.5)

Description

Contains the returns of the S&P 500 stock index for the years 2007–2010. The returns were computed as (Adjusted.Close-Open)/Open.

Format

A univariate time series with 1008 observations; a zoo object

Details

The data was downloaded from the Yahoo! Finance Website.

References

Yahoo! Finance Website http://finance.yahoo.com/q/hp?s=^GSPC+Historical+Prices

Examples

plot(sp500)

Description

Contains a detrended and demeaned version of the well-known Beveridge Wheat Price Index which gives annual price data from 1500 to 1869, averaged over many locations in western and central Europe [cf. Beveridge (1921)]. The index series $x_t$ was detrended as proposed by Granger (1964), p. 21, by letting

$y_t := \frac{x_t}{\sum_{j=-15}^{15} x_{t+j}},$

where $x_t := x_1, t < 1$ and $x_t := x_n, t > n$. The time series in the data set is also demeaned by letting

$z_t := y_t - n^{-1} \sum_{t=1}^n y_t.$

Format

A univariate time series $(z_t)$ with 370 observations; a ts object.

Details

The index data cited in Beveridge's paper was taken from bev in the tseries package.

References

Beveridge, W. H. (1921). Weather and Harvest Cycles. The Economic Journal, 31(124):429–452.

Granger, C. W. J. (1964). Spectral Analysis of Economic Time Series. Princeton University Press, Princeton, NJ.

Examples

plot(wheatprices)

Description

FreqRep is an S4 class that encapsulates, for a multivariate time series $(Y_{t,i})_{t=0,\ldots,n-1}$, $i=1,\ldots,d$ the data structures for the storage of a frequency representation. Examples of such frequency representations include

• the Fourier transformation of the clipped time series $(\{I\{Y_{t,i} \leq q\})$, or

• the weighted $L_1$-projection of $(Y_{t,i})$ onto an harmonic basis.

Examples are realized by implementing a sub-class to FreqRep. Currently, implementations for the two examples mentioned above are available: ClippedFT and QRegEstimator.

Details

It is always an option to base the calculations on the pseudo data $R_{t,n,i} / n$ where $R_{t,n,i}$ denotes the rank of $Y_{t,i}$ among $(Y_{t,i})_{t=0,\ldots,n-1}$.

To allow for a block bootstrapping procedure a number of B estimates determined from bootstrap replications of the time series which are yield by use of a BootPos-object can be stored on initialization.

The data in the frequency domain is stored in the array values, which has dimensions (J,P,K,B+1), where J is the number of frequencies, P is the dimension of the time series, K is the number of levels and B is the number of bootstrap replications requested on intialization. In particular, values[j,i,k,1] corresponds to the time series' frequency representation with frequencies[j], dimension i and levels[k], while values[j,i,k,b+1] is the for the same, but determined from the bth block bootstrapped replicate of the time series.

Slots

Y

The time series of which the frequency representation is to be determined.

frequencies

The frequencies for which the frequency representation will be determined. On initalization frequenciesValidator is called, so that it will always be a vector of reals from $[0,\pi]$. Also, only Fourier frequencies of the form $2\pi j / n$ with integers $j$ and $n$ the length(Y) are allowed.

levels

The levels for which the frequency representation will be determined. If the flag isRankBased is set to FALSE, then it can be any vector of reals. If isRankBased is set to TRUE, then it has to be from $[0,1]$.

values

The array holding the determined frequency representation. Use a getValues method of the relevant subclass to access it.

isRankBased

A flag that is FALSE if the determined values are based on the original time series and TRUE if it is based on the pseudo data as described in the Details section of this topic.

positions.boot

An object of type BootPos, that is used to determine the block bootstrapped replicates of the time series.

B

Number of bootstrap replications to perform.

Examples

Y       <- rnorm(32)
freq    <- 2*pi*c(0:31)/32 
levels  <- c(0.25,0.5,0.75)
cFT     <- clippedFT(Y, freq, levels)

plot(cFT)

# Get values for all Fourier frequencies and all levels available.
V.all    <- getValues(cFT)

# Get values for every second frequency available
V.coarse <- getValues(cFT, frequencies = 2*pi*c(0:15)/16, levels = levels)

# Trying to get values on a finer grid of frequencies than available will
# yield a warning and then all values with frequencies closest to that finer
# grid.
V.fine   <- getValues(cFT, frequencies = 2*pi*c(0:63)/64, levels = levels)

# Finally, get values for the available Fourier frequencies from [0,pi] and
# only for tau=0.25
V.part   <- getValues(cFT, frequencies = 2*pi*c(0:16)/32, levels = c(0.25))

# Alternatively this can be phrased like this:
V.part.alt <- getValues(cFT, frequencies = freq[freq <= pi], levels = c(0.25))

Description

Validation of the parameter freq is perfomed in six steps:

1. Throw an error if parameter is not a vector or not numeric.

2. Transform each element $\omega$ of the vector to $[0,2\pi)$, by replacing it with $\omega \, \mbox{mod} \, 2\pi$.

3. Check whether all elements $\omega$ of the vector are Fourier frequency $2 \pi j / T$, $j \in Z$. If this is not the case issue a warning and round each frequency to the next Fourier frequency of the mentioned type; the smaller one, if there are two.

4. Transform each element $\omega$ with $\pi < \omega < 2\pi$ of the vector to $[0,\pi]$, by replacing it with $2\pi - \omega$.

5. Check for doubles and remove all but the first appearance.

6. Sort in ascending order.

Any subset of the six steps can be chosen, but 1 should almost always be among the steps to be performed.

Usage

frequenciesValidator(freq, N, steps = 1:6)

Arguments

Value

Returns a vector of Fourier frequencies that is yield by the transformations described above.

Examples

freq <- 2*pi*c(3,2,5,8,9)/10

res <- frequenciesValidator(freq, N=10, steps=1:3)
res * 10 / (2*pi) # Returns: [1] 3 2 5 8 9

res <- frequenciesValidator(freq, N=10, steps=1:4)
res * 10 / (2*pi) # Returns: [1] 3 2 5 2 1

res <- frequenciesValidator(freq, N=10, steps=1:5)
res * 10 / (2*pi) # Returns: [1] 3 2 5 1

res <- frequenciesValidator(freq, N=10, steps=1:6)
res * 10 / (2*pi) # Returns: [1] 1 2 3 5

Description

These generic functions are needed to access the objects' attributes. Note that the naming convention getAttribute was applied, where attribute is the name of the attribute/slot of the class of the object.

Usage

getY(object, ...)

getValues(object, ...)

getCoherency(object, ...)

getIsRankBased(object, ...)

getB(object, ...)

getLagOperator(object, ...)

getMaxLag(object, ...)

getParallel(object, ...)

getFrequencies(object, ...)

getLevels(object, ...)

getMeanPG(object, ...)

getStdError(object, ...)

getN(object, ...)

getR(object, ...)

getType(object, ...)

getTs(object, ...)

getCoherencySdNaive(object, ...)

getSdNaive(object, ...)

getSdBoot(object, ...)

getPointwiseCIs(object, ...)

getDescr(object, ...)

getW(object, ...)

getBw(object, ...)

getWnj(object, ...)

Arguments

See Also

For an overview on the classes of the framework, and all of their attributes, see the class diagrams in the package description [cf. quantspec-package].

Description

These generic functions are needed to access the objects' associated objects. Note that the naming convention getAssociatedObject was applied, where AssociatedObject is the name of the class of the associated object.

Usage

getQuantilePG(object, ...)

getBootPos(object, ...)

getFreqRep(object, ...)

getQuantileSD(object, ...)

getWeight(object, ...)

Arguments

See Also

For an overview on the classes of the framework, and all associations, see the class diagrams in the package description [cf. quantspec-package].

Description

These generic functions need to be defined to allow for the automatic dispaching mechanism.

Usage

increasePrecision(object, ...)

getPositions(object, ...)

Arguments

See Also

For an overview on the classes of the framework, and all of their methods, see the class diagrams in the package description [cf. quantspec-package].

Get B from a FreqRep object.

Description

Get B from a FreqRep object.

Usage

## S4 method for signature 'FreqRep'
getB(object)

Arguments

Value

Returns the attribute B that's a slot of object.

Get B from a LagOperator object.

Description

Get B from a LagOperator object.

Usage

## S4 method for signature 'LagOperator'
getB(object)

Arguments

Value

Returns the attribute B that's a slot of object.

Get associated BootPos from a FreqRep.

Description

Get associated BootPos from a FreqRep.

Usage

## S4 method for signature 'FreqRep'
getBootPos(object)

Arguments

Value

Returns the BootPos object associated.

Get associated BootPos from a LagOperator.

Description

Get associated BootPos from a LagOperator.

Usage

## S4 method for signature 'LagOperator'
getBootPos(object)

Arguments

Value

Returns the BootPos object associated.

Description

Get attribute bw (bandwidth / scaling parameter used for smoothing) from a KernelWeight.

Usage

## S4 method for signature 'KernelWeight'
getBw(object)

Arguments

Value

Returns the bw attribute.

Description

Get attribute bw (bandwidth / scaling parameter used for smoothing) from a LagKernelWeight.

Usage

## S4 method for signature 'LagKernelWeight'
getBw(object)

Arguments

Value

Returns the bw attribute.

Description

Returns quantile coherency defined as

$\frac{f^{j_1, j_2}(\omega; \tau_1, \tau_2)}{(f^{j_1, j_1}(\omega; \tau_1, \tau_1) f^{j_2, j_2}(\omega; \tau_2, \tau_2))^{1/2}}$

where $f^{j_1, j_2}(\omega; \tau_1, \tau_2)$ is the quantile spectral density.

Usage

## S4 method for signature 'QuantileSD'
getCoherency(object, frequencies = 2 * pi *
  (0:(object@N - 1))/object@N, levels.1 = getLevels(object, 1),
  levels.2 = getLevels(object, 2), d1 = 1:(dim(object@values)[2]),
  d2 = 1:(dim(object@values)[4]))

Arguments

Details

For the mechanism of selecting frequencies, dimensions and/or levels see, for example, getValues-QuantileSD.

Value

Returns data from the coherency as defined in the details.

See Also

For examples on how to use this function go to QuantileSD.

Description

Returns quantile coherency defined as

$\frac{G^{j_1, j_2}(\omega; \tau_1, \tau_2)}{(G^{j_1, j_1}(\omega; \tau_1, \tau_1) G^{j_2, j_2}(\omega; \tau_2, \tau_2))^{1/2}}$

where $G^{j_1, j_2}(\omega; \tau_1, \tau_2)$ is the smoothed quantile periodogram.

Usage

## S4 method for signature 'SmoothedPG'
getCoherency(object, frequencies = 2 * pi *
  (0:(lenTS(object@qPG@freqRep@Y) - 1))/lenTS(object@qPG@freqRep@Y),
  levels.1 = getLevels(object, 1), levels.2 = getLevels(object, 2),
  d1 = 1:(dim(object@values)[2]), d2 = 1:(dim(object@values)[4]))

Arguments

Details

For the mechanism of selecting frequencies, dimensions and/or levels see, for example, getValues-SmoothedPG.

Value

Returns data from the array values that's a slot of object.

See Also

An example on how to use this function is analogously to the example given in getValues-QuantilePG.

Description

Determines and returns an array of dimension [J,K1,K2], where J=length(frequencies), K1=length(levels.1), and K2=length(levels.2)). Whether available or not, boostrap repetitions are ignored by this procedure. At position (j,k1,k2) the returned value is the standard deviation estimated corresponding to frequencies[j], levels.1[k1] and levels.2[k2] that are closest to the frequencies, levels.1 and levels.2 available in object; closest.pos is used to determine what closest to means.

Usage

## S4 method for signature 'SmoothedPG'
getCoherencySdNaive(object, frequencies = 2 * pi *
  (0:(lenTS(object@qPG@freqRep@Y) - 1))/lenTS(object@qPG@freqRep@Y),
  levels.1 = getLevels(object, 1), levels.2 = getLevels(object, 2),
  d1 = 1:(dim(object@values)[2]), d2 = 1:(dim(object@values)[4]),
  type = c("1", "2"), impl = c("R", "C"))

Arguments

Details

If not only one, but multiple time series are under study, the dimension of the returned vector is of dimension [J,P,K1,P,K2], where P denotes the dimension of the time series.

Requires that the SmoothedPG is available at all Fourier frequencies from $(0,\pi]$. If this is not the case the missing values are imputed by taking one that is available and has a frequency that is closest to the missing Fourier frequency; closest.pos is used to determine which one this is.

A precise definition on how the standard deviations of the smoothed quantile periodogram are estimated is given in Barunik and Kley (2015). The estimate returned is denoted by $\sigma(\tau_1, \tau_2; \omega)$ on p. 26 of the arXiv preprint.

Note the “standard deviation” estimated here is not the square root of the complex-valued variance. It's real part is the square root of the variance of the real part of the estimator and the imaginary part is the square root of the imaginary part of the variance of the estimator.

Value

Returns the estimate described above.

References

Kley, T., Volgushev, S., Dette, H. & Hallin, M. (2016). Quantile Spectral Processes: Asymptotic Analysis and Inference. Bernoulli, 22(3), 1770–1807. [cf. http://arxiv.org/abs/1401.8104]

Barunik, J. & Kley, T. (2015). Quantile Cross-Spectral Measures of Dependence between Economic Variables. [preprint available from the authors]

Description

Get attribute descr from a Weight.

Usage

## S4 method for signature 'Weight'
getDescr(object)

Arguments

Value

Returns the descr attribute.

Get associated FreqRep from a QuantilePG.

Description

Get associated FreqRep from a QuantilePG.

Usage

## S4 method for signature 'QuantilePG'
getFreqRep(object)

Arguments

Value

Returns the FreqRep object associated.

Get attribute frequencies from a FreqRep.

Description

Get attribute frequencies from a FreqRep.

Usage

## S4 method for signature 'FreqRep'
getFrequencies(object)

Arguments

Value

Returns the frequencies attribute, as a vector of real numbers.

Description

Get attribute frequencies from a QSpecQuantity.

Usage

## S4 method for signature 'QSpecQuantity'
getFrequencies(object)

Arguments

Value

Returns the frequencies attribute, as a vector of real numbers.

Examples

qPG  <- quantilePG(rnorm(10), levels.1=c(0.25,0.5))
freq <- getFrequencies(qPG)

Get isRankBased from a FreqRep object

Description

Get isRankBased from a FreqRep object

Usage

## S4 method for signature 'FreqRep'
getIsRankBased(object)

Arguments

Value

Returns the attribute isRankBased that's a slot of object.

Get isRankBased from a LagOperator object

Description

Get isRankBased from a LagOperator object

Usage

## S4 method for signature 'LagOperator'
getIsRankBased(object)

Arguments

Value

Returns the attribute isRankBased that's a slot of object.

Get associated LagOperator from a LagEstimator.

Description

Get associated LagOperator from a LagEstimator.

Usage

## S4 method for signature 'LagEstimator'
getLagOperator(object)

Arguments

Value

Returns the LagOperator object associated.

Get attribute levels from a FreqRep.

Description

Get attribute levels from a FreqRep.

Usage

## S4 method for signature 'FreqRep'
getLevels(object)

Arguments

Value

Returns the levels attribute, as a vector of real numbers.

Description

If the optional parameter j is supplied, then the jth vector of levels will be returned, a list with all vectors otherwise.

Usage

## S4 method for signature 'LagOperator'
getLevels(object, j)

Arguments

Value

Returns levels attribute, as a vector of real numbers.

Description

If the optional parameter j is supplied, then the jth vector of levels will be returned, a list with all vectors otherwise.

Usage

## S4 method for signature 'QSpecQuantity'
getLevels(object, j)

Arguments

Value

Returns levels attribute, as a vector of real numbers.

Examples

qPG         <- quantilePG(rnorm(10), levels.1=c(0.25,0.5))
levels.list <- getLevels(qPG)
levels.1    <- getLevels(qPG,1)

Get maxLag from a LagOperator object.

Description

Get maxLag from a LagOperator object.

Usage

## S4 method for signature 'LagOperator'
getMaxLag(object)

Arguments

Value

Returns the attribute maxLag that's a slot of object.

Description

The selection mechanism for frequencies and levels operates in the same way as described in getValues-QuantileSD. The format of the output is also described there.

Usage

## S4 method for signature 'QuantileSD'
getMeanPG(object, frequencies = 2 * pi *
  (0:(getN(object) - 1))/getN(object), levels.1 = getLevels(object, 1),
  levels.2 = getLevels(object, 2), d1 = 1:(dim(object@values)[2]),
  d2 = 1:(dim(object@values)[4]))

Arguments

Value

Returns the array meanPG that's a slot of object.

Description

Get N from a quantile spectral density kernel

Usage

## S4 method for signature 'QuantileSD'
getN(object)

Arguments

Value

Returns the attribute N that's a slot of object.

Get getParallel from a QRegEstimator object

Description

Get getParallel from a QRegEstimator object

Usage

## S4 method for signature 'QRegEstimator'
getParallel(object)

Arguments

Value

Returns the attribute parallel that's a slot of object.

Description

Returns a list of two arrays lowerCIs and upperCIs that contain the upper and lower limits for a level 1-alpha confidence interval of the copula spectral density kernel. Each array is of dimension [J,K1,K2], where J=length(frequencies), K1=length(levels.1), and K2=length(levels.2)). At position (j,k1,k2) the real (imaginary) part of the returned values are the bounds of the confidence interval for the the real (imaginary) part of the quantile spectrum, which corresponds to frequencies[j], levels.1[k1] and levels.2[k2] closest to the Fourier frequencies, levels.1 and levels.2 available in object; closest.pos is used to determine what closest to means.

Usage

## S4 method for signature 'LagEstimator'
getPointwiseCIs(object, frequencies = 2 * pi *
  (0:(length(object@Y) - 1))/length(object@Y), levels.1 = getLevels(object,
  1), levels.2 = getLevels(object, 2), alpha = 0.1, type = c("naive.sd",
  "boot.sd", "boot.full"))

Arguments

Details

Currently, only one type of confidence interval is available:

• "naive.sd": confidence intervals based on the asymptotic normality of the lag-window estimator; standard deviations are estimated using getSdNaive.

Value

Returns a named list of two arrays lowerCIS and upperCIs containing the lower and upper bounds for the confidence intervals.

Examples

lagEst <- lagEstimator(rnorm(2^10), levels.1=0.5)
CI.upper <- Re(getPointwiseCIs(lagEst)$upperCIs[,1,1])
CI.lower <- Re(getPointwiseCIs(lagEst)$lowerCIs[,1,1])
freq = 2*pi*(0:1023)/1024
plot(x = freq, y = rep(0.25/(2*pi),1024),
   ylim=c(min(CI.lower), max(CI.upper)),
   type="l", col="red") # true spectrum
lines(x = freq, y = CI.upper)
lines(x = freq, y = CI.lower)

Description

Returns a list of two arrays lowerCIs and upperCIs that contain the upper and lower limits for a level 1-alpha confidence interval of the quantity of interest. Each array is of dimension [J,K1,K2] if a univariate time series is being analysed or of dimension [J,D1,K1,D2,K2], where J=length(frequencies), D1=length(d1), D2=length(d2), K1=length(levels.1), and K2=length(levels.2)). At position (j,k1,k2) or (j,i1,k1,i2,k2) the real (imaginary) part of the returned values are the bounds of the confidence interval for the the real (imaginary) part of the quantity under anlysis, which corresponds to frequencies[j], d1[i1], d2[i2], levels.1[k1] and levels.2[k2] closest to the Fourier frequencies, levels.1 and levels.2 available in object; closest.pos is used to determine what closest to means.

Usage

## S4 method for signature 'SmoothedPG'
getPointwiseCIs(object,
  quantity = c("spectral density", "coherency", "coherence"),
  frequencies = 2 * pi * (0:(lenTS(object@qPG@freqRep@Y) -
  1))/lenTS(object@qPG@freqRep@Y), levels.1 = getLevels(object, 1),
  levels.2 = getLevels(object, 2), d1 = 1:(dim(object@values)[2]),
  d2 = 1:(dim(object@values)[4]), alpha = 0.1, type = c("naive.sd",
  "boot.sd", "boot.full"))

Arguments

Details

Currently, pointwise confidence bands for two different quantity are implemented:

• "spectral density": confidence intervals for the quantile spectral density as described in Kley et. al (2016) for the univariate case and in Barunik and Kley (2015) for the multivariate case.

• "coherency": confidence intervals for the quantile coherency as described in Barunik and Kley (2015).

Currently, three different types of confidence intervals are available:

• "naive.sd": confidence intervals based on the asymptotic normality of the smoothed quantile periodogram; standard deviations are estimated using getSdNaive.

• "boot.sd": confidence intervals based on the asymptotic normality of the smoothed quantile periodogram; standard deviations are estimated using getSdBoot.

• "boot.full": confidence intervals determined by estimating the quantiles of he distribution of the smoothed quantile periodogram, by the empirical quantiles of the sample of bootstrapped replications.

Value

Returns a named list of two arrays lowerCIS and upperCIs containing the lower and upper bounds for the confidence intervals.

Examples

sPG <- smoothedPG(rnorm(2^10), levels.1=0.5)
CI.upper <- Re(getPointwiseCIs(sPG)$upperCIs[,1,1])
CI.lower <- Re(getPointwiseCIs(sPG)$lowerCIs[,1,1])
freq = 2*pi*(0:1023)/1024
plot(x = freq, y = rep(0.25/(2*pi),1024),
   ylim=c(min(CI.lower), max(CI.upper)),
   type="l", col="red") # true spectrum
lines(x = freq, y = CI.upper)
lines(x = freq, y = CI.lower)

Description

Get Positions for the Moving Blocks Bootstrap.

Usage

## S4 method for signature 'MovingBlocks'
getPositions(object, B = 1)

Arguments

Value

a matrix of dimension [N,B] where each column gives the positions in which to reorder the observations to yield one bootstrap replication.

Get associated QuantilePG from a QuantileSD.

Description

Get associated QuantilePG from a QuantileSD.

Usage

## S4 method for signature 'QuantileSD'
getQuantilePG(object)

Arguments

Value

Returns the QuantilePG object associated.

Get associated QuantilePG from a SmoothedPG.

Description

Get associated QuantilePG from a SmoothedPG.

Usage

## S4 method for signature 'SmoothedPG'
getQuantilePG(object)

Arguments

Value

Returns the QuantilePG object associated.

Get associated getQuantileSD from an IntegrQuantileSD.

Description

Get associated getQuantileSD from an IntegrQuantileSD.

Usage

## S4 method for signature 'IntegrQuantileSD'
getQuantileSD(object)

Arguments

Value

Returns the getQuantileSD object associated.

Description

Get R from a quantile spectral density kernel

Usage

## S4 method for signature 'QuantileSD'
getR(object)

Arguments

Value

Returns the attribute R that's a slot of object.

Description

Determines and returns an array of dimension [J,K1,K2], where J=length(frequencies), K1=length(levels.1), and K2=length(levels.2)). At position (j,k1,k2) the real part of the returned value is the standard deviation estimated from the real parts of the bootstrap replications and the imaginary part of the returned value is the standard deviation estimated from the imaginary part of the bootstrap replications. The estimate is determined from those bootstrap replicates of the estimator that have frequencies[j], levels.1[k1] and levels.2[k2] closest to the frequencies, levels.1 and levels.2 available in object; closest.pos is used to determine what closest to means.

Usage

## S4 method for signature 'LagEstimator'
getSdBoot(object, frequencies = 2 * pi *
  (0:(length(object@lagOp@Y) - 1))/length(object@lagOp@Y),
  levels.1 = getLevels(object, 1), levels.2 = getLevels(object, 2))

Arguments

Details

Requires that the LagEstimator is available at all Fourier frequencies from $(0,\pi]$. If this is not the case the missing values are imputed by taking one that is available and has a frequency that is closest to the missing Fourier frequency; closest.pos is used to determine which one this is.

If there are no bootstrap replicates available (i. e., B == 0) an error is returned.

Note the “standard deviation” estimated here is not the square root of the complex-valued variance. It's real part is the square root of the variance of the real part of the estimator and the imaginary part is the square root of the imaginary part of the variance of the estimator.

Value

Returns the estimate described above.

Description

Determines and returns an array of dimension [J,K1,K2], where J=length(frequencies), K1=length(levels.1), and K2=length(levels.2)). At position (j,k1,k2) the real part of the returned value is the standard deviation estimated from the real parts of the bootstrap replications and the imaginary part of the returned value is the standard deviation estimated from the imaginary part of the bootstrap replications. The estimate is determined from those bootstrap replicates of the estimator that have frequencies[j], levels.1[k1] and levels.2[k2] closest to the frequencies, levels.1 and levels.2 available in object; closest.pos is used to determine what closest to means.

Usage

## S4 method for signature 'SmoothedPG'
getSdBoot(object, frequencies = 2 * pi *
  (0:(lenTS(object@qPG@freqRep@Y) - 1))/lenTS(object@qPG@freqRep@Y),
  levels.1 = getLevels(object, 1), levels.2 = getLevels(object, 2))

Arguments

Details

Requires that the SmoothedPG is available at all Fourier frequencies from $(0,\pi]$. If this is not the case the missing values are imputed by taking one that is available and has a frequency that is closest to the missing Fourier frequency; closest.pos is used to determine which one this is.

If there are no bootstrap replicates available (i. e., B == 0) an error is returned.

Note the “standard deviation” estimated here is not the square root of the complex-valued variance. It's real part is the square root of the variance of the real part of the estimator and the imaginary part is the square root of the imaginary part of the variance of the estimator.

Value

Returns the estimate described above.

Description

Determines and returns an array of dimension [J,K1,K2], where J=length(frequencies), K1=length(levels.1), and K2=length(levels.2)). At position (j,k1,k2) the returned value is the standard deviation estimated corresponding to frequencies[j], levels.1[k1] and levels.2[k2] that are closest to the frequencies, levels.1 and levels.2 available in object; closest.pos is used to determine what closest to means.

Usage

## S4 method for signature 'LagEstimator'
getSdNaive(object, frequencies = 2 * pi *
  (0:(length(object@Y) - 1))/length(object@Y), levels.1 = getLevels(object,
  1), levels.2 = getLevels(object, 2))

Arguments

Details

Requires that the LagEstimator is available at all Fourier frequencies from $(0,\pi]$. If this is not the case the missing values are imputed by taking one that is available and has a frequency that is closest to the missing Fourier frequency; closest.pos is used to determine which one this is.

Note the “standard deviation” estimated here is not the square root of the complex-valued variance. It's real part is the square root of the variance of the real part of the estimator and the imaginary part is the square root of the imaginary part of the variance of the estimator.

Value

Returns the estimate described above.

Description

Determines and returns an array of dimension [J,K1,K2], where J=length(frequencies), K1=length(levels.1), and K2=length(levels.2)). Whether available or not, boostrap repetitions are ignored by this procedure. At position (j,k1,k2) the returned value is the standard deviation estimated corresponding to frequencies[j], levels.1[k1] and levels.2[k2] that are closest to the frequencies, levels.1 and levels.2 available in object; closest.pos is used to determine what closest to means.

Usage

## S4 method for signature 'SmoothedPG'
getSdNaive(object, frequencies = 2 * pi *
  (0:(lenTS(object@qPG@freqRep@Y) - 1))/lenTS(object@qPG@freqRep@Y),
  levels.1 = getLevels(object, 1), levels.2 = getLevels(object, 2),
  d1 = 1:(dim(object@values)[2]), d2 = 1:(dim(object@values)[4]),
  impl = c("R", "C"))

Arguments

Details

If not only one, but multiple time series are under study, the dimension of the returned vector is of dimension [J,P,K1,P,K2,B+1], where P denotes the dimension of the time series.

Requires that the SmoothedPG is available at all Fourier frequencies from $(0,\pi]$. If this is not the case the missing values are imputed by taking one that is available and has a frequency that is closest to the missing Fourier frequency; closest.pos is used to determine which one this is.

A precise definition on how the standard deviations of the smoothed quantile periodogram are estimated is given in Barunik&Kley (2015).

Note the “standard deviation” estimated here is not the square root of the complex-valued variance. It's real part is the square root of the variance of the real part of the estimator and the imaginary part is the square root of the imaginary part of the variance of the estimator.

Value

Returns the estimate described above.

References

Dette, H., Hallin, M., Kley, T. & Volgushev, S. (2015). Of Copulas, Quantiles, Ranks and Spectra: an $L_1$-approach to spectral analysis. Bernoulli, 21(2), 781–831. [cf. http://arxiv.org/abs/1111.7205]

Description

The selection mechanism for frequencies and levels operates in the same way as described in getValues-QuantileSD. The format of the output is also described there.

Usage

## S4 method for signature 'QuantileSD'
getStdError(object, frequencies = 2 * pi * (0:(object@N
  - 1))/object@N, levels.1 = getLevels(object, 1),
  levels.2 = getLevels(object, 2), d1 = 1:(dim(object@values)[2]),
  d2 = 1:(dim(object@values)[4]))

Arguments

Value

Returns the array stdError that's a slot of object.

Description

Get ts from a quantile spectral density kernel

Usage

## S4 method for signature 'QuantileSD'
getTs(object)

Arguments

Value

Returns the attribute ts that's a slot of object.

Description

Get type from a quantile spectral density kernel

Usage

## S4 method for signature 'QuantileSD'
getType(object)

Arguments

Value

Returns the attribute type that's a slot of object.

Description

For two vectors frequencies and levels the values from an object of type FreqRep are returned.

Usage

## S4 method for signature 'FreqRep'
getValues(object, frequencies = 2 * pi *
  (0:(lenTS(object@Y) - 1))/lenTS(object@Y), levels = object@levels,
  d = 1:(dim(object@values)[2]))

Arguments

Details

The two parameters frequencies and levels are expected to be vectors of reals; an error is thrown otherwise. If any of the frequencies or levels requested is not available from object a warning is issued, and the values with frequencies and levels closest to the ones requested are returned. Note that the frequencies are transformed to $[0,\pi]$ using frequenciesValidator when checking if they are available in object.

The returned array of values is of dimension [J,K,B+1], where J=length(frequencies), K=length(levels), and B denotes the value stored in slot B of object. At position (j,k,b) the returned value is the one corresponding to frequencies[j] and levels[k] that are closest to the frequencies and levels available in object; closest.pos is used to determine what closest to means.

Value

Returns data from the array values that's a slot of object.

Examples

Y        <- rnorm(32)
freq     <- 2*pi*c(0:31)/32
levels   <- c(0.25,0.5,0.75)
cFT      <- clippedFT(Y, freq, levels)
V.all    <- getValues(cFT)
V.coarse <- getValues(cFT, frequencies = 2*pi*c(0:15)/16, levels = levels)
V.fine   <- getValues(cFT, frequencies = 2*pi*c(0:63)/64, levels = levels)
V.part   <- getValues(cFT, frequencies = 2*pi*c(0:16)/32, levels = c(0.25))

Description

If none of the optional parameters is specified then the values are returned for all Fourier frequencies in $[0,2\pi)$ (base given by slot N) and all levels available. The frequencies and levels can be freely specified. The returned array then has, at position (j,k1,k2,b), the value corresponding to the frequencies[j], levels.1[k1] and levels.2[k2] that are closest to the frequencies, levels.1 and levels.2 available in object; closest.pos is used to determine what closest to means.

Usage

## S4 method for signature 'IntegrQuantileSD'
getValues(object, frequencies = 2 * pi *
  (0:(getN(object@qsd) - 1))/getN(object@qsd), levels.1 = getLevels(object,
  1), levels.2 = getLevels(object, 2))

Arguments

Value

Returns data from the array values that's a slot of object.

See Also

For examples on how to use this function go to IntegrQuantileSD.

Description

For an object of type KernelWeight and an optional integer N the weights $W_n$ are returned as a vector that has $W_n(2\pi(k-1)/n)$ at position k.

Usage

## S4 method for signature 'KernelWeight'
getValues(object, N = length(object@env$values))

Arguments

Value

Returns a vector of size N as described in the Details section.

Description

The returned array of values is of dimension [J,K1,K2], where J=length(frequencies), K1=length(levels.1) and K2=length(levels.2)). At position (j,k1,k2) the returned value is the one corresponding to frequencies[j], levels.1[k1] and levels.2[k2] that are closest to the frequencies, levels.1 and levels.2 available in object; closest.pos is used to determine what closest to means.

Usage

## S4 method for signature 'LagEstimator'
getValues(object, frequencies = 2 * pi *
  (0:(length(object@Y) - 1))/length(object@Y), levels.1 = getLevels(object,
  1), levels.2 = getLevels(object, 2))

Arguments

Value

Returns data from the array values that's a slot of object.

See Also

An example on how to use this function is analogously to the example given in getValues-QuantilePG.

Description

For an object of type LagKernelWeight and an optional integer K the weights $W_k$ are returned as a vector that has $W_k((k-1)/bw)$ at position k.

Usage

## S4 method for signature 'LagKernelWeight'
getValues(object, K = length(object@env$values))

Arguments

Value

Returns a vector of size K as described in the Details section.

Description

Get attribute values from a LagOperator.

Usage

## S4 method for signature 'LagOperator'
getValues(object, levels.1, levels.2)

Arguments

Value

Returns the values attribute.

Description

For vectors frequencies, levels.1 and levels.2 the values from an object of type QuantilePG are returned.

Usage

## S4 method for signature 'QuantilePG'
getValues(object, frequencies = 2 * pi *
  (0:(lenTS(object@freqRep@Y) - 1))/lenTS(object@freqRep@Y),
  levels.1 = getLevels(object, 1), levels.2 = getLevels(object, 2),
  d1 = 1:(dim(object@freqRep@Y)[2]), d2 = 1:(dim(object@freqRep@Y)[2]))

Arguments

Details

Fetching of the periodogram values basically happens by passing frequencies and the union of levels.1 and levels.2 to getValues. Therefore, the parameters frequencies, levels.1 and levels.1 are expected to be vectors of reals; an error is thrown otherwise. If any of the frequencies, levels.1 and levels.2 requested is not available from object a warning is issued. Note that the frequencies are transformed to $[0,\pi]$ using frequenciesValidator when checking if they are available in object.

The returned array of values is of dimension [J,K1,K2,B+1], where J=length(frequencies), K1=length(levels.1), K2=length(levels.2)), and B denotes the value stored in slot B of freqRep that's a slot of object. At position (j,k1,k2,b) the returned value is the one corresponding to frequencies[j], levels.1[k1] and levels.2[k2] that are closest to the frequencies, levels.1 and levels.2 available in object; closest.pos is used to determine what closest to means.

Value

Returns data from the array values that's a slot of object.

Examples

Y        <- rnorm(32)
freq     <- 2*pi*c(0:31)/32
levels   <- c(0.25,0.5,0.75)
qPG      <- quantilePG(Y, levels.1=levels)
V.all    <- getValues(qPG)
V.coarse <- getValues(qPG, frequencies = 2*pi*c(0:15)/16)
V.fine   <- getValues(qPG, frequencies = 2*pi*c(0:63)/64)
V.part   <- getValues(qPG, frequencies = 2*pi*c(0:16)/32,
                           levels.1 = c(0.25), levels.2 = c(0.5,0.75))

Description

If none of the optional parameters is specified then the values are returned for all Fourier frequencies in $[0,2\pi)$ (base given by slot N) and all levels available. The frequencies and levels can be freely specified. The returned array then has, at position (j,k1,k2,b), the value corresponding to the frequencies[j], levels.1[k1] and levels.2[k2] that are closest to the frequencies, levels.1 and levels.2 available in object; closest.pos is used to determine what closest to means.

Usage

## S4 method for signature 'QuantileSD'
getValues(object, frequencies = 2 * pi * (0:(object@N -
  1))/object@N, levels.1 = getLevels(object, 1),
  levels.2 = getLevels(object, 2), d1 = 1:(dim(object@values)[2]),
  d2 = 1:(dim(object@values)[4]))

Arguments

Value

Returns data from the array values that's a slot of object.

See Also

For examples on how to use this function go to QuantileSD.

Description

The returned array of values is of dimension [J,K1,K2,B+1], where J=length(frequencies), K1=length(levels.1), K2=length(levels.2)), and B denotes the value stored in slot B of freqRep [that is the number of boostrap repetitions performed on initialization]. At position (j,k1,k2,b) the returned value is the one corresponding to frequencies[j], levels.1[k1] and levels.2[k2] that are closest to the frequencies, levels.1 and levels.2 available in object; closest.pos is used to determine what closest to means. b==1 corresponds to the estimate without bootstrapping; b>1 corresponds to the b-1st bootstrap estimate.

Usage

## S4 method for signature 'SmoothedPG'
getValues(object, frequencies = 2 * pi *
  (0:(lenTS(object@qPG@freqRep@Y) - 1))/lenTS(object@qPG@freqRep@Y),
  levels.1 = getLevels(object, 1), levels.2 = getLevels(object, 2),
  d1 = 1:(dim(object@values)[2]), d2 = 1:(dim(object@values)[4]))

Arguments

Details

If not only one, but multiple time series are under study, the dimension of the returned vector is of dimension [J,P,K1,P,K2,B+1], where P denotes the dimension of the time series.

Value

Returns data from the array values that's a slot of object.

See Also

An example on how to use this function is analogously to the example given in getValues-QuantilePG.

Get values from a weight object of type SpecDistrWeight

Description

For an object of type SpecDistrWeight and an optional integer N the weights $W_n$ are returned as a vector that has $W_n(2\pi(k-1)/n)$ at position k.

Usage

## S4 method for signature 'SpecDistrWeight'
getValues(object, N = length(object@env$values))

Arguments

Value

Returns a vector of size N as described in the Description section.

Description

Get attribute W (kernel used for smoothing) from a KernelWeight.

Usage

## S4 method for signature 'KernelWeight'
getW(object)

Arguments

Value

Returns the W attribute.

Description

Get attribute W (kernel used for smoothing) from a LagKernelWeight.

Usage

## S4 method for signature 'LagKernelWeight'
getW(object)

Arguments

Value

Returns the W attribute.

Get associated Weight from a LagEstimator.

Description

Get associated Weight from a LagEstimator.

Usage

## S4 method for signature 'LagEstimator'
getWeight(object)

Arguments

Value

Returns the Weight object associated.

Get associated Weight from a SmoothedPG.

Description

Get associated Weight from a SmoothedPG.

Usage

## S4 method for signature 'SmoothedPG'
getWeight(object)

Arguments

Value

Returns the Weight object associated.

Description

If the optional parameter j is supplied, then only the jth element(s) of the vector will be returned, the entire vector otherwise.

Usage

## S4 method for signature 'KernelWeight'
getWnj(object, j)

Arguments

Value

Returns levels attribute, as a vector of real numbers.

Examples

wgt <- kernelWeight(W=W1, N=2^3, bw=0.7)
getWnj(wgt)
getWnj(wgt, 2)
getWnj(wgt, c(2,7))

Get Y from a FreqRep object.

Description

Get Y from a FreqRep object.

Usage

## S4 method for signature 'FreqRep'
getY(object, d = 1)

Arguments

Value

Returns the attribute Y that's a slot of object.

Description

The precision is increased by generating an additional R QuantilePG objects (independent of the previous ones) and then including them in the average.

Usage

## S4 method for signature 'QuantileSD'
increasePrecision(object, R = 1, quiet = FALSE)

Arguments

Value

Returns an QuantileSD object determined from oldR + R independent repetitions.

Examples

# First simulate a copula spectral density from R=20 independent runs.
csd <- quantileSD(N=2^9, ts=ts1, levels.1=c(0.25,0.5), type="copula", R=20)

# Check out the result:
getR(csd)
plot(csd)

# Now increase the number of independent simulation runs to 50.
csd <- increasePrecision(csd, R=30)

# Check out the (more precise) result:
getR(csd)
plot(csd)

Description

IntegrQuantileSD is an S4 class that implements the necessary calculations to determine an integrated version of the quantile spectral density kernel (computed via QuantileSD). In particular it can be determined for any model from which a time series of length N can be sampled via a function call ts(N).

Details

In the simulation the quantile spectral density is first determined via QuantileSD, it's values are recovered using getValues-QuantileSD and then cumulated using cumsum.

Note that, all remarks made in the documentation of the super-class QSpecQuantity apply.

Slots

qsd

a QuantileSD from which to begin the computations.

Examples

################################################################################
## This script illustrates how to estimate integrated quantile spectral densities

## Simulate a time series Y1,...,Y128 from the QAR(1) process discussed in
## Dette et. al (2015).
set.seed(2581)
Y <- ts1(128)

## For a defined set of quantile levels ... 
levels <- c(0.25,0.5,0.75)

## ... and a weight (of Type A), defined using the Epanechnikov kernel ...
wgt <- specDistrWeight()

## ... compute a smoothed quantile periodogram (based on the clipped time series).
## Repeat the estimation 100 times, using the moving blocks bootstrap with
## block length l=32.
sPG.cl <- smoothedPG(Y, levels.1 = levels, type="clipped", weight = wgt,
    type.boot = "mbb", B=100, l=32)

## Create a (model) spectral density kernel for he QAR(1) model for display
## in the next plot.
csd <- quantileSD(N=2^8, seed.init = 2581, type = "copula",
    ts = ts1, levels.1=levels, R = 100)
icsd <- integrQuantileSD(csd)

plot(sPG.cl, ptw.CIs = 0.1, qsd = icsd, type.CIs = "boot.full")

Create an instance of the IntegrQuantileSD class.

Description

Create an instance of the IntegrQuantileSD class.

Usage

integrQuantileSD(object = 2^8, type = c("copula", "Laplace"), ts = rnorm,
  seed.init = 2581, levels.1 = 0.5, levels.2 = levels.1, R = 1,
  quiet = FALSE)

Arguments

Value

Returns an instance of IntegrQuantileSD.

See Also

For an example see IntegrQuantileSD.

Description

Borrowed from the example in integer.

Usage

is.wholenumber(x, tol = .Machine$double.eps^0.5)

Arguments

Value

Returns a vector of logicals with the same length as x; each element i is TRUE iff x[i] is an integer.

Examples

## Not run: 
is.wholenumber(1) # is TRUE
(x <- seq(1, 5, by = 0.5) )
is.wholenumber( x ) #-->  TRUE FALSE TRUE ...

## End(Not run)

Description

Implementations of kernel functions

Usage

W0(x)

W1(x)

W2(x)

W3(x)

WDaniell(x, a = (pi/2))

WParzen(u)

Arguments

Details

Daniell kernel function W0:

$\frac{1}{2\pi} I\{|x| \leq \pi\}.$

Epanechnikov kernel W1 (i. e., variance minimizing kernel function of order 2):

$\frac{3}{4\pi} (1-\frac{x}{\pi})^2 I\{|x| \leq \pi\}.$

Variance minimizing kernel function W2 of order 4:

$\frac{15}{32\pi} (7(x/\pi)^4 -10(x/\pi)^2+3) I\{|x| \leq \pi\}.$

Variance minimizing kernel function W3 of order 6:

$\frac{35}{256\pi} (-99(x/\pi)^6 + 189(x/\pi)^4 - 105(x/\pi)^2+15) I\{|x| \leq \pi\}.$

Kernel yield by convolution of two Daniell kernels:

$\frac{1}{\pi+a} \Big(1-\frac{|x|-a}{\pi-a} I\{a \leq |x| \leq \pi\}\Big).$

Parzen Window for lagEstimators

Examples

plot(x=seq(-8,8,0.05), y=W0(seq(-8,8,0.05)), type="l")
plot(x=seq(-8,8,0.05), y=W1(seq(-8,8,0.05)), type="l")
plot(x=seq(-8,8,0.05), y=W2(seq(-8,8,0.05)), type="l")
plot(x=seq(-8,8,0.05), y=W3(seq(-8,8,0.05)), type="l")
plot(x=seq(-pi,pi,0.05), y=WDaniell(seq(-pi,pi,0.05),a=(pi/2)), type="l")
plot(x=seq(-2,2,0.05),y=WParzen(seq(-2,2,0.05)),type = "l")

Description

KernelWeight is an S4 class that implements a weighting function by specification of a kernel function W and a scale parameter bw.

Details

It extends the class Weight and writes

$W_N(2\pi (k-1)/N) := \sum_{j \in Z} bw^{-1} W(2\pi bw^{-1} [(k-1)/N + j])$

to values[k] [nested inside env] for k=1,...,N. The number length(values) of Fourier frequencies for which $W_N$ will be evaluated may be set on construction or updated when evoking the method getValues. To standardize the weights used in the convolution to unity

$W_N^j := \sum_{j \neq s = 0}^{N-1} W_n(2\pi s / N)$

is stored to Wnj[s] for s=1,...,N, for later usage.

Slots

W

a kernel function

bw

bandwidth

env

An environment to allow for slots which need to be accessable in a call-by-reference manner:

values

A vector storing the weights; see the Details section.

Wnj

A vector storing the terms used for normalization; see the Details section.

References

Brillinger, D. R. (1975). Time Series: Data Analysis and Theory. Holt, Rinehart and Winston, Inc., New York. [cf. p. 146 f.]

See Also

Examples for implementations of kernels W can be found at: kernels.

Create an instance of the KernelWeight class.

Description

Create an instance of the KernelWeight class.

Usage

kernelWeight(W = W0, N = 1, bw = 0.1 * N^(-1/5), descr = paste("bw=",
  round(bw, 3), ", N=", N, sep = ""))

Arguments

Value

Returns an instance of KernelWeight.

See Also

kernels

Examples

wgt1 <- kernelWeight(W=W0, N=16, bw=c(0.1,0.3,0.7))
print(wgt1)
wgt2 <- kernelWeight(W=W1, N=2^8, bw=0.1)
plot(wgt2, main="Weights determined from Epanechnikov kernel")

Description

For a given time series Y a lag-window estimator of the Form

$\hat{f}(\omega) = \sum_{|k|< n-1 } K_n(k) \Gamma(Y_0,Y_k) \exp(-i \omega k)$

will be calculated on initalization. The LagKernelWeight K_n is determined by the slot weight and the LagOperator $\Gamma(Y_0,Y_k)$ is defined by the slot lagOp.

Details

Currently, the implementation of this class allows only for the analysis of univariate time series.

Slots

Y

the time series where the lag estimator was applied one

weight

a Weight object to be used as lag window

lagOp

a LagOperator object that determines which kind of bivariate structure should be calculated.

env

An environment to allow for slots which need to be accessable in a call-by-reference manner:

sdNaive

An array used for storage of the naively estimated standard deviations of the smoothed periodogram.

sdNaive.done

a flag indicating whether sdNaive has been set yet.

Description

A LagEstimator object can be created from numeric, a ts, or a zoo object. Also a LagOperator and a Weight object can be used to create different types of estimators.

Usage

lagEstimator(Y, frequencies = 2 * pi/length(Y) * 0:(length(Y) - 1),
  levels.1 = 0.5, levels.2 = levels.1, weight = lagKernelWeight(K =
  length(Y), bw = 100), type = c("clippedCov"))

Arguments

Value

Returns an instance of LagEstimator.

Examples

Y <- rnorm(100)
levels.1 <- c(0.1,0.5,0.9)
weight <- lagKernelWeight(W = WParzen,  bw = 10, K = length(Y))
lagOp <- clippedCov(Y,levels.1 = levels.1)
lagEst <- lagEstimator(lagOp, weight = weight)

Description

LagKernelWeight is an S4 class that implements a weighting function by specification of a kernel function W and a scale parameter bw.

Details

It extends the class Weight and writes

$W_N(x[k]) := W(x[k]/bw)$

to values[k] [nested inside env] for k=1,...,length(x). The points x where $W$ is evaluated may be set on construction or updated when evoking the method getValues.

Slots

W

a kernel function

bw

bandwidth

env

An environment to allow for slots which need to be accessable in a call-by-reference manner:

values

A vector storing the weights; see the Details section.

See Also

Examples for implementations of kernels W can be found at: kernels.

Create an instance of the LagKernelWeight class.

Description

Create an instance of the LagKernelWeight class.

Usage

lagKernelWeight(W = WParzen, bw = K/2, K = 10, descr = paste("bw=", bw,
  ", K=", K, sep = ""))

Arguments

Value

Returns an instance of LagKernelWeight.

See Also

kernels

Examples

wgt1 <- lagKernelWeight(W=WParzen, K=20, bw=10)
print(wgt1)

Description

LagOperator is an S4 class that provides a common interface to implementations of an operator $\Gamma(Y)$ which is calculated on all pairs of observations $(Y_0,Y_k)$ with lag smaller than maxLag