\HeaderA{AtomicList}{Lists of Atomic Vectors in Natural and Rle Form}{AtomicList}
\aliasA{"!,CompressedLogicalList-method}{AtomicList}{"!,CompressedLogicalList.Rdash.method}
\aliasA{"!,CompressedRleList-method}{AtomicList}{"!,CompressedRleList.Rdash.method}
\aliasA{"!,SimpleLogicalList-method}{AtomicList}{"!,SimpleLogicalList.Rdash.method}
\aliasA{"!,SimpleRleList-method}{AtomicList}{"!,SimpleRleList.Rdash.method}
\aliasA{as.character,AtomicList-method}{AtomicList}{as.character,AtomicList.Rdash.method}
\aliasA{as.complex,AtomicList-method}{AtomicList}{as.complex,AtomicList.Rdash.method}
\aliasA{as.data.frame,AtomicList-method}{AtomicList}{as.data.frame,AtomicList.Rdash.method}
\aliasA{as.factor,AtomicList-method}{AtomicList}{as.factor,AtomicList.Rdash.method}
\aliasA{as.integer,AtomicList-method}{AtomicList}{as.integer,AtomicList.Rdash.method}
\aliasA{as.list,CompressedAtomicList-method}{AtomicList}{as.list,CompressedAtomicList.Rdash.method}
\aliasA{as.logical,AtomicList-method}{AtomicList}{as.logical,AtomicList.Rdash.method}
\aliasA{as.numeric,AtomicList-method}{AtomicList}{as.numeric,AtomicList.Rdash.method}
\aliasA{as.raw,AtomicList-method}{AtomicList}{as.raw,AtomicList.Rdash.method}
\aliasA{as.vector,AtomicList,missing-method}{AtomicList}{as.vector,AtomicList,missing.Rdash.method}
\aliasA{AtomicList-class}{AtomicList}{AtomicList.Rdash.class}
\aliasA{CharacterList}{AtomicList}{CharacterList}
\aliasA{CharacterList-class}{AtomicList}{CharacterList.Rdash.class}
\aliasA{chartr,ANY,ANY,CompressedCharacterList-method}{AtomicList}{chartr,ANY,ANY,CompressedCharacterList.Rdash.method}
\aliasA{chartr,ANY,ANY,CompressedRleList-method}{AtomicList}{chartr,ANY,ANY,CompressedRleList.Rdash.method}
\aliasA{chartr,ANY,ANY,SimpleCharacterList-method}{AtomicList}{chartr,ANY,ANY,SimpleCharacterList.Rdash.method}
\aliasA{chartr,ANY,ANY,SimpleRleList-method}{AtomicList}{chartr,ANY,ANY,SimpleRleList.Rdash.method}
\aliasA{coerce,AtomicList,character-method}{AtomicList}{coerce,AtomicList,character.Rdash.method}
\aliasA{coerce,AtomicList,complex-method}{AtomicList}{coerce,AtomicList,complex.Rdash.method}
\aliasA{coerce,AtomicList,data.frame-method}{AtomicList}{coerce,AtomicList,data.frame.Rdash.method}
\aliasA{coerce,AtomicList,factor-method}{AtomicList}{coerce,AtomicList,factor.Rdash.method}
\aliasA{coerce,AtomicList,integer-method}{AtomicList}{coerce,AtomicList,integer.Rdash.method}
\aliasA{coerce,AtomicList,logical-method}{AtomicList}{coerce,AtomicList,logical.Rdash.method}
\aliasA{coerce,AtomicList,numeric-method}{AtomicList}{coerce,AtomicList,numeric.Rdash.method}
\aliasA{coerce,AtomicList,raw-method}{AtomicList}{coerce,AtomicList,raw.Rdash.method}
\aliasA{coerce,AtomicList,vector-method}{AtomicList}{coerce,AtomicList,vector.Rdash.method}
\aliasA{coerce,CompressedAtomicList,list-method}{AtomicList}{coerce,CompressedAtomicList,list.Rdash.method}
\aliasA{coerce,LogicalList,CompressedIRangesList-method}{AtomicList}{coerce,LogicalList,CompressedIRangesList.Rdash.method}
\aliasA{coerce,LogicalList,CompressedNormalIRangesList-method}{AtomicList}{coerce,LogicalList,CompressedNormalIRangesList.Rdash.method}
\aliasA{coerce,LogicalList,IRangesList-method}{AtomicList}{coerce,LogicalList,IRangesList.Rdash.method}
\aliasA{coerce,LogicalList,NormalIRangesList-method}{AtomicList}{coerce,LogicalList,NormalIRangesList.Rdash.method}
\aliasA{coerce,LogicalList,SimpleIRangesList-method}{AtomicList}{coerce,LogicalList,SimpleIRangesList.Rdash.method}
\aliasA{coerce,LogicalList,SimpleNormalIRangesList-method}{AtomicList}{coerce,LogicalList,SimpleNormalIRangesList.Rdash.method}
\aliasA{coerce,RleList,CompressedIRangesList-method}{AtomicList}{coerce,RleList,CompressedIRangesList.Rdash.method}
\aliasA{coerce,RleList,CompressedNormalIRangesList-method}{AtomicList}{coerce,RleList,CompressedNormalIRangesList.Rdash.method}
\aliasA{coerce,RleList,IRangesList-method}{AtomicList}{coerce,RleList,IRangesList.Rdash.method}
\aliasA{coerce,RleList,NormalIRangesList-method}{AtomicList}{coerce,RleList,NormalIRangesList.Rdash.method}
\aliasA{coerce,RleList,SimpleIRangesList-method}{AtomicList}{coerce,RleList,SimpleIRangesList.Rdash.method}
\aliasA{coerce,RleList,SimpleNormalIRangesList-method}{AtomicList}{coerce,RleList,SimpleNormalIRangesList.Rdash.method}
\aliasA{coerce,vector,AtomicList-method}{AtomicList}{coerce,vector,AtomicList.Rdash.method}
\aliasA{Complex,CompressedAtomicList-method}{AtomicList}{Complex,CompressedAtomicList.Rdash.method}
\aliasA{Complex,SimpleAtomicList-method}{AtomicList}{Complex,SimpleAtomicList.Rdash.method}
\aliasA{ComplexList}{AtomicList}{ComplexList}
\aliasA{ComplexList-class}{AtomicList}{ComplexList.Rdash.class}
\aliasA{CompressedAtomicList-class}{AtomicList}{CompressedAtomicList.Rdash.class}
\aliasA{CompressedCharacterList}{AtomicList}{CompressedCharacterList}
\aliasA{CompressedCharacterList-class}{AtomicList}{CompressedCharacterList.Rdash.class}
\aliasA{CompressedComplexList}{AtomicList}{CompressedComplexList}
\aliasA{CompressedComplexList-class}{AtomicList}{CompressedComplexList.Rdash.class}
\aliasA{CompressedIntegerList}{AtomicList}{CompressedIntegerList}
\aliasA{CompressedIntegerList-class}{AtomicList}{CompressedIntegerList.Rdash.class}
\aliasA{CompressedLogicalList}{AtomicList}{CompressedLogicalList}
\aliasA{CompressedLogicalList-class}{AtomicList}{CompressedLogicalList.Rdash.class}
\aliasA{CompressedNumericList}{AtomicList}{CompressedNumericList}
\aliasA{CompressedNumericList-class}{AtomicList}{CompressedNumericList.Rdash.class}
\aliasA{CompressedRawList}{AtomicList}{CompressedRawList}
\aliasA{CompressedRawList-class}{AtomicList}{CompressedRawList.Rdash.class}
\aliasA{CompressedRleList}{AtomicList}{CompressedRleList}
\aliasA{CompressedRleList-class}{AtomicList}{CompressedRleList.Rdash.class}
\aliasA{cor,IntegerList,AtomicList-method}{AtomicList}{cor,IntegerList,AtomicList.Rdash.method}
\aliasA{cor,LogicalList,AtomicList-method}{AtomicList}{cor,LogicalList,AtomicList.Rdash.method}
\aliasA{cor,NumericList,AtomicList-method}{AtomicList}{cor,NumericList,AtomicList.Rdash.method}
\aliasA{cor,RleList,AtomicList-method}{AtomicList}{cor,RleList,AtomicList.Rdash.method}
\aliasA{cov,IntegerList,AtomicList-method}{AtomicList}{cov,IntegerList,AtomicList.Rdash.method}
\aliasA{cov,LogicalList,AtomicList-method}{AtomicList}{cov,LogicalList,AtomicList.Rdash.method}
\aliasA{cov,NumericList,AtomicList-method}{AtomicList}{cov,NumericList,AtomicList.Rdash.method}
\aliasA{cov,RleList,AtomicList-method}{AtomicList}{cov,RleList,AtomicList.Rdash.method}
\aliasA{diff,IntegerList-method}{AtomicList}{diff,IntegerList.Rdash.method}
\aliasA{diff,NumericList-method}{AtomicList}{diff,NumericList.Rdash.method}
\aliasA{diff,RleList-method}{AtomicList}{diff,RleList.Rdash.method}
\aliasA{gsub,ANY,ANY,CompressedCharacterList-method}{AtomicList}{gsub,ANY,ANY,CompressedCharacterList.Rdash.method}
\aliasA{gsub,ANY,ANY,CompressedRleList-method}{AtomicList}{gsub,ANY,ANY,CompressedRleList.Rdash.method}
\aliasA{gsub,ANY,ANY,SimpleCharacterList-method}{AtomicList}{gsub,ANY,ANY,SimpleCharacterList.Rdash.method}
\aliasA{gsub,ANY,ANY,SimpleRleList-method}{AtomicList}{gsub,ANY,ANY,SimpleRleList.Rdash.method}
\aliasA{IntegerList}{AtomicList}{IntegerList}
\aliasA{IntegerList-class}{AtomicList}{IntegerList.Rdash.class}
\aliasA{IQR,IntegerList-method}{AtomicList}{IQR,IntegerList.Rdash.method}
\aliasA{IQR,LogicalList-method}{AtomicList}{IQR,LogicalList.Rdash.method}
\aliasA{IQR,NumericList-method}{AtomicList}{IQR,NumericList.Rdash.method}
\aliasA{IQR,RleList-method}{AtomicList}{IQR,RleList.Rdash.method}
\aliasA{is.na,CompressedAtomicList-method}{AtomicList}{is.na,CompressedAtomicList.Rdash.method}
\aliasA{is.na,CompressedRleList-method}{AtomicList}{is.na,CompressedRleList.Rdash.method}
\aliasA{is.na,SimpleAtomicList-method}{AtomicList}{is.na,SimpleAtomicList.Rdash.method}
\aliasA{is.na,SimpleRleList-method}{AtomicList}{is.na,SimpleRleList.Rdash.method}
\aliasA{lapply,CompressedAtomicList-method}{AtomicList}{lapply,CompressedAtomicList.Rdash.method}
\aliasA{LogicalList}{AtomicList}{LogicalList}
\aliasA{LogicalList-class}{AtomicList}{LogicalList.Rdash.class}
\aliasA{mad,IntegerList-method}{AtomicList}{mad,IntegerList.Rdash.method}
\aliasA{mad,LogicalList-method}{AtomicList}{mad,LogicalList.Rdash.method}
\aliasA{mad,NumericList-method}{AtomicList}{mad,NumericList.Rdash.method}
\aliasA{mad,RleList-method}{AtomicList}{mad,RleList.Rdash.method}
\aliasA{match,CompressedAtomicList,atomic-method}{AtomicList}{match,CompressedAtomicList,atomic.Rdash.method}
\aliasA{match,CompressedAtomicList,AtomicList-method}{AtomicList}{match,CompressedAtomicList,AtomicList.Rdash.method}
\aliasA{match,CompressedRleList,atomic-method}{AtomicList}{match,CompressedRleList,atomic.Rdash.method}
\aliasA{match,CompressedRleList,AtomicList-method}{AtomicList}{match,CompressedRleList,AtomicList.Rdash.method}
\aliasA{match,SimpleAtomicList,atomic-method}{AtomicList}{match,SimpleAtomicList,atomic.Rdash.method}
\aliasA{match,SimpleAtomicList,AtomicList-method}{AtomicList}{match,SimpleAtomicList,AtomicList.Rdash.method}
\aliasA{match,SimpleRleList,atomic-method}{AtomicList}{match,SimpleRleList,atomic.Rdash.method}
\aliasA{match,SimpleRleList,AtomicList-method}{AtomicList}{match,SimpleRleList,AtomicList.Rdash.method}
\aliasA{Math,CompressedAtomicList-method}{AtomicList}{Math,CompressedAtomicList.Rdash.method}
\aliasA{Math,SimpleAtomicList-method}{AtomicList}{Math,SimpleAtomicList.Rdash.method}
\aliasA{Math2,CompressedAtomicList-method}{AtomicList}{Math2,CompressedAtomicList.Rdash.method}
\aliasA{Math2,SimpleAtomicList-method}{AtomicList}{Math2,SimpleAtomicList.Rdash.method}
\aliasA{mean,IntegerList-method}{AtomicList}{mean,IntegerList.Rdash.method}
\aliasA{mean,LogicalList-method}{AtomicList}{mean,LogicalList.Rdash.method}
\aliasA{mean,NumericList-method}{AtomicList}{mean,NumericList.Rdash.method}
\aliasA{mean,RleList-method}{AtomicList}{mean,RleList.Rdash.method}
\aliasA{median,IntegerList-method}{AtomicList}{median,IntegerList.Rdash.method}
\aliasA{median,LogicalList-method}{AtomicList}{median,LogicalList.Rdash.method}
\aliasA{median,NumericList-method}{AtomicList}{median,NumericList.Rdash.method}
\aliasA{median,RleList-method}{AtomicList}{median,RleList.Rdash.method}
\aliasA{nchar,CompressedCharacterList-method}{AtomicList}{nchar,CompressedCharacterList.Rdash.method}
\aliasA{nchar,CompressedRleList-method}{AtomicList}{nchar,CompressedRleList.Rdash.method}
\aliasA{nchar,SimpleCharacterList-method}{AtomicList}{nchar,SimpleCharacterList.Rdash.method}
\aliasA{nchar,SimpleRleList-method}{AtomicList}{nchar,SimpleRleList.Rdash.method}
\aliasA{NumericList}{AtomicList}{NumericList}
\aliasA{NumericList-class}{AtomicList}{NumericList.Rdash.class}
\aliasA{Ops,atomic,AtomicList-method}{AtomicList}{Ops,atomic,AtomicList.Rdash.method}
\aliasA{Ops,atomic,CompressedAtomicList-method}{AtomicList}{Ops,atomic,CompressedAtomicList.Rdash.method}
\aliasA{Ops,AtomicList,atomic-method}{AtomicList}{Ops,AtomicList,atomic.Rdash.method}
\aliasA{Ops,CompressedAtomicList,atomic-method}{AtomicList}{Ops,CompressedAtomicList,atomic.Rdash.method}
\aliasA{Ops,CompressedAtomicList,CompressedAtomicList-method}{AtomicList}{Ops,CompressedAtomicList,CompressedAtomicList.Rdash.method}
\aliasA{Ops,CompressedAtomicList,SimpleAtomicList-method}{AtomicList}{Ops,CompressedAtomicList,SimpleAtomicList.Rdash.method}
\aliasA{Ops,SimpleAtomicList,CompressedAtomicList-method}{AtomicList}{Ops,SimpleAtomicList,CompressedAtomicList.Rdash.method}
\aliasA{Ops,SimpleAtomicList,SimpleAtomicList-method}{AtomicList}{Ops,SimpleAtomicList,SimpleAtomicList.Rdash.method}
\aliasA{pmax,IntegerList-method}{AtomicList}{pmax,IntegerList.Rdash.method}
\aliasA{pmax,NumericList-method}{AtomicList}{pmax,NumericList.Rdash.method}
\aliasA{pmax,RleList-method}{AtomicList}{pmax,RleList.Rdash.method}
\aliasA{pmax.int,IntegerList-method}{AtomicList}{pmax.int,IntegerList.Rdash.method}
\aliasA{pmax.int,NumericList-method}{AtomicList}{pmax.int,NumericList.Rdash.method}
\aliasA{pmax.int,RleList-method}{AtomicList}{pmax.int,RleList.Rdash.method}
\aliasA{pmin,IntegerList-method}{AtomicList}{pmin,IntegerList.Rdash.method}
\aliasA{pmin,NumericList-method}{AtomicList}{pmin,NumericList.Rdash.method}
\aliasA{pmin,RleList-method}{AtomicList}{pmin,RleList.Rdash.method}
\aliasA{pmin.int,IntegerList-method}{AtomicList}{pmin.int,IntegerList.Rdash.method}
\aliasA{pmin.int,NumericList-method}{AtomicList}{pmin.int,NumericList.Rdash.method}
\aliasA{pmin.int,RleList-method}{AtomicList}{pmin.int,RleList.Rdash.method}
\aliasA{quantile,IntegerList-method}{AtomicList}{quantile,IntegerList.Rdash.method}
\aliasA{quantile,LogicalList-method}{AtomicList}{quantile,LogicalList.Rdash.method}
\aliasA{quantile,NumericList-method}{AtomicList}{quantile,NumericList.Rdash.method}
\aliasA{quantile,RleList-method}{AtomicList}{quantile,RleList.Rdash.method}
\aliasA{RawList}{AtomicList}{RawList}
\aliasA{RawList-class}{AtomicList}{RawList.Rdash.class}
\aliasA{RleList}{AtomicList}{RleList}
\aliasA{RleList-class}{AtomicList}{RleList.Rdash.class}
\aliasA{runmean,RleList-method}{AtomicList}{runmean,RleList.Rdash.method}
\aliasA{runmed,CompressedIntegerList-method}{AtomicList}{runmed,CompressedIntegerList.Rdash.method}
\aliasA{runmed,NumericList-method}{AtomicList}{runmed,NumericList.Rdash.method}
\aliasA{runmed,RleList-method}{AtomicList}{runmed,RleList.Rdash.method}
\aliasA{runmed,SimpleIntegerList-method}{AtomicList}{runmed,SimpleIntegerList.Rdash.method}
\aliasA{runq,RleList-method}{AtomicList}{runq,RleList.Rdash.method}
\aliasA{runsum,RleList-method}{AtomicList}{runsum,RleList.Rdash.method}
\aliasA{runwtsum,RleList-method}{AtomicList}{runwtsum,RleList.Rdash.method}
\aliasA{sd,IntegerList-method}{AtomicList}{sd,IntegerList.Rdash.method}
\aliasA{sd,LogicalList-method}{AtomicList}{sd,LogicalList.Rdash.method}
\aliasA{sd,NumericList-method}{AtomicList}{sd,NumericList.Rdash.method}
\aliasA{sd,RleList-method}{AtomicList}{sd,RleList.Rdash.method}
\aliasA{seqselect<-,CompressedAtomicList-method}{AtomicList}{seqselect<.Rdash.,CompressedAtomicList.Rdash.method}
\aliasA{seqselect<-,SimpleAtomicList-method}{AtomicList}{seqselect<.Rdash.,SimpleAtomicList.Rdash.method}
\aliasA{show,AtomicList-method}{AtomicList}{show,AtomicList.Rdash.method}
\aliasA{show,RleList-method}{AtomicList}{show,RleList.Rdash.method}
\aliasA{SimpleAtomicList-class}{AtomicList}{SimpleAtomicList.Rdash.class}
\aliasA{SimpleCharacterList}{AtomicList}{SimpleCharacterList}
\aliasA{SimpleCharacterList-class}{AtomicList}{SimpleCharacterList.Rdash.class}
\aliasA{SimpleComplexList}{AtomicList}{SimpleComplexList}
\aliasA{SimpleComplexList-class}{AtomicList}{SimpleComplexList.Rdash.class}
\aliasA{SimpleIntegerList}{AtomicList}{SimpleIntegerList}
\aliasA{SimpleIntegerList-class}{AtomicList}{SimpleIntegerList.Rdash.class}
\aliasA{SimpleLogicalList}{AtomicList}{SimpleLogicalList}
\aliasA{SimpleLogicalList-class}{AtomicList}{SimpleLogicalList.Rdash.class}
\aliasA{SimpleNumericList}{AtomicList}{SimpleNumericList}
\aliasA{SimpleNumericList-class}{AtomicList}{SimpleNumericList.Rdash.class}
\aliasA{SimpleRawList}{AtomicList}{SimpleRawList}
\aliasA{SimpleRawList-class}{AtomicList}{SimpleRawList.Rdash.class}
\aliasA{SimpleRleList}{AtomicList}{SimpleRleList}
\aliasA{SimpleRleList-class}{AtomicList}{SimpleRleList.Rdash.class}
\aliasA{smoothEnds,CompressedIntegerList-method}{AtomicList}{smoothEnds,CompressedIntegerList.Rdash.method}
\aliasA{smoothEnds,NumericList-method}{AtomicList}{smoothEnds,NumericList.Rdash.method}
\aliasA{smoothEnds,RleList-method}{AtomicList}{smoothEnds,RleList.Rdash.method}
\aliasA{smoothEnds,SimpleIntegerList-method}{AtomicList}{smoothEnds,SimpleIntegerList.Rdash.method}
\aliasA{sort,AtomicList-method}{AtomicList}{sort,AtomicList.Rdash.method}
\aliasA{sub,ANY,ANY,CompressedCharacterList-method}{AtomicList}{sub,ANY,ANY,CompressedCharacterList.Rdash.method}
\aliasA{sub,ANY,ANY,CompressedRleList-method}{AtomicList}{sub,ANY,ANY,CompressedRleList.Rdash.method}
\aliasA{sub,ANY,ANY,SimpleCharacterList-method}{AtomicList}{sub,ANY,ANY,SimpleCharacterList.Rdash.method}
\aliasA{sub,ANY,ANY,SimpleRleList-method}{AtomicList}{sub,ANY,ANY,SimpleRleList.Rdash.method}
\aliasA{Summary,AtomicList-method}{AtomicList}{Summary,AtomicList.Rdash.method}
\aliasA{table,CompressedAtomicList-method}{AtomicList}{table,CompressedAtomicList.Rdash.method}
\aliasA{table,SimpleAtomicList-method}{AtomicList}{table,SimpleAtomicList.Rdash.method}
\aliasA{tolower,CompressedCharacterList-method}{AtomicList}{tolower,CompressedCharacterList.Rdash.method}
\aliasA{tolower,CompressedRleList-method}{AtomicList}{tolower,CompressedRleList.Rdash.method}
\aliasA{tolower,SimpleCharacterList-method}{AtomicList}{tolower,SimpleCharacterList.Rdash.method}
\aliasA{tolower,SimpleRleList-method}{AtomicList}{tolower,SimpleRleList.Rdash.method}
\aliasA{toupper,CompressedCharacterList-method}{AtomicList}{toupper,CompressedCharacterList.Rdash.method}
\aliasA{toupper,CompressedRleList-method}{AtomicList}{toupper,CompressedRleList.Rdash.method}
\aliasA{toupper,SimpleCharacterList-method}{AtomicList}{toupper,SimpleCharacterList.Rdash.method}
\aliasA{toupper,SimpleRleList-method}{AtomicList}{toupper,SimpleRleList.Rdash.method}
\aliasA{unique,AtomicList-method}{AtomicList}{unique,AtomicList.Rdash.method}
\aliasA{unique,CompressedRleList-method}{AtomicList}{unique,CompressedRleList.Rdash.method}
\aliasA{unique,SimpleRleList-method}{AtomicList}{unique,SimpleRleList.Rdash.method}
\aliasA{var,IntegerList,AtomicList-method}{AtomicList}{var,IntegerList,AtomicList.Rdash.method}
\aliasA{var,IntegerList,missing-method}{AtomicList}{var,IntegerList,missing.Rdash.method}
\aliasA{var,LogicalList,AtomicList-method}{AtomicList}{var,LogicalList,AtomicList.Rdash.method}
\aliasA{var,LogicalList,missing-method}{AtomicList}{var,LogicalList,missing.Rdash.method}
\aliasA{var,NumericList,AtomicList-method}{AtomicList}{var,NumericList,AtomicList.Rdash.method}
\aliasA{var,NumericList,missing-method}{AtomicList}{var,NumericList,missing.Rdash.method}
\aliasA{var,RleList,AtomicList-method}{AtomicList}{var,RleList,AtomicList.Rdash.method}
\aliasA{var,RleList,missing-method}{AtomicList}{var,RleList,missing.Rdash.method}
\aliasA{which,CompressedLogicalList-method}{AtomicList}{which,CompressedLogicalList.Rdash.method}
\aliasA{which,CompressedRleList-method}{AtomicList}{which,CompressedRleList.Rdash.method}
\aliasA{which,SimpleLogicalList-method}{AtomicList}{which,SimpleLogicalList.Rdash.method}
\aliasA{which,SimpleRleList-method}{AtomicList}{which,SimpleRleList.Rdash.method}
\aliasA{\%in\%,CompressedAtomicList,atomic-method}{AtomicList}{.Rpcent.in.Rpcent.,CompressedAtomicList,atomic.Rdash.method}
\aliasA{\%in\%,CompressedAtomicList,AtomicList-method}{AtomicList}{.Rpcent.in.Rpcent.,CompressedAtomicList,AtomicList.Rdash.method}
\aliasA{\%in\%,CompressedRleList,atomic-method}{AtomicList}{.Rpcent.in.Rpcent.,CompressedRleList,atomic.Rdash.method}
\aliasA{\%in\%,CompressedRleList,AtomicList-method}{AtomicList}{.Rpcent.in.Rpcent.,CompressedRleList,AtomicList.Rdash.method}
\aliasA{\%in\%,SimpleAtomicList,atomic-method}{AtomicList}{.Rpcent.in.Rpcent.,SimpleAtomicList,atomic.Rdash.method}
\aliasA{\%in\%,SimpleAtomicList,AtomicList-method}{AtomicList}{.Rpcent.in.Rpcent.,SimpleAtomicList,AtomicList.Rdash.method}
\aliasA{\%in\%,SimpleRleList,atomic-method}{AtomicList}{.Rpcent.in.Rpcent.,SimpleRleList,atomic.Rdash.method}
\aliasA{\%in\%,SimpleRleList,AtomicList-method}{AtomicList}{.Rpcent.in.Rpcent.,SimpleRleList,AtomicList.Rdash.method}
\keyword{methods}{AtomicList}
\keyword{classes}{AtomicList}
\begin{Description}\relax
An extension of \code{\LinkA{Sequence}{Sequence.Rdash.class}} that holds
only atomic vectors in either a natural or run-length encoded form.
\end{Description}
\begin{Details}\relax
The lists of atomic vectors are \code{LogicalList}, \code{IntegerList},
\code{NumericList}, \code{ComplexList}, \code{CharacterList}, and
\code{RawList}. There is also an \code{RleList} class for
run-length encoded versions of these atomic vector types.

Each of the above mentioned classes is virtual with Compressed* and Simple*
non-virtual representations.
\end{Details}
\begin{Section}{Constructors}
\describe{
\item[] \code{LogicalList(..., compress = TRUE)}: Concatenates the
\code{logical} vectors in \code{...} into a new \code{LogicalList}.
If \code{compress}, the internal storage of the data is compressed.
\item[] \code{IntegerList(..., compress = TRUE)}: Concatenates the
\code{integer} vectors in \code{...} into a new \code{IntegerList}.
If \code{compress}, the internal storage of the data is compressed.
\item[] \code{NumericList(..., compress = TRUE)}: Concatenates the
\code{numeric} vectors in \code{...} into a new \code{NumericList}.
If \code{compress}, the internal storage of the data is compressed.
\item[] \code{ComplexList(..., compress = TRUE)}: Concatenates the
\code{complex} vectors in \code{...} into a new \code{ComplexList}.
If \code{compress}, the internal storage of the data is compressed.
\item[] \code{CharacterList(..., compress = TRUE)}: Concatenates the
\code{character} vectors in \code{...} into a new \code{CharacterList}.
If \code{compress}, the internal storage of the data is compressed.
\item[] \code{RawList(..., compress = TRUE)}: Concatenates the
\code{raw} vectors in \code{...} into a new \code{RawList}.
If \code{compress}, the internal storage of the data is compressed.
\item[] \code{RleList(..., compress = FALSE)}: Concatenates the
run-length encoded atomic vectors in \code{...} into a new
\code{RleList}.
If \code{compress}, the internal storage of the data is compressed.
}
\end{Section}
\begin{Section}{Coercion}
\describe{
\item[] \code{as.vector(x)}, \code{as(from, "vector")}: Creates a vector based
on the values contained in \code{x}.

\item[] \code{as.logical(x)}, \code{as(from, "logical")}: Creates a logical
vector based on the values contained in \code{x}.

\item[] \code{as.integer(x)}, \code{as(from, "integer")}: Creates an integer
vector based on the values contained in \code{x}.

\item[] \code{as.numeric(x)}, \code{as(from, "numeric")}: Creates a numeric
vector based on the values contained in \code{x}.

\item[] \code{as.complex(x)}, \code{as(from, "complex")}: Creates a complex
vector based on the values contained in \code{x}.

\item[] \code{as.character(x)}, \code{as(from, "character")}: Creates a character
vector based on the values contained in \code{x}.

\item[] \code{as.raw(x)}, \code{as(from, "raw")}: Creates a raw
vector based on the values contained in \code{x}.

\item[] \code{as.factor(x)}, \code{as(from, "factor")}: Creates a factor object
based on the values contained in \code{x}.

\item[] \code{as.data.frame(x, row.names = NULL, optional = FALSE)},
\code{as(from, "data.frame")}: Creates a \code{data.frame} object based
on the values contained in \code{x}. Essentially the same as calling
\code{data.frame(space=rep(names(x), elementLengths(x)), as.vector(x))}.

\item[] \code{as(from, "CompressedSplitDataFrameList")},
\code{as(from, "SimpleSplitDataFrameList")}: Creates a
\LinkA{CompressedSplitDataFrameList}{CompressedSplitDataFrameList.Rdash.class}/\LinkA{SimpleSplitDataFrameList}{SimpleSplitDataFrameList.Rdash.class}
instance from an AtomicList instance.

\item[] \code{as(from, "IRangesList")}, \code{as(from, "CompressedIRangesList")},
\code{as(from, "SimpleIRangesList")}: Creates a
\LinkA{CompressedIRangesList}{CompressedIRangesList.Rdash.class}/\LinkA{SimpleIRangesList}{SimpleIRangesList.Rdash.class}
instance from a LogicalList or logical RleList instance. Note that the
elements of this instance are guaranteed to be normal.

\item[] \code{as(from, "NormalIRangesList")},
\code{as(from, "CompressedNormalIRangesList")},
\code{as(from, "SimpleNormalIRangesList")}: Creates a
\LinkA{CompressedNormalIRangesList}{CompressedNormalIRangesList.Rdash.class}/\LinkA{SimpleNormalIRangesList}{SimpleNormalIRangesList.Rdash.class}
instance from a LogicalList or logical RleList instance.

\item[] \code{as(from, "AtomicList")}: If \code{from} is a vector,
converts it to an \code{AtomicList} of the appropriate type.

}
\end{Section}
\begin{Section}{Group Generics}
AtomicList objects have support for S4 group generic functionality to operate
within elements across objects:
\describe{
\item[\code{Arith}] \code{"+"}, \code{"-"}, \code{"*"}, \code{"\textasciicircum{}"},
\code{"\%\%"}, \code{"\%/\%"}, \code{"/"}
\item[\code{Compare}] \code{"=="}, \code{">"}, \code{"<"}, \code{"!="}, 
\code{"<="}, \code{">="}
\item[\code{Logic}] \code{"\&"}, \code{"|"}
\item[\code{Ops}] \code{"Arith"}, \code{"Compare"}, \code{"Logic"}
\item[\code{Math}] \code{"abs"}, \code{"sign"}, \code{"sqrt"},
\code{"ceiling"}, \code{"floor"}, \code{"trunc"}, \code{"cummax"},
\code{"cummin"}, \code{"cumprod"}, \code{"cumsum"}, \code{"log"},
\code{"log10"}, \code{"log2"}, \code{"log1p"}, \code{"acos"},
\code{"acosh"}, \code{"asin"}, \code{"asinh"}, \code{"atan"},
\code{"atanh"}, \code{"exp"}, \code{"expm1"}, \code{"cos"},
\code{"cosh"}, \code{"sin"}, \code{"sinh"}, \code{"tan"}, \code{"tanh"},
\code{"gamma"}, \code{"lgamma"}, \code{"digamma"}, \code{"trigamma"}
\item[\code{Math2}] \code{"round"}, \code{"signif"}
\item[\code{Summary}] \code{"max"}, \code{"min"}, \code{"range"},
\code{"prod"}, \code{"sum"}, \code{"any"}, \code{"all"}
\item[\code{Complex}] \code{"Arg"}, \code{"Conj"}, \code{"Im"},
\code{"Mod"}, \code{"Re"}
}
See \LinkA{S4groupGeneric}{S4groupGeneric} for more details.
\end{Section}
\begin{Section}{Other Basic Methods}
The AtomicList objects also support a large number of basic methods.
Like the group generics above, these methods perform the corresponding
operation on each element of the list separately. The methods are: 

\describe{
\item[General] \code{\%in\%}, \code{is.na}, \code{match}, \code{sort},
\code{table}, \code{unique}
\item[Logical] \code{!}, \code{which}
\item[Numeric] \code{diff},
\code{pmax}, \code{pmax.int}, \code{pmin}, \code{pmin.int},
\code{mean}, \code{var}, \code{cov}, \code{cor}, \code{sd},
\code{median}, \code{quantile}, \code{mad}, \code{IQR}
\item[Running Window] \code{smoothEnds}, \code{runmed}. \code{runmean},
\code{runsum}, \code{runwtsum}, \code{runq}
\item[Character] \code{nchar}, \code{chartr}, \code{tolower},
\code{toupper}, \code{sub}, \code{gsub}
}
\end{Section}
\begin{Author}\relax
P. Aboyoun
\end{Author}
\begin{SeeAlso}\relax
\code{\LinkA{Sequence}{Sequence.Rdash.class}} for the applicable methods.
\end{SeeAlso}
\begin{Examples}
\begin{ExampleCode}
  int1 <- c(1L,2L,3L,5L,2L,8L)
  int2 <- c(15L,45L,20L,1L,15L,100L,80L,5L)
  collection <- IntegerList(int1, int2)

  ## names
  names(collection) <- c("one", "two")
  names(collection)
  names(collection) <- NULL # clear names
  names(collection)
  names(collection) <- "one"
  names(collection) # c("one", NA)

  ## extraction
  collection[[1]] # range1
  collection[["1"]] # NULL, does not exist
  collection[["one"]] # range1
  collection[[NA_integer_]] # NULL

  ## subsetting
  collection[numeric()] # empty
  collection[NULL] # empty
  collection[] # identity
  collection[c(TRUE, FALSE)] # first element
  collection[2] # second element
  collection[c(2,1)] # reversed
  collection[-1] # drop first
  collection$one

  ## replacement
  collection$one <- int2
  collection[[2]] <- int1

  ## combining
  col1 <- IntegerList(one = int1, int2)
  col2 <- IntegerList(two = int2, one = int1)
  col3 <- IntegerList(int2)
  append(col1, col2)
  append(col1, col2, 0)
  c(col1, col2, col3)

  ## group generics
  2 * col1
  col1 + col1
  col1 > 2
  log(col1)
  sum(col1)

  ## get the mean for each element
  sapply(col1, mean)
\end{ExampleCode}
\end{Examples}

