# The R object classes that turn up inside a package's data/ directory. # Generated from reference/r-object-catalog.json. Coverage says what the # analyzer reads out of each class, not what the class can hold. version: 2 classes: - class: igraph package: igraph domain: graphs family: ragged storage_form: igraph serialisable: direct status: current coverage: partial trigger: 'class.iter().any(|c| c == "igraph")' extracts: - n_vertices - n_edges - directed - n_missing_total gaps: - 'the graph, vertex and edge attribute lists are not read, so a weighted or named graph reports neither weights nor names' note: 'A graph: vertices, edges, and attributes on either. Stored as a plain list with a fixed layout, which is why the counts are readable without igraph installed. That layout changed in igraph 2.0, so a graph saved before it needs upgrade_graph() and a reader that assumes the current layout is reading the wrong slots on an old one.' verified: true failure_mode: stale-version - class: big.matrix package: bigmemory domain: handles family: handle storage_form: a big.matrix.descriptor plus a backing file found_in: both found_in_note: The descriptor saves into data/. The backing file it names has to travel separately. serialisable: wrapped status: current coverage: 'none' failure_mode: 'null-pointer' note: 'A matrix held outside R''s memory so it can outgrow it. The object is a pointer to that memory, so what a package bundles is the descriptor and the backing file, attached with attach.big.matrix().' verified: true - class: environment package: base domain: handles family: handle storage_form: environment serialisable: direct status: current coverage: 'none' note: 'A binding from names to values. R writes a user environment with everything in it, so the contents do travel. What is written by reference instead is the global environment and any package or namespace environment, which come back attached to whatever the loading session has. Nothing here descends into one, so an object that keeps its data in an environment reports a class name and no shape, and that is this reader rather than the format.' verified: true - class: ffdf package: ff domain: handles family: handle storage_form: an ff file on disk plus its metadata found_in: both found_in_note: The metadata saves into data/. The ff file it points at has to travel separately. serialisable: wrapped status: current coverage: 'none' aliases: - ff - ff_matrix failure_mode: path-reference note: 'A frame whose columns live in files on disk, paged in as needed. It saves and loads without error and works until the files move, which makes it the path-reference failure rather than the pointer one.' verified: true - class: function package: base domain: handles family: handle storage_form: function serialisable: direct status: current coverage: 'none' note: 'A closure: its arguments, its body, and the environment it was defined in. It saves and loads, but the environment it carries can pull an entire session''s worth of objects into the file with it.' verified: true - class: Table package: arrow domain: handles family: handle storage_form: a .parquet or .feather file read at use time found_in: inst/extdata found_in_note: The parquet or feather file is the thing bundled. Nothing useful goes in data/. serialisable: 'not-serialisable' status: current coverage: 'none' note: 'An Arrow table lives in C++ memory behind a handle. Saving one raises no error and every method then fails on the restored object, which makes it a quiet trap rather than a loud one. Put the parquet file under inst/extdata instead.' verified: true failure_mode: 'null-pointer' - class: xml_document package: xml2 domain: handles family: handle storage_form: the XML file itself found_in: inst/extdata found_in_note: The XML file itself is bundled and parsed at use time. serialisable: 'not-serialisable' status: current coverage: 'none' failure_mode: 'null-pointer' note: 'A parsed XML tree held by libxml2. The R object is a pointer to it, so a saved document restores as a handle to nothing and every accessor fails.' verified: true - class: array package: base domain: matrix-array family: dim storage_form: array serialisable: direct status: current coverage: full extracts: - dim - n_dim - length - type - mean - median - value_min - value_max - sd - summary_over - n_missing_total gaps: - 'nrow and ncol are left unset beyond two dimensions, so the browse table shows a dash where the dim vector has the answer' note: 'A matrix of more than two dimensions. R treats a matrix as the two-dimensional case of the same thing, and the values are summarised the same way, flattened to one vector, which is what summary() on an array does too.' verified: true - class: ddiMatrix package: Matrix domain: matrix-array family: recipe storage_form: ddiMatrix serialisable: direct status: current coverage: full extracts: - n_stored - density - matrix_shape - type - n_missing_total note: 'A diagonal matrix. Only the diagonal is stored, so an n by n identity costs n numbers rather than n squared.' verified: true - class: dgCMatrix package: Matrix domain: matrix-array family: recipe storage_form: dgCMatrix serialisable: direct status: current coverage: full extracts: - n_stored - n_nonzero - n_cells - density - matrix_shape - matrix_storage - matrix_value_type - n_missing_total note: 'A general sparse matrix in compressed column form, which is the format most of R''s sparse linear algebra expects. What reaches the disk is the recipe rather than the cells: the row indices i, the column pointers p, the values x and a Dim. Only the stored entries are kept, so a summary of its values is a summary of those and not of every cell.' verified: true - class: dgeMatrix package: Matrix domain: matrix-array family: dim storage_form: dgeMatrix serialisable: direct status: current coverage: full extracts: - n_stored - density - matrix_shape - type - mean - n_missing_total note: 'A dense matrix carried by Matrix rather than by base R, so it can meet a sparse one in the same arithmetic without either being converted first.' verified: true - class: dgRMatrix package: Matrix domain: matrix-array family: recipe storage_form: dgRMatrix serialisable: direct status: current coverage: full extracts: - n_stored - density - matrix_shape - matrix_storage - type - mean - n_missing_total note: 'A general sparse matrix compressed by row rather than by column. Less common than the column form, which is what most of R''s sparse solvers expect.' verified: true - class: dgTMatrix package: Matrix domain: matrix-array family: recipe storage_form: dgTMatrix serialisable: direct status: current coverage: full extracts: - n_stored - density - matrix_shape - matrix_storage - type - mean - n_missing_total note: 'A general sparse matrix in triplet form: row, column and value kept as three parallel vectors. Easy to build one entry at a time and converted to compressed form for arithmetic.' verified: true - class: dist package: stats domain: matrix-array family: recipe storage_form: dist serialisable: direct status: current coverage: partial extracts: - length - type - mean - median - value_min - value_max - n_missing_total gaps: - 'read as the flat vector it is stored as, so the number of objects it compares is not recovered from its Size attribute' note: 'A distance matrix stored as its own lower triangle in one vector. Everything that takes one, from hclust to cmdscale, reads that layout directly.' verified: true - class: dsCMatrix package: Matrix domain: matrix-array family: recipe storage_form: dsCMatrix serialisable: direct status: current coverage: full extracts: - n_stored - n_nonzero - n_cells - density - matrix_shape - matrix_storage - matrix_uplo - matrix_value_type - n_missing_total note: 'A symmetric sparse matrix. Only one triangle is stored, with the other half implied by the symmetry, which is why it holds fewer entries than it has non-zero cells.' verified: true - class: dsparseVector package: Matrix domain: matrix-array family: recipe storage_form: dsparseVector serialisable: direct status: current coverage: 'none' note: 'A sparse vector rather than a sparse matrix. It stores positions and values with no dim slot, so none of the matrix readers apply to it and it comes back as a class name.' verified: true - class: dtCMatrix package: Matrix domain: matrix-array family: recipe storage_form: dtCMatrix serialisable: direct status: current coverage: full extracts: - n_stored - density - matrix_shape - matrix_uplo - matrix_diag - type - mean - n_missing_total note: 'A triangular sparse matrix. Half the matrix is known to be zero from the shape, so it is not stored, and a solver can skip the back substitution it would otherwise do.' verified: true - class: ftable package: stats domain: matrix-array family: dim storage_form: ftable serialisable: direct status: current coverage: partial extracts: - dim - type - mean - median - value_min - value_max - n_missing_total gaps: - the row and column variable assignment that distinguishes a flat table from the array it came from is not read note: 'A contingency table flattened for printing, with several classifying variables laid along the rows and the rest along the columns.' verified: true - class: indMatrix package: Matrix domain: matrix-array family: recipe storage_form: indMatrix serialisable: direct status: current coverage: shape-only notes_tag: s4-dim-slot extracts: - nrow - ncol - dim gaps: - the index vector is the object and is not read - 'there are no values to summarise, by construction' note: 'An index matrix: each row has exactly one entry set. A one-hot encoding is one of these, and like a permutation it is stored as the indices rather than as cells.' verified: true - class: lgCMatrix package: Matrix domain: matrix-array family: recipe storage_form: lgCMatrix serialisable: direct status: current coverage: full extracts: - n_stored - density - matrix_shape - matrix_storage - type - n_missing_total note: 'A sparse matrix of logicals. Used for adjacency and incidence, where the question is whether a cell is set rather than by how much.' verified: true - class: matrix package: base domain: matrix-array family: dim storage_form: matrix serialisable: direct status: current coverage: full extracts: - dim - n_dim - dimnames - type - mean - median - value_min - value_max - n_missing_total gaps: - 'summarised across every cell as one vector, so there are no per-row or per-column figures' note: 'One vector with a dim attribute. Everything in it shares a type, which is the difference between a matrix and a data.frame that happens to be all numeric.' verified: true - class: ngCMatrix package: Matrix domain: matrix-array family: recipe storage_form: ngCMatrix serialisable: direct status: current coverage: partial extracts: - n_stored - density - matrix_shape - matrix_storage - n_missing_total gaps: - 'there are no values to summarise, so the profile carries a density and no distribution' note: 'A pattern matrix: which cells are non-zero, with no values at all. The sparsity pattern is the data, which is what a graph or a design structure often needs.' verified: true - class: pMatrix package: Matrix domain: matrix-array family: recipe storage_form: pMatrix serialisable: direct status: current coverage: shape-only notes_tag: s4-dim-slot extracts: - nrow - ncol - dim gaps: - 'the permutation vector is the object and is not read, so nothing says what the reordering is' - 'there are no values to summarise, by construction' note: 'A permutation matrix, stored as the permutation itself rather than as cells. Multiplying by one reorders rows or columns, which is why it needs no values at all.' verified: true - class: table package: base domain: matrix-array family: dim storage_form: table serialisable: direct status: current coverage: full extracts: - dim - dimnames - type - mean - median - value_min - value_max - n_missing_total gaps: - 'summarised across every cell, so no per-margin totals' note: 'A contingency table: counts in an array whose dimnames carry both the categories and the variables they came from. The variable names are what make it readable as a cross-tabulation rather than as a bare matrix.' verified: true - class: aov package: stats domain: models family: ragged storage_form: aov serialisable: direct status: current coverage: partial extracts: - element_names - element_classes - element_lens - max_depth - elements - attrs_other gaps: - 'the ANOVA table itself is computed on demand rather than stored, so nothing here is that table' note: 'An analysis of variance fit. It is an lm underneath with the terms arranged for the ANOVA table, which is why the class chain says aov and then lm.' verified: true - class: coxph package: survival domain: models family: ragged storage_form: coxph serialisable: direct status: current coverage: partial extracts: - element_names - element_classes - max_depth - n_missing_total gaps: - the formula and the baseline hazard are not read note: 'A fitted proportional hazards model, carrying coefficients, their variance, and the survival object it was fitted to.' verified: true - class: dendrogram package: stats domain: models family: ragged storage_form: dendrogram serialisable: direct status: current coverage: shape-only extracts: - max_depth - length - type gaps: - the branch attributes carrying heights and labels are not read at any level - 'no leaf count' note: 'The same clustering as a nested list, one element per branch, with attributes carrying the height and the labels. Deeply recursive, which is the one thing about it that is measured.' verified: true - class: gam package: mgcv domain: models family: ragged storage_form: gam serialisable: direct status: current coverage: partial extracts: - element_names - element_classes - element_lens - max_depth - elements - attrs_other gaps: - 'the smooth terms are a list of basis objects that are listed rather than opened, so neither the number of smooths nor their bases is read' - the formula is a language object and is not rendered note: 'A generalised additive model: a glm whose terms can be smooths fitted from the data rather than fixed shapes. It inherits from glm and lm, so its class chain is three deep and its slot list is the longest of any model here.' verified: true - class: glm package: stats domain: models family: ragged storage_form: glm serialisable: direct status: current coverage: partial extracts: - element_names - element_classes - max_depth - inner_nrow_total - n_missing_total gaps: - 'the family and link are not read, so a logistic and a Poisson fit look the same here' - the formula is not rendered note: 'A fitted generalised linear model. Everything an lm carries, plus the family and the link, which sit in a slot the reader lists by name without opening.' verified: true - class: glmnet package: glmnet domain: models family: ragged storage_form: glmnet serialisable: direct status: current coverage: partial extracts: - element_names - element_classes - element_lens - max_depth - elements - attrs_other gaps: - 'the coefficient matrix is sparse and is listed rather than summarised, so neither the path length nor the number of non-zero coefficients is read' note: 'A regularisation path: one fit per penalty value rather than one fit. That is why it holds a matrix of coefficients rather than a vector, and why a bundled example of one is larger than an lm.' verified: true - class: hclust package: stats domain: models family: ragged storage_form: hclust serialisable: direct status: current coverage: partial extracts: - element_names - element_classes - length - n_missing_total gaps: - the leaf count and the tree height are inside the merge and height vectors and are not read note: 'A hierarchical clustering: the merge order, the heights the merges happened at, and the leaf order for drawing. Not a tree structure but the instructions for building one.' verified: true - class: htest package: stats domain: models family: ragged storage_form: htest serialisable: direct status: current coverage: partial extracts: - element_names - element_classes - length - n_missing_total gaps: - 'the values sit in a list and are listed by slot rather than read, so neither the statistic nor the p value is extracted' note: 'The result of a hypothesis test: statistic, p value, confidence interval, and the names of what was compared. Every test in stats returns this one shape, which is why the class is so common.' verified: true - class: lm package: stats domain: models family: ragged storage_form: lm serialisable: direct status: current coverage: partial extracts: - element_names - element_classes - element_len_total - max_depth - inner_nrow_total - inner_names - n_missing_total gaps: - 'the formula is a language object and is not rendered, so the model is not identified' - 'no response class, and no coefficient count separate from the slot lengths' note: 'A fitted linear model. It is a plain list, so its slot names are readable without stats loaded: coefficients, residuals, fitted values, the terms object and, when the fit kept it, the model frame the data came from.' verified: true - class: lme package: nlme domain: models family: ragged storage_form: lme serialisable: direct status: current coverage: partial extracts: - element_names - element_classes - element_lens - max_depth - elements - attrs_other gaps: - the random effects structure and the grouping factors are in slots that are listed rather than read note: 'A fitted linear mixed model from nlme, the older of R''s two mixed model packages and the one that is a plain list rather than S4, which is why more of it is readable.' verified: true - class: mcmc.list package: coda domain: models family: ragged storage_form: mcmc.list serialisable: direct status: current coverage: shape-only extracts: - length - type gaps: - 'the chains are matrices inside a list and are not descended into, so neither the draw count nor the parameter names is read' note: 'Parallel MCMC chains, each a matrix of draws by parameter. What every Bayesian sampler in R is converted to before it is diagnosed.' verified: true - class: merMod package: lme4 domain: models family: sealed storage_form: merMod serialisable: direct status: current coverage: shape-only notes_tag: s4-assay-dims extracts: - object_system - s4_package gaps: - the shape comes from the first matrix found in a slot rather than from the model - 'no fixed effects, no random effect structure and no observation count' note: 'A fitted mixed model. Unlike the other model classes it is S4 rather than a list, so it falls to the S4 path and a matrix found in one of its slots is reported as the object''s shape.' verified: true aliases: - lmerMod - glmerMod - nlmerMod failure_mode: definition-missing - class: nls package: stats domain: models family: ragged storage_form: nls serialisable: direct status: current coverage: partial extracts: - element_names - element_classes - element_lens - max_depth - elements - attrs_other gaps: - the model function is a closure and is not read - 'no convergence information is extracted' note: 'A nonlinear least squares fit. Small, because it stores the model function and the converged parameters rather than a design matrix.' verified: true - class: prcomp package: stats domain: models family: ragged storage_form: prcomp serialisable: direct status: current coverage: partial extracts: - element_names - element_classes - length - n_missing_total gaps: - the component count and the variance explained are not derived from the slots note: 'A principal components fit: the rotation matrix, the standard deviations, and optionally the rotated data. Small and self-contained, which is why it is a common thing to bundle.' verified: true - class: randomForest package: randomForest domain: models family: ragged storage_form: randomForest serialisable: direct status: current coverage: partial extracts: - element_names - element_classes - max_depth - n_missing_total gaps: - 'the tree count, the mtry setting and the out-of-bag error sit in slots that are listed rather than read' note: 'A fitted forest. It keeps per-tree structure and the out-of-bag error trace, which is why the object is large relative to the data it was fitted to.' verified: true - class: rpart package: rpart domain: models family: ragged storage_form: rpart serialisable: direct status: current coverage: partial extracts: - element_names - element_classes - max_depth - inner_nrow_total - inner_names - n_missing_total gaps: - 'the node table is reached as an anonymous nested frame, so neither the depth nor the leaf count is derived from it' note: 'A fitted classification or regression tree. Its frame slot is a data.frame with one row per node, which is why a tree reports rows nested inside it.' verified: true - class: survfit package: survival domain: models family: ragged storage_form: survfit serialisable: direct status: current coverage: partial extracts: - element_names - element_classes - length - n_missing_total gaps: - 'the curve is a set of parallel vectors that are listed rather than summarised, so neither the follow-up time nor the event count is extracted' note: 'An estimated survival curve: times, numbers at risk, numbers of events, and the step function itself. What a Kaplan-Meier plot is drawn from.' verified: true - class: RasterBrick package: raster domain: spatial-raster family: grid storage_form: RasterBrick serialisable: direct status: superseded superseded_by: 'terra::SpatRaster' coverage: full notes_tag: raster-grid trigger: 'klass.starts_with("Raster")' extracts: - n_layers - resolution - 'nodata_value' - in_memory - layer_names - layer_min - layer_max - bbox - crs_input - crs_epsg - n_missing_total note: 'A multi-layer grid from the raster package. raster was the standard for gridded work in R for over a decade, and its author''s successor package terra now does the same job faster and with a simpler set of classes.' verified: true - class: RasterLayer package: raster domain: spatial-raster family: grid storage_form: RasterLayer serialisable: direct status: superseded superseded_by: 'terra::SpatRaster' coverage: full notes_tag: raster-grid trigger: 'klass.starts_with("Raster")' extracts: - n_layers - resolution - in_memory - layer_names - crs_input - crs_epsg - bbox - nrow - ncol - length - type - mean - n_missing_total note: A single-layer grid from the raster package. A RasterBrick or RasterStack is the same thing carrying several layers over one geometry. verified: true - class: RasterStack package: raster domain: spatial-raster family: grid storage_form: RasterStack found_in: both found_in_note: Saves into data/ carrying paths. The raster files those paths name have to travel too. serialisable: direct status: superseded superseded_by: 'terra::SpatRaster' coverage: partial notes_tag: raster-grid trigger: 'klass.starts_with("Raster")' extracts: - resolution - bbox - nrow - ncol - length - n_missing_total gaps: - 'the layers slot holds a raster object per layer and is not walked, so there are no layer names, no per-layer ranges and no values at all' - 'a stack can reference layers held in separate files, and those are not followed' note: 'Several grids treated as one object. Unlike a brick it keeps a separate raster per layer rather than one block of values, which is why a brick is read in full and a stack is not.' verified: true failure_mode: path-reference - class: SpatialGridDataFrame package: sp domain: spatial-raster family: grid storage_form: SpatialGridDataFrame serialisable: direct status: superseded superseded_by: 'terra::SpatRaster' coverage: partial extracts: - nrow - ncol - bbox - columns - n_missing_total gaps: - 'the grid topology slot holding the cell size and the origin is not read, so there is no resolution' - the cell values are read as an attribute table rather than as a grid note: 'A regular grid with a value table, from sp. The rows are cells rather than features, which is why its shape reads as a long thin table rather than as the grid it is.' verified: true - class: SpatialPixelsDataFrame package: sp domain: spatial-raster family: grid storage_form: SpatialPixelsDataFrame serialisable: direct status: superseded superseded_by: 'terra::SpatRaster' coverage: partial notes_tag: sp-spatial extracts: - nrow - ncol - bbox - columns - n_missing_total gaps: - 'the grid topology carrying the cell size and the origin is not read, so there is no resolution' - 'nothing in the profile distinguishes it from a full grid' note: 'A grid stored as the cells that have values rather than as a full rectangle, which is what makes it different from a SpatialGridDataFrame and much smaller for a sparse coverage.' verified: true - class: SpatRaster package: terra domain: spatial-raster family: grid storage_form: PackedSpatRaster serialisable: wrapped status: current coverage: partial notes_tag: terra-packed trigger: 'klass.starts_with("Packed")' extracts: - nrow - ncol - n_layers - crs_input - n_missing_total gaps: - 'the cell values are not read, so there is no distribution' - resolution and extent are not recovered from the packed form - per-layer ranges are not available note: 'The current way to hold gridded data in R, and the successor to the raster package''s classes. A SpatRaster holds a pointer into terra''s C++ side, so it cannot be saved directly. terra::wrap() turns it into a PackedSpatRaster first, and that is what a package actually bundles.' verified: true aliases: - PackedSpatRaster failure_mode: 'null-pointer' - class: sf package: sf domain: spatial-vector family: geometry storage_form: sf serialisable: direct status: current coverage: partial extracts: - geom_type - n_geometries - bbox - crs_epsg - columns - n_missing_total gaps: - the coordinates themselves are not summarised note: 'A data.frame with a geometry column. Every other column is ordinary data about the feature in the same row, which is why the attribute columns profile exactly as a plain table''s do.' verified: true failure_mode: stale-version - class: sfc package: sf domain: spatial-vector family: geometry storage_form: sfc serialisable: direct status: current coverage: partial trigger: 'class.iter().any(|c| c.starts_with("sfc"))' extracts: - geom_type - geom_dimension - n_geometries - n_empty - bbox - crs_input - crs_epsg - crs_wkt - n_missing_total gaps: - 'the coordinates themselves are not summarised, so there is no vertex count and no measure of geometry complexity' note: 'The geometry column of an sf table. Each element is one feature''s shape, and the column as a whole carries the coordinate reference system and the bounding box. This is where R''s vector spatial work has been since sf replaced sp.' verified: true - class: SpatialLinesDataFrame package: sp domain: spatial-vector family: geometry storage_form: SpatialLinesDataFrame serialisable: direct status: superseded superseded_by: sf coverage: partial notes_tag: sp-spatial extracts: - nrow - ncol - bbox - columns - n_missing_total gaps: - 'the lines slot is not walked, so there is no vertex or part count' note: 'Lines with a table of attributes, from sp. The geometry sits in a slot of nested lists, one per feature, which is why the shape reported is the attribute table''s rather than the geometry''s.' verified: true - class: SpatialPointsDataFrame package: sp domain: spatial-vector family: geometry storage_form: SpatialPointsDataFrame serialisable: direct status: superseded superseded_by: sf coverage: partial extracts: - nrow - ncol - bbox - crs_input - columns - n_missing_total gaps: - 'the coordinates are in a slot the reader does not open, so there is no point count independent of the attribute table' note: 'Points with a table of attributes, from the package that carried R''s vector GIS before sf. The projection libraries it depended on have since been retired.' verified: true - class: SpatialPolygons package: sp domain: spatial-vector family: geometry storage_form: SpatialPolygons serialisable: direct status: superseded superseded_by: sf coverage: shape-only notes_tag: sp-spatial-geometry-only extracts: - bbox - is_spatial gaps: - 'no feature count and no vertex count, because the polygons slot is not walked' note: 'Polygons with no attribute table, which is the geometry half of a SpatialPolygonsDataFrame. With no table there is no shape to report, so it comes back as an extent and nothing else.' verified: true - class: SpatialPolygonsDataFrame package: sp domain: spatial-vector family: geometry storage_form: SpatialPolygonsDataFrame serialisable: direct status: superseded superseded_by: sf coverage: partial trigger: 'sp_bbox.is_some() || klass.starts_with("Spatial")' extracts: - nrow - bbox - crs_input - is_spatial - n_missing_total gaps: - 'the geometry slot is not walked, so there is no feature count and no geometry type' note: 'The S4 spatial classes that carried R''s vector GIS work before sf. The attribute table sits in a data slot and the shapes in a polygons slot beside it, rather than in one column of one table. Reading one today needs sp installed, and the packages it depended on for projections and geometry operations have been retired.' verified: true - class: SpatVector package: terra domain: spatial-vector family: geometry storage_form: PackedSpatVector serialisable: wrapped status: current coverage: shape-only extracts: - nrow - ncol gaps: - 'the packed form falls through to the assay-matrix reader, which reports the coordinate matrix as the object''s shape and tags it s4-assay-dims' - 'no geometry type, no feature count, no CRS and no extent' note: 'terra''s vector counterpart to SpatRaster, and the modern replacement for sp''s Spatial classes. Like a SpatRaster it holds a pointer and has to go through terra::wrap() before it can be saved.' verified: true aliases: - PackedSpatVector failure_mode: 'null-pointer' - class: AnnotatedDataFrame package: Biobase origin: bioconductor domain: tabular-and-other family: sealed storage_form: AnnotatedDataFrame serialisable: direct status: superseded superseded_by: 'S4Vectors::DFrame' coverage: 'none' notes_tag: s4-class-only note: 'A data.frame with a second frame describing what its columns mean, used for the sample and feature annotation of an ExpressionSet.' verified: true failure_mode: definition-missing - class: data.frame package: base domain: tabular-and-other family: frame storage_form: data.frame serialisable: direct status: current coverage: full extracts: - nrow - ncol - columns - has_rownames - frame_class - n_missing_total note: 'A list of equal-length columns presented as a table. Almost everything rectangular in R inherits from it, which is why the class column so often has more than one entry.' verified: true - class: data.table package: data.table domain: tabular-and-other family: frame storage_form: data.table serialisable: direct status: current coverage: full extracts: - nrow - ncol - columns - frame_class - dt_key - dt_indices - n_missing_total note: 'A data.frame with a key. The key is a sort order held with the table, and it is what makes joins and lookups fast, so it survives being saved and describes the file rather than a session. Loaded from an rda its internal self-reference is stale, so the first assignment by reference warns unless the package calls setalloccol() when it loads.' verified: true failure_mode: stale-version - class: DFrame package: S4Vectors origin: bioconductor domain: tabular-and-other family: sealed storage_form: DFrame serialisable: direct status: current coverage: shape-only notes_tag: s4-dataframe extracts: - nrow - ncol gaps: - 'the column list is in a slot the frame reader does not reach, so there are no column names, types or profiles' note: 'Bioconductor''s DataFrame, which unlike a data.frame can hold S4 columns such as run-length encodings or genomic ranges. That flexibility is why its columns sit in a listData slot rather than where a data.frame''s do.' verified: true - class: DNAStringSet package: Biostrings origin: bioconductor domain: tabular-and-other family: recipe storage_form: DNAStringSet serialisable: direct status: current coverage: 'none' note: 'A set of biological sequences held in a compact shared buffer rather than as R character vectors, which is what makes whole-genome work fit in memory.' verified: true - class: ExpressionSet package: Biobase origin: bioconductor domain: tabular-and-other family: sealed storage_form: ExpressionSet serialisable: direct status: superseded superseded_by: 'SummarizedExperiment::SummarizedExperiment' coverage: 'none' notes_tag: s4-class-only note: 'The container Bioconductor used for assay data before SummarizedExperiment, and still common in older data packages. Its assayData is an environment rather than a slot holding a matrix. The matrix is in the file and loads intact. This reader does not descend into environments, so nothing about its shape is recovered. Unreached rather than absent.' verified: true failure_mode: definition-missing - class: grouped_df package: dplyr domain: tabular-and-other family: frame storage_form: grouped_df serialisable: direct status: current coverage: full extracts: - group_vars - n_groups - is_grouped - frame_class - nrow - ncol - columns - n_missing_total note: 'A tibble carrying a grouping, so later operations run once per group. The grouping survives being saved, which means it describes the file rather than a session.' verified: true - class: IRanges package: IRanges origin: bioconductor domain: tabular-and-other family: recipe storage_form: IRanges serialisable: direct status: current coverage: 'none' note: 'Integer intervals, given as a start and a width. The base class underneath GRanges and most of Bioconductor''s range arithmetic.' verified: true - class: list package: base domain: tabular-and-other family: ragged storage_form: list serialisable: direct status: current coverage: full extracts: - element_names - element_classes - element_len_min - element_len_max - element_len_total - max_depth - inner_nrow_total - inner_ncol - inner_names - n_missing_total gaps: - 'each element''s own length is not recorded separately, only the range across all of them' note: 'The container everything else is built on. What matters about a stored list is usually what is inside it, since a list of three elements can hold thousands of rows.' verified: true - class: Rle package: S4Vectors origin: bioconductor domain: tabular-and-other family: recipe storage_form: Rle serialisable: direct status: current coverage: 'none' note: 'A run-length encoding: values and how many times each repeats. Genomic coverage is mostly long runs of the same number, so this is often orders of magnitude smaller than the vector it stands for.' verified: true - class: rowwise_df package: dplyr domain: tabular-and-other family: frame storage_form: rowwise_df serialisable: direct status: current coverage: partial extracts: - n_groups - frame_class - nrow - ncol - columns - n_missing_total gaps: - 'the rowwise state is not detected, so it reports as an ordinary tibble whose group count happens to equal its row count' note: 'A tibble marked so that later operations run one row at a time. It uses the grouping machinery with no grouping variables, which is why its group count matches its row count.' verified: true - class: S7_object package: S7 domain: tabular-and-other family: sealed storage_form: 'the user''s own class name, stored with an S7 prefix' serialisable: direct status: current coverage: shape-only notes_tag: s4-class-only extracts: - object_system gaps: - 'the class definition travels inside the saved object and is matched on but never opened, so the declared property names and types are dropped' - 'property values are listed by name only, so an S7 object holding a table records neither its shape nor its fingerprint' note: 'The newest of R''s object systems, meant to succeed both S3 and S4. An instance is stored under its own class name rather than under S7_object, and its properties are ordinary attributes, so they are listed by name with their values unread.' verified: true failure_mode: definition-missing - class: tbl_df package: tibble domain: tabular-and-other family: frame storage_form: tbl_df serialisable: direct status: current coverage: full extracts: - nrow - ncol - columns - frame_class - group_vars - n_groups - n_missing_total note: 'A tibble. It is a data.frame with different defaults. It never converts strings to factors, never adds row names, and prints a few rows rather than all of them. A column of it can itself hold a list, which is how nested tables are stored.' verified: true - class: mts package: stats domain: time-series family: index storage_form: mts serialisable: direct status: current coverage: full extracts: - ts_start - ts_end - ts_frequency - dim - dimnames - type - mean - n_missing_total note: 'Several regular series over one index, stored as a matrix with a column per series. Everything true of ts is true of it, including that it cannot represent a gap.' verified: true - class: tbl_ts package: tsibble domain: time-series family: frame storage_form: tbl_ts serialisable: direct status: current coverage: partial extracts: - nrow - ncol - columns - frame_class - n_missing_total gaps: - 'the index and key attributes that make it a tsibble are not read, so which column is time and which identify a series are unknown' - its ordered attribute is picked up by the data.table index reader and reported as an index name note: 'A tibble that names one column as its time index and others as the keys identifying each series. Those declarations are the whole difference from a plain tibble, and they are what is not read.' verified: true - class: timeSeries package: timeSeries domain: time-series family: index storage_form: timeSeries serialisable: direct status: current coverage: partial extracts: - nrow - ncol - dimnames - units - type - mean - n_missing_total gaps: - 'the positions slot carrying the timestamps is not read, so the series has no span and no index class' note: 'The series class from the Rmetrics family, matrix-backed with its timestamps in a slot rather than in an index attribute.' verified: true - class: ts package: stats domain: time-series family: index storage_form: ts serialisable: direct status: current coverage: full extracts: - ts_start - ts_end - ts_frequency - ts_span - type - mean - median - value_min - value_max - n_missing_total note: 'Base R''s regular time series: a vector plus a tsp attribute holding a start, an end and a frequency, with every observation assumed evenly spaced. It cannot represent a gap, which is what zoo and xts were written for.' verified: true - class: xts package: xts domain: time-series family: index storage_form: xts serialisable: direct status: current coverage: full extracts: - index_start - index_end - index_class - index_tz - index_span - index_delta - index_regular - dimnames - n_missing_total note: 'A zoo series whose index is always a date or a time, which is why it carries a time zone. It is a matrix underneath, so it can hold several series over one index.' verified: true - class: yearmon package: zoo domain: time-series family: tag storage_form: yearmon serialisable: direct status: current coverage: partial extracts: - length - type - mean - value_min - value_max - n_missing_total gaps: - 'stored as a fractional year and read as a number, so the range prints as 2020.0 rather than as Jan 2020' note: 'A calendar month as a single number, the year plus the month as a twelfth. It sorts and subtracts like a number because that is what it is.' verified: true - class: yearqtr package: zoo domain: time-series family: tag storage_form: yearqtr serialisable: direct status: current coverage: partial extracts: - length - type - mean - value_min - value_max gaps: - 'stored as a fractional year and read as a number, so the range prints as 2020.0 rather than as 2020 Q1' note: 'A calendar quarter as a single number, the year plus the quarter as a fourth. The sibling of yearmon.' verified: true - class: zoo package: zoo domain: time-series family: index storage_form: zoo serialisable: direct status: current coverage: full extracts: - index_start - index_end - index_n - index_class - index_span - index_delta - index_regular - index_n_gaps - index_max_gap - n_missing_total note: 'A series in index order, with the index stored explicitly, so the observations can be irregular and the index can be any type that sorts rather than only a number.' verified: true - class: zooreg package: zoo domain: time-series family: index storage_form: zooreg serialisable: direct status: current coverage: full extracts: - ts_frequency - index_class - index_start - index_end - type - mean - n_missing_total note: 'A zoo series that also declares a frequency, so it can say it is regular rather than leaving a reader to infer it from the spacing.' verified: true - class: blob package: blob domain: vectors family: ragged storage_form: blob serialisable: direct status: current coverage: partial extracts: - length - element_lens - type gaps: - 'each element is a raw vector whose bytes are not kept, so there is a length and no content' note: 'A vector of binary blobs, one raw vector per element. What a database driver returns for a BLOB column, and what R has no other natural type for.' verified: true - class: compact_intseq package: base domain: vectors family: recipe storage_form: an integer vector serialisable: direct status: current coverage: full extracts: - length - type - mean - median - value_min - value_max - n_missing_total note: 'Not a class a package author writes, but what R stores when a vector can be described instead of listed. A compact sequence keeps a start, a length and a step. A deferred string keeps the vector it will be converted from, and a wrapper keeps the thing it wraps plus what is known about it. All travel the same way and all expand on being changed.' verified: true aliases: - compact_realseq - deferred_string - wrap_integer - wrap_real - wrap_string - wrap_logical - class: Date package: base domain: vectors family: tag storage_form: Date serialisable: direct status: current coverage: full extracts: - type - mean - median - value_min - value_max - length - n_unique - n_missing_total note: 'A calendar day, stored as the number of days since 1970. Arithmetic on it is arithmetic on that number, which is why subtracting two of them gives a difftime measured in days.' verified: true - class: difftime package: base domain: vectors family: tag storage_form: difftime serialisable: direct status: current coverage: full extracts: - units - type - mean - value_min - value_max - length - n_missing_total note: 'An elapsed time with its unit attached. The unit is chosen when the difference is taken, so the same interval can arrive as days here and as hours in the next column.' verified: true - class: Duration package: lubridate domain: vectors family: tag storage_form: Duration serialisable: direct status: current coverage: full extracts: - length - type - mean - value_min - value_max note: 'A length of time in seconds exactly, with no calendar in it. The counterpart to Period, and the difference between them is the whole of why both exist.' verified: true - class: factor package: base domain: vectors family: tag storage_form: factor serialisable: direct status: current coverage: full extracts: - levels - n_levels - level_counts - n_unique - type - length - n_missing_total note: 'A vector of codes with a level for each. The codes are what is stored. The levels give them meaning and fix the order they sort and plot in. Profiled by the same reader that profiles a factor column, so a factor stored on its own carries everything one inside a table does.' verified: true - class: haven_labelled package: haven domain: vectors family: tag storage_form: haven_labelled serialisable: direct status: current coverage: partial extracts: - type - mean - median - value_min - value_max - length - n_missing_total gaps: - 'the value labels are not read, so a column of codes has no key to what the codes mean' note: 'A vector of codes with labels attached, which is how SPSS, Stata and SAS represent a categorical. R would use a factor. This keeps the original codes so a round trip is possible.' verified: true - class: hms package: hms domain: vectors family: tag storage_form: hms serialisable: direct status: current coverage: full extracts: - units - type - mean - value_min - value_max - length - n_missing_total note: 'A time of day, stored as seconds since midnight with a units attribute. It is a difftime underneath, which is why it prints as a duration.' verified: true - class: IDate package: data.table domain: vectors family: tag storage_form: IDate serialisable: direct status: current coverage: full extracts: - type - mean - median - value_min - value_max - length note: 'A Date stored as an integer rather than a double. Same meaning, half the memory, and it sorts and subtracts identically, which is why data.table uses it by default when reading dates.' verified: true - class: integer64 package: bit64 domain: vectors family: tag storage_form: integer64 serialisable: direct status: current coverage: partial extracts: - length - type - mean - n_missing_total gaps: - 'stored as doubles with a class attribute, so the values are summarised as the doubles they are bit for bit rather than as the integers they represent' note: 'A 64 bit integer, which base R does not have. The bits are carried in a double, so anything reading it without bit64 sees meaningless floating point numbers.' verified: true - class: Interval package: lubridate domain: vectors family: tag storage_form: Interval serialisable: direct status: current coverage: partial extracts: - length - type gaps: - 'the start instant is an attribute and is not read, so an interval reports a span with no position in time' note: 'A span with a start and an end rather than only a length, so it knows which stretch of time it covers.' verified: true - class: ITime package: data.table domain: vectors family: tag storage_form: ITime serialisable: direct status: current coverage: partial extracts: - type - length - mean - value_min - value_max gaps: - 'read as the integer count of seconds it is stored as, so a time of day prints as a number' note: 'A time of day as seconds since midnight, held as an integer. The companion to IDate.' verified: true - class: ordered package: base domain: vectors family: tag storage_form: ordered serialisable: direct status: current coverage: full extracts: - levels - n_levels - level_counts - is_ordered - n_unique - type - n_missing_total note: 'A factor whose levels are ranked, so a comparison between two of them means something. The ranking is the declared order of the levels, which is stored separately from the counts.' verified: true - class: Period package: lubridate domain: vectors family: parallel storage_form: Period serialisable: direct status: current coverage: partial extracts: - length - type gaps: - 'the month, day and year components are separate attributes and are not combined, so the period is not rendered' note: 'A length of time in calendar units, where a month is a month whatever its length. Adding one to a date lands on the same day of the next month rather than a fixed number of seconds later.' verified: true - class: POSIXct package: base domain: vectors family: tag storage_form: POSIXct serialisable: direct status: current coverage: full extracts: - type - tz - mean - median - value_min - value_max - length - n_missing_total note: 'An instant, stored as seconds since 1970 with a time zone attached. The zone is not decoration. The same number prints as two different local times without it.' verified: true - class: POSIXlt package: base domain: vectors family: parallel storage_form: POSIXlt serialisable: direct status: current coverage: partial extracts: - element_names - type - length - n_missing_total gaps: - 'read as the eleven-element list it is stored as, so its length reports the fields rather than the timestamps' note: 'A timestamp broken into its parts as a list of parallel vectors, named the way R names them: sec, min, hour, mday, mon, year and so on. POSIXct is the same instant as one number, and is what almost everything stores.' verified: true - class: Surv package: survival domain: vectors family: dim storage_form: Surv serialisable: direct status: current coverage: partial extracts: - dim - dimnames - type - mean - median - value_min - value_max - n_missing_total gaps: - 'the type attribute saying whether the times are right censored, interval censored or a counting process is not read' - 'a multi-state object''s states attribute is likewise unread' note: 'A survival outcome, carried as one column of a data frame and physically a matrix of times and status codes. Without its type attribute the numbers are just numbers, and the censoring is what gives them meaning.' verified: true - class: units package: units domain: vectors family: tag storage_form: units serialisable: direct status: current coverage: full extracts: - units - type - mean - median - value_min - value_max - n_missing_total note: 'A numeric vector that knows what it measures. Arithmetic on it converts and checks units, so adding metres to seconds is an error rather than a number.' verified: true - class: vctrs_rcrd package: vctrs domain: vectors family: parallel storage_form: vctrs_rcrd serialisable: direct status: current coverage: partial aliases: - clock_year_month_day - clock_calendar - ivs_iv extracts: - element_names - element_lens - length - elements gaps: - 'a record vector is a list of parallel fields and reads as that list, so its length is the number of fields rather than the number of records' note: 'A vector whose elements have several parts, stored as parallel fields under one class. clock''s calendar types and ivs''s intervals are built on it, and read without vctrs it looks like a short list.' verified: true - class: vector package: base domain: vectors family: run storage_form: vector serialisable: direct status: current coverage: full extracts: - type - length - n_unique - n_missing_total - min_nchar - max_nchar - n_true - n_false - mean - median - value_min - value_max note: 'A bare atomic vector with no class attribute: numeric, integer, character, logical, complex or raw. It profiles through the same reader as a column of a table, so a character vector reports its distinct count and its shortest and longest strings, and a logical its true, false and missing counts. The type is reported rather than the class, because there is no class to report.' verified: true # What was hung on the run of cells to make each class, which is a different # question from the domain a reader comes looking in. families: - id: run title: A run of cells claim: 'A type and a length, and nothing hung on either. Every other figure here is this one with something attached to it.' exemplar: vector bands: - vector draws_every_member: true - id: tag title: 'The same run, read differently' claim: 'The cells do not move. One attribute says how to read them, and the reading changes completely.' exemplar: factor bands: - factor - id: recipe title: A recipe instead of the cells claim: The run is not in the file. What is written is a description short enough to rebuild it from. exemplar: dgCMatrix bands: - dgCMatrix identifies: - width - unpinned - 'noncolumnar' departs_from_run: true - id: dim title: A run with a dim claim: 'Nothing is copied. A dim attribute says to read the same run in threes. Names, where there are any, hang on the whole block rather than on a column, which is why the fingerprint of one comes down to a width and a type.' exemplar: matrix bands: - matrix identifies: - width - 'noncolumnar' draws_every_member: true - id: frame title: 'Named runs, side by side' claim: 'Not a table. A list of equal-length runs, each carrying its own name and its own type.' exemplar: data.frame bands: - data.frame identifies: - columns draws_every_member: true - id: parallel title: Parallel runs under one name claim: 'Several equal-length runs presented as one value, so a length counts the parts rather than the values.' exemplar: POSIXlt bands: - POSIXlt - id: index title: A run with an index claim: 'Values, and where each one sits. The index is either declared in an attribute or written out in full.' exemplar: ts bands: - ts - xts - id: ragged title: A list that need not line up claim: 'Elements of any length and any type, so there is no row count. A fitted model is one of these.' exemplar: list bands: - list - lm departs_from_run: true - id: geometry title: A table with the shapes beside it claim: 'One part holds the geometry: as a column of the table, or as a slot alongside it.' builds_on: frame exemplar: sf bands: - sf - SpatialPolygonsDataFrame identifies: - columns - id: grid title: A grid with a coordinate system claim: 'A fold like a matrix, with an extent and a coordinate system attached to the whole of it.' builds_on: dim exemplar: RasterLayer bands: - RasterLayer identifies: - unpinned - 'noncolumnar' draws_every_member: true - id: sealed title: Slots the reader does not open claim: 'The data is in the file, in a slot this reader does not reach.' builds_on: frame exemplar: DFrame bands: - DFrame - id: handle title: 'Nothing the reader opens' claim: 'A pointer, a path or a binding reaches the file, and nothing is read out of any of them.' exemplar: Table bands: - Table draws_every_member: true # Named from recall and never measured. No coverage claim, no field list. candidates: - class: multiPhylo package: ape domain: graphs storage_form: multiPhylo serialisable: direct status: current note: 'A list of phylogenetic trees, which is what a bootstrap or a posterior sample of trees is.' - class: network package: network domain: graphs storage_form: network serialisable: direct status: current note: 'The other long-standing graph representation in R, used by the statnet family. Stored as lists of edges and vertices rather than igraph''s vectors, so nothing that reads one reads the other.' - class: phylo package: ape domain: graphs storage_form: phylo serialisable: direct status: current note: 'A phylogenetic tree: an edge matrix, branch lengths, tip labels and an internal node count, as a plain list. One of the most commonly bundled non-rectangular objects on CRAN, and readable without ape for the same reason an igraph is.' - class: tbl_graph package: tidygraph domain: graphs storage_form: tbl_graph serialisable: direct status: current note: 'An igraph wearing a tibble interface, so nodes and edges can be handled with dplyr verbs. The graph underneath is a real igraph, which is what is actually stored.' - class: connection package: base domain: handles storage_form: reopen it at use time serialisable: 'not-serialisable' status: current failure_mode: 'null-pointer' note: 'A file, socket or pipe, held as a small integer indexing a table of open connections. Saving one writes that integer, so it restores pointing at whatever occupies that slot in the loading session. The quietest failure of the lot, because there is nothing about the restored object to suggest it is wrong.' - class: DBIConnection package: DBI domain: handles storage_form: a connection reopened with dbConnect() serialisable: 'not-serialisable' status: current failure_mode: 'null-pointer' note: 'A live handle to a database. It cannot outlive the session that opened it, let alone reach another machine, so what a package should bundle is the query result rather than the handle.' - class: envRefClass package: methods domain: handles storage_form: envRefClass serialisable: direct status: current aliases: - refObjectGenerator failure_mode: definition-missing note: 'A reference class instance, R5, which is an environment carrying fields and methods. Its contents travel, but its class definition does not, so without the defining package the fields are present and every method is gone.' - class: externalptr package: base domain: handles storage_form: externalptr serialisable: 'not-serialisable' status: current failure_mode: 'null-pointer' note: 'A raw pointer into memory owned by compiled code. It saves as a null pointer and restores as one, which is the mechanism behind every class on this page that has to be wrapped before it can be stored.' - class: formula package: stats domain: handles storage_form: formula serialisable: direct status: current aliases: - terms - call - name - expression note: 'A language object: an unevaluated expression plus the environment it was written in. That environment is why a model fitted to forty rows can save as twelve megabytes, since it can reach everything that was in scope. terms, call and name travel the same way, and a terms object sits inside every fitted model on this page.' - class: H2OFrame package: h2o domain: handles storage_form: a frame in a running h2o cluster serialisable: 'not-serialisable' status: current failure_mode: 'null-pointer' note: 'A reference to data held by an h2o cluster, not by R. It cannot outlive the cluster, let alone reach another machine.' - class: keras.engine.training.Model package: keras domain: handles storage_form: a model file written with save_model_tf() or save_model_hdf5() serialisable: 'not-serialisable' status: current failure_mode: 'null-pointer' note: 'A Keras model, which is a handle into a Python session reached through reticulate. Two layers of external state rather than one, and neither survives being written to an rda.' - class: lgb.Booster package: lightgbm domain: handles storage_form: a model file written with lgb.save() serialisable: wrapped status: current failure_mode: 'null-pointer' note: 'A fitted LightGBM model behind a pointer into its own memory, with a save format of its own. The same shape as the xgboost case.' - class: ncdf4 package: ncdf4 domain: handles storage_form: 'a NetCDF file on disk, reopened with nc_open()' serialisable: 'not-serialisable' status: current failure_mode: 'null-pointer' note: 'A handle to an open NetCDF file. The object is a file identifier and some cached metadata, so it restores pointing at a file descriptor that no longer exists. Bundle the .nc file and open it at use time.' - class: python.builtin.object package: reticulate domain: handles storage_form: whatever the Python side can write serialisable: 'not-serialisable' status: current failure_mode: 'null-pointer' note: 'Any Python object reached through reticulate. The R object is a handle into a Python session, which is the general case that the keras and torch entries are instances of.' - class: R6 package: R6 domain: handles storage_form: R6 serialisable: direct status: current note: 'An object system built on environments, giving reference semantics and methods bound to the instance. Whether one survives being saved depends entirely on what its fields hold: plain data does, an open connection or a C++ pointer does not.' - class: torch_tensor package: torch domain: handles storage_form: a file written with torch_save() serialisable: 'not-serialisable' status: current failure_mode: 'null-pointer' note: 'A tensor living in libtorch''s memory. Like the others here it saves as a pointer, and unlike most of it the failure can be silent for a while, because printing the object may work before arithmetic does.' - class: xgb.Booster package: xgboost domain: handles storage_form: a model file written with xgb.save() serialisable: 'not-serialisable' status: current failure_mode: 'null-pointer' note: 'A fitted gradient boosting model held behind a pointer into xgboost''s own memory. It has a save format of its own, and a booster saved with save() instead restores as an empty handle.' - class: DelayedArray package: DelayedArray origin: bioconductor domain: matrix-array storage_form: DelayedArray serialisable: direct status: current aliases: - DelayedMatrix note: 'An array that records the operations queued against it and applies them when the values are finally needed. Wrapping an in-memory matrix it is entirely self-contained, which is what separates it from HDF5Array: the path problem belongs to the backend, not to this class.' - class: dfm package: quanteda domain: matrix-array storage_form: dfm serialisable: direct status: current note: 'quanteda''s document feature matrix, a dgCMatrix subclass carrying document variables alongside the counts. Read as a plain sparse matrix the counts survive and the document metadata does not.' - class: DocumentTermMatrix package: tm domain: matrix-array storage_form: DocumentTermMatrix serialisable: direct status: current aliases: - TermDocumentMatrix note: 'A sparse count of terms per document, stored as a simple triplet matrix with a weighting attribute saying whether the counts are raw or scaled. The weighting is what tells a reader whether the numbers are frequencies at all.' - class: HDF5Array package: HDF5Array origin: bioconductor domain: matrix-array storage_form: an HDF5 file plus the path to it serialisable: wrapped status: current failure_mode: path-reference note: 'An array whose values stay in an HDF5 file and are read as needed. It saves and loads and keeps working, right up until the file is not where the object says it is.' - class: simple_triplet_matrix package: slam domain: matrix-array storage_form: simple_triplet_matrix serialisable: direct status: current note: 'A sparse matrix as three plain vectors of row, column and value, with no S4 machinery. The text mining packages use it, which is why a document term matrix is often one of these rather than a Matrix object.' - class: SVT_SparseMatrix package: SparseArray origin: bioconductor domain: matrix-array storage_form: SVT_SparseMatrix serialisable: direct status: current aliases: - SVT_SparseArray - COO_SparseArray note: 'The sparse type current Bioconductor containers default to, in place of the Matrix classes. It stores a vector per column rather than one long triple, and it extends to more than two dimensions, which the Matrix family does not.' - class: draws_array package: posterior domain: models storage_form: draws_array serialisable: direct status: current aliases: - draws_df - draws_matrix - draws_list - rvar note: 'The modern representation of posterior draws, replacing coda''s mcmc.list: iterations by chains by variables, with rvar carrying a whole distribution as a single vector element.' - class: draws_df package: posterior domain: models storage_form: draws_df serialisable: direct status: current aliases: - draws_matrix - draws_list - rvar note: 'Posterior draws as a data frame, one row per draw, with the chain and iteration as columns. rvar is the other side of the same package: a whole distribution carried as one element of a vector, so a mean of rvars is a distribution rather than a number.' - class: stanfit package: rstan domain: models storage_form: stanfit serialisable: direct status: current aliases: - brmsfit failure_mode: definition-missing note: 'A fitted Stan model: the draws are a plain array and survive, and the compiled model behind them is a pointer that does not. So it loads, prints and summarises correctly, and only the things needing the compiled model fail. A partial version of the pointer failure rather than the whole of it.' - class: im package: spatstat.geom domain: spatial-raster storage_form: im serialisable: direct status: current note: 'A pixel image, the raster half of spatstat. Used for covariates and for fitted intensities over the same window a point pattern was observed in.' - class: stars package: stars domain: spatial-raster storage_form: stars serialisable: direct status: current note: 'A data cube: a raster with named dimensions beyond x and y, so a stack of grids over time or over spectral bands is one object rather than a list of them. Built to sit alongside sf rather than to replace terra.' - class: stars_proxy package: stars domain: spatial-raster storage_form: the raster files plus the paths to them serialisable: wrapped status: current failure_mode: path-reference note: 'A stars cube that has not read its data: it holds the file paths and reads on demand, which is what makes a hundred gigabyte cube openable. The paths are absolute at creation.' - class: owin package: spatstat.geom domain: spatial-vector storage_form: owin serialisable: direct status: current note: 'An observation window, the region a point pattern was recorded in. Stored separately because the same window is usually shared by several patterns.' - class: ppp package: spatstat.geom domain: spatial-vector storage_form: ppp serialisable: direct status: current note: 'A point pattern: locations plus the window they were observed in. The window matters as much as the points, because it is what makes an intensity meaningful.' - class: psp package: spatstat.geom domain: spatial-vector storage_form: psp serialisable: direct status: current note: 'A line segment pattern, carrying the window it was observed in the same way a point pattern does.' - class: DNAbin package: ape domain: tabular-and-other storage_form: DNAbin serialisable: direct status: current note: 'Aligned sequences packed one base per byte in a raw matrix. Read without ape the raw bytes mean nothing, which is the same trap as integer64: the class attribute is the whole key to the values.' - class: GRanges package: GenomicRanges origin: bioconductor domain: tabular-and-other storage_form: GRanges serialisable: direct status: current note: 'Genomic intervals: an IRanges with a sequence name and a strand, plus arbitrary metadata columns. The standard currency for anything positional in a genome.' - class: GRangesList package: GenomicRanges origin: bioconductor domain: tabular-and-other storage_form: GRangesList serialisable: direct status: current note: 'Genomic intervals grouped, one group per element, which is how the exons of a transcript or the reads of a pair are held together.' - class: phyloseq package: phyloseq origin: bioconductor domain: tabular-and-other storage_form: phyloseq serialisable: direct status: current note: 'An abundance table with its taxonomy, sample data and a tree, as one S4 object. One of the most commonly bundled non-rectangular objects in Bioconductor.' - class: Seurat package: SeuratObject domain: tabular-and-other storage_form: Seurat serialisable: direct status: current failure_mode: definition-missing note: 'A single-cell container backed by sparse matrices, so it does round-trip. Its assay class changed in Seurat 5 and objects saved before that need updating before use, which is what its stored version field is for.' - class: SingleCellExperiment package: SingleCellExperiment origin: bioconductor domain: tabular-and-other storage_form: SingleCellExperiment serialisable: direct status: current failure_mode: definition-missing note: 'The container single-cell data packages actually bundle. It extends SummarizedExperiment with slots for dimensionality reductions and alternative experiments, and those sit in internal metadata rather than beside the assays, so a reader written for its parent will not reach them.' - class: SummarizedExperiment package: SummarizedExperiment origin: bioconductor domain: tabular-and-other storage_form: SummarizedExperiment serialisable: direct status: current note: 'Bioconductor''s assay container: one or more matrices of the same shape sharing row annotation for features and column annotation for samples. A reader exists for assay-shaped S4 objects and tags them s4-assay-dims, but the package is not installed here, so nothing has been checked against a real one and nothing is claimed.' - class: tokens package: quanteda domain: tabular-and-other storage_form: tokens serialisable: direct status: current note: 'A tokenised corpus: one integer vector per document, indexing a shared type table held as an attribute. Read without the type table it is a list of meaningless integers.' - class: TreeSummarizedExperiment package: TreeSummarizedExperiment origin: bioconductor domain: tabular-and-other storage_form: TreeSummarizedExperiment serialisable: direct status: current note: 'A SingleCellExperiment with phylogenetic trees on its rows and columns, used for microbiome data.' - class: AsIs package: base domain: vectors storage_form: AsIs serialisable: direct status: current note: 'The mark I() leaves. It is how a matrix or a list gets into a data.frame as one column, which is what a Surv column is, and it suppresses the conversions the frame would otherwise apply.' - class: Hmisc_labelled package: Hmisc domain: vectors storage_form: Hmisc_labelled serialisable: direct status: current aliases: - labelled note: 'A vector with a label and optionally a unit attached, from Hmisc. Distinct from haven''s labelled, which attaches value labels instead, and dominant in older clinical datasets.' - class: nanotime package: nanotime domain: vectors storage_form: nanotime serialisable: direct status: current note: 'A timestamp at nanosecond resolution, carried in a 64 bit integer. The same trap as integer64: read without the package the bits are meaningless as floating point.'