Frame (h2o-core 3.46.0 API)

java.lang.Object
- water.Iced<T>
- - water.Keyed<T>
  - - water.Lockable<Frame>
    - - water.fvec.Frame

All Implemented Interfaces:

java.io.Externalizable, java.io.Serializable, java.lang.Cloneable, Freezable<Frame>

Direct Known Subclasses:

TypedFrame, UnfoldingFrame
```
public class Frame
extends Lockable<Frame>
```
A collection of named Vecs, essentially an R-like Distributed Data Frame.
Frames represent a large distributed 2-D table with named columns (Vecs) and numbered rows. A reasonable column limit is 100K columns, but there's no hard-coded limit. There's no real row limit except memory; Frames (and Vecs) with many billions of rows are used routinely.
A Frame is a collection of named Vecs; a Vec is a collection of numbered Chunks. A Frame is small, cheaply and easily manipulated, it is commonly passed-by-Value. It exists on one node, and may be stored in the DKV. Vecs, on the other hand, must be stored in the DKV, as they represent the shared common management state for a collection of distributed Chunks.
Multiple Frames can reference the same Vecs, although this sharing can make Vec lifetime management complex. Commonly temporary Frames are used to work with a subset of some other Frame (often during algorithm execution, when some columns are dropped from the modeling process). The temporary Frame can simply be ignored, allowing the normal GC process to reclaim it. Such temp Frames usually have a null key.
All the Vecs in a Frame belong to the same Vec.VectorGroup which then enforces Chunk row alignment across Vecs (or at least enforces a low-cost access model). Parallel and distributed execution touching all the data in a Frame relies on this alignment to get good performance.
Example: Make a Frame from a CSV file:
```
  File file = ...
  NFSFileVec nfs = NFSFileVec.make(file); // NFS-backed Vec, lazily read on demand
  Frame fr = water.parser.ParseDataset.parse(Key.make("myKey"),nfs._key);
  
```
Example: Find and remove the Vec called "unique_id" from the Frame, since modeling with a unique_id can lead to overfitting:
```
  Vec uid = fr.remove("unique_id");
  
```
Example: Move the response column to the last position:
```
  fr.add("response",fr.remove("response"));
  
```
See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Frame.CSVStream`
`static class`	`Frame.CSVStreamParams`
`static class`	`Frame.DeepSelect` Last column is a bit vec indicating whether or not to take the row.
`class`	`Frame.FrameVecRegistry`
`static class`	`Frame.VecSpecifier` Pair of (column name, Frame key).

Field Summary

Fields
Modifier and Type Field and Description

java.lang.String[] _names
Vec names
- Fields inherited from class water.Lockable
  _lockers
- Fields inherited from class water.Keyed
  _key

Fields
Modifier and Type	Field and Description
`java.lang.String[]`	`_names` Vec names

Constructor Summary

Constructors
Constructor and Description
`Frame(Frame fr)` Deep copy of Vecs and Keys and Names (but not data!) to a new random Key.
`Frame(Key<Frame> key)` Creates an empty frame with given key.
`Frame(Key<Frame> key, java.lang.String[] names, Vec[] vecs)` Creates a frame with given key, names and vectors.
`Frame(Key<Frame> key, Vec[] vecs)` Creates a frame with given key, default names and vectors.
`Frame(java.lang.String[] names, Vec[] vecs)` Creates an internal frame composed of the given Vecs and names.
`Frame(Vec... vecs)` Creates an internal frame composed of the given Vecs and default names.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`Frame`	`add(Frame fr)` Append a Frame onto this Frame.
`void`	`add(java.lang.String[] names, Vec[] vecs)`
`void`	`add(java.lang.String[] names, Vec[] vecs, int cols)`
`Vec`	`add(java.lang.String name, Vec vec)` Append a named Vec to the Frame.
`Vec`	`anyVec()` Returns the first readable vector.
`Vec[]`	`bulkRollups()`
`long`	`byteSize()` The `Vec.byteSize` of all Vecs
`int[]`	`cardinality()` Number of categorical levels for categorical columns; -1 for non-categorical columns.
`protected long`	`checksum_impl(boolean noCache)` 64-bit checksum of the checksums of the vecs.
`Frame`	`deepCopy(java.lang.String keyName)` Create a copy of the input Frame and return that copied Frame.
`Frame`	`deepSlice(java.lang.Object orows, java.lang.Object ocols)` In support of R, a generic Deep Copy and Slice.
`static java.lang.String`	`defaultColName(int col)` Default column name maker
`Frame`	`delete_and_lock(Key<Job> job_key)`
`static void`	`deleteTempFrameAndItsNonSharedVecs(Frame tempFrame, Frame baseFrame)` Given a temp Frame and a base Frame from which it was created, delete the Vecs that aren't found in the base Frame and then delete the temp Frame.
`java.lang.String[][]`	`domains()` All the domains for categorical columns; null for non-categorical columns.
`static Job`	`export(Frame fr, java.lang.String path, java.lang.String frameName, boolean overwrite, int nParts)`
`static Job`	`export(Frame fr, java.lang.String path, java.lang.String frameName, boolean overwrite, int nParts, boolean parallel, java.lang.String compression, Frame.CSVStreamParams csvParms)`
`static Job`	`export(Frame fr, java.lang.String path, java.lang.String frameName, boolean overwrite, int nParts, java.lang.String compression, Frame.CSVStreamParams csvParms)`
`static Job`	`exportParquet(Frame fr, java.lang.String path, boolean overwrite, java.lang.String compression, boolean writeChecksum)`
`Frame`	`extractFrame(int startIdx, int endIdx)` Split this Frame; return a subframe created from the given column interval, and remove those columns from this Frame.
`static Frame[]`	`fetchAll()` Fetch all Frames from the KV store.
`int`	`find(Key key)` Deprecated. as many columns in a Frame could be backed by the same Vec (and its key), we can't return single column index that corresponds to a given `key`. Please use `find(String)` instead.
`int`	`find(java.lang.String name)` Finds the column index with a matching name, or -1 if missing
`int[]`	`find(java.lang.String[] names)` Bulk `find(String)` api
`int`	`find(Vec vec)` Deprecated. as many columns in a Frame could be backed by the same Vec, we can't return single column index that corresponds to a given `vec`. Please use `find(String)` instead.
`Frame.FrameVecRegistry`	`frameVecRegistry()` A structure for fast lookup in the set of frame's vectors.
`boolean`	`hasInfs()`
`boolean`	`hasNAs()`
`void`	`insertVec(int i, java.lang.String name, Vec vec)`
`boolean`	`isCompatible(Frame fr)` Frames are compatible if they have the same layout (number of rows and chunking) and the same vector group (chunk placement)..
`Key<Vec>[]`	`keys()` The array of keys.
`java.lang.Iterable<Key<Vec>>`	`keysList()`
`Vec`	`lastVec()` Convenience to accessor for last Vec
`java.lang.String`	`lastVecName()` Convenience to accessor for last Vec name
`Vec[]`	`makeCompatible(Frame f)`
`Vec[]`	`makeCompatible(Frame f, boolean force)` Return array of Vectors if 'f' is compatible with 'this', else return a new array of Vectors compatible with 'this' and a copy of 'f's data otherwise.
`java.lang.Class<KeyV3.FrameKeyV3>`	`makeSchema()`
`Frame`	`makeSimilarlyDistributed(Frame f, Key<Frame> newKey)` Make rows of a given frame distributed similarly to this frame.
`double[]`	`means()` All the column means.
`int[]`	`modes()` Majority class for categorical columns; -1 for non-categorical columns.
`void`	`moveFirst(int[] cols)` move the provided columns to be first, in-place.
`double[]`	`mults()` One over the standard deviation of each column.
`long`	`naCount()`
`double`	`naFraction()`
`java.lang.String`	`name(int i)` A single column name.
`java.lang.String[]`	`names()` The array of column names.
`int`	`numCols()` Number of columns
`long`	`numRows()` Number of rows
`Futures`	`postWrite(Futures fs)` Allow rollups for all written-into vecs; used by `MRTask` once writing is complete.
`Frame`	`prepend(java.lang.String name, Vec vec)` Insert a named column as the first column
`protected Keyed`	`readAll_impl(AutoBuffer ab, Futures fs)`
`Vec[]`	`reloadVecs()` Force a cache-flush and reload, assuming vec mappings were altered remotely, or that the _vecs array was shared and now needs to be a defensive copy.
`protected Futures`	`remove_impl(Futures fs, boolean cascade)` Actually remove/delete all Vecs from memory, not just from the Frame.
`Vec`	`remove(int idx)` Removes a numbered column.
`Vec[]`	`remove(int[] idxs)` Removes a list of columns by index; the index list must be sorted
`Vec`	`remove(java.lang.String name)` Removes the column with a matching name.
`Frame`	`remove(java.lang.String[] names)`
`Vec[]`	`removeAll()` Remove all the vecs from frame.
`void`	`reOrder(int[] newOrder)` Re-order the columns according to the new order specified in newOrder.
`Vec`	`replace(int col, Vec nv)` Replace one column with another.
`void`	`restructure(java.lang.String[] names, Vec[] vecs)` Restructure a Frame completely
`void`	`restructure(java.lang.String[] names, Vec[] vecs, int cols)` Restructure a Frame completely, but only for a specified number of columns (counting up)
`Futures`	`retain(Futures futures, java.util.Set<Key> retainedKeys)` Removes this `Frame` object and all directly linked `Keyed` objects and POJOs, while retaining the keys defined by the retainedKeys parameter.
`void`	`setNames(java.lang.String[] columns)`
`Frame`	`sort(int[] cols)` Sort rows of a frame, using the set of columns as keys.
`Frame`	`sort(int[] cols, int[] ascending)`
`Frame`	`subframe(int startIdx, int endIdx)` Create a subframe from given interval of columns.
`Frame`	`subframe(java.lang.String[] names)` Returns a subframe of this frame containing only vectors with desired names.
`void`	`swap(int lo, int hi)` Swap two Vecs in-place; useful for sorting columns by some criteria
`Frame`	`toCategoricalCol(int columIdx)` Returns the original frame with specific column converted to categorical
`Frame`	`toCategoricalCol(java.lang.String column)` Returns the original frame with specific column converted to categorical
`java.io.InputStream`	`toCSV(Frame.CSVStreamParams parms)` Convert this Frame to a CSV (in an `InputStream`), that optionally is compatible with R 3.1's recent change to read.csv()'s behavior.
`java.lang.String`	`toString()`
`java.lang.String`	`toString(long off, int len)`
`java.lang.String`	`toString(long off, int len, boolean rollups)`
`TwoDimTable`	`toTwoDimTable()`
`TwoDimTable`	`toTwoDimTable(long off, int len)`
`TwoDimTable`	`toTwoDimTable(long off, int len, boolean rollups)`
`byte[]`	`types()` Type for every Vec
`java.lang.String[]`	`typesStr()` String name for each Vec type
`java.lang.String`	`uniquify(java.lang.String name)`
`Vec`	`vec(int idx)` Returns the Vec by given index, implemented by code: `vecs()[idx]`.
`Vec`	`vec(java.lang.String name)` Return a Vec by name, or null if missing
`Vec[]`	`vecs()` The internal array of Vecs.
`Vec[]`	`vecs(int[] idxs)`
`Vec[]`	`vecs(java.lang.String[] names)`
`protected AutoBuffer`	`writeAll_impl(AutoBuffer ab)` Write out K/V pairs, in this case Vecs.

Methods inherited from class water.Lockable
delete_and_lock, delete_and_lock, delete_and_lock, delete, delete, delete, delete, read_lock, read_lock, read_lock, unlock_all, unlock, unlock, unlock, unlock, update, update, update, write_lock_to_read_lock, write_lock, write_lock, write_lock

Methods inherited from class water.Keyed
checksum_impl, checksum, checksum, getKey, readAll, remove_impl, remove_self_key_impl, remove, remove, remove, remove, remove, remove, removeQuietly, writeAll

Methods inherited from class water.Iced
asBytes, clone, copyOver, frozenType, read, readExternal, readJSON, reloadFromBytes, toJsonBytes, toJsonString, write, writeExternal, writeJSON

Methods inherited from class java.lang.Object
equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - _names
```
public java.lang.String[] _names
```
    Vec names
- Constructor Detail
  - Frame
```
public Frame(Vec... vecs)
```
    Creates an internal frame composed of the given Vecs and default names. The frame has no key.
  - Frame
```
public Frame(java.lang.String[] names,
             Vec[] vecs)
```
    Creates an internal frame composed of the given Vecs and names. The frame has no key.
  - Frame
```
public Frame(Key<Frame> key)
```
    Creates an empty frame with given key.
  - Frame
```
public Frame(Key<Frame> key,
             Vec[] vecs)
```
    Creates a frame with given key, default names and vectors.
  - Frame
```
public Frame(Key<Frame> key,
             java.lang.String[] names,
             Vec[] vecs)
```
    Creates a frame with given key, names and vectors.
  - Frame
```
public Frame(Frame fr)
```
    Deep copy of Vecs and Keys and Names (but not data!) to a new random Key. The resulting Frame does not share with the original, so the set of Vecs can be freely hacked without disturbing the original Frame.
- Method Detail
  - deleteTempFrameAndItsNonSharedVecs
```
public static void deleteTempFrameAndItsNonSharedVecs(Frame tempFrame,
                                                      Frame baseFrame)
```
    Given a temp Frame and a base Frame from which it was created, delete the Vecs that aren't found in the base Frame and then delete the temp Frame. For most use cases with short-lived temp frames, use Scope.protect(Frame...) or a Scope.safe(Frame...) instead.
  - fetchAll
```
public static Frame[] fetchAll()
```
    Fetch all Frames from the KV store.
  - hasNAs
```
public boolean hasNAs()
```
  - hasInfs
```
public boolean hasInfs()
```
  - naCount
```
public long naCount()
```
  - naFraction
```
public double naFraction()
```
  - setNames
```
public final void setNames(java.lang.String[] columns)
```
  - defaultColName
```
public static java.lang.String defaultColName(int col)
```
    Default column name maker
  - uniquify
```
public java.lang.String uniquify(java.lang.String name)
```
  - isCompatible
```
public boolean isCompatible(Frame fr)
```
    Frames are compatible if they have the same layout (number of rows and chunking) and the same vector group (chunk placement)..
  - numCols
```
public int numCols()
```
    Number of columns
    
    Returns:
    
    Number of columns
  - numRows
```
public long numRows()
```
    Number of rows
    
    Returns:
    
    Number of rows
  - anyVec
```
public final Vec anyVec()
```
    Returns the first readable vector.
    
    Returns:
    
    the first readable Vec
  - names
```
public java.lang.String[] names()
```
    The array of column names.
    
    Returns:
    
    the array of column names
  - name
```
public java.lang.String name(int i)
```
    A single column name.
    
    Returns:
    
    the column name
  - keys
```
public Key<Vec>[] keys()
```
    The array of keys.
    
    Returns:
    
    the array of keys for each vec in the frame.
  - keysList
```
public java.lang.Iterable<Key<Vec>> keysList()
```
  - vecs
```
public final Vec[] vecs()
```
    The internal array of Vecs. For efficiency Frames contain an array of Vec Keys - and the Vecs themselves are lazily loaded from the DKV.
    
    Returns:
    
    the internal array of Vecs
  - vecs
```
public final Vec[] vecs(int[] idxs)
```
  - vecs
```
public Vec[] vecs(java.lang.String[] names)
```
  - lastVec
```
public Vec lastVec()
```
    Convenience to accessor for last Vec
    
    Returns:
    
    last Vec
  - lastVecName
```
public java.lang.String lastVecName()
```
    Convenience to accessor for last Vec name
    
    Returns:
    
    last Vec name
  - reloadVecs
```
public final Vec[] reloadVecs()
```
    Force a cache-flush and reload, assuming vec mappings were altered remotely, or that the _vecs array was shared and now needs to be a defensive copy.
    
    Returns:
    
    the new instance of the Frame's Vec[]
  - vec
```
public final Vec vec(int idx)
```
    Returns the Vec by given index, implemented by code: vecs()[idx].
    
    Parameters:
    
    idx - idx of column
    
    Returns:
    
    this frame idx-th vector, never returns null
  - vec
```
public Vec vec(java.lang.String name)
```
    Return a Vec by name, or null if missing
    
    Returns:
    
    a Vec by name, or null if missing
  - find
```
public int find(java.lang.String name)
```
    Finds the column index with a matching name, or -1 if missing
    
    Returns:
    
    the column index with a matching name, or -1 if missing
  - find
```
@Deprecated
public int find(Vec vec)
```
    Deprecated. as many columns in a Frame could be backed by the same Vec, we can't return single column index that corresponds to a given vec. Please use find(String) instead.
    
    Finds the matching column index, or -1 if missing
    
    Returns:
    
    the matching column index, or -1 if missing
  - find
```
@Deprecated
public int find(Key key)
```
    Deprecated. as many columns in a Frame could be backed by the same Vec (and its key), we can't return single column index that corresponds to a given key. Please use find(String) instead.
    
    Finds the matching column index, or -1 if missing
    
    Returns:
    
    the matching column index, or -1 if missing
  - find
```
public int[] find(java.lang.String[] names)
```
    Bulk find(String) api
    
    Returns:
    
    An array of column indices matching the names array
  - insertVec
```
public void insertVec(int i,
                      java.lang.String name,
                      Vec vec)
```
  - types
```
public byte[] types()
```
    Type for every Vec
  - typesStr
```
public java.lang.String[] typesStr()
```
    String name for each Vec type
  - domains
```
public java.lang.String[][] domains()
```
    All the domains for categorical columns; null for non-categorical columns.
    
    Returns:
    
    the domains for categorical columns
  - cardinality
```
public int[] cardinality()
```
    Number of categorical levels for categorical columns; -1 for non-categorical columns.
    
    Returns:
    
    the number of levels for categorical columns
  - bulkRollups
```
public Vec[] bulkRollups()
```
  - modes
```
public int[] modes()
```
    Majority class for categorical columns; -1 for non-categorical columns.
    
    Returns:
    
    the majority class for categorical columns
  - means
```
public double[] means()
```
    All the column means.
    
    Returns:
    
    the mean of each column
  - mults
```
public double[] mults()
```
    One over the standard deviation of each column.
    
    Returns:
    
    Reciprocal the standard deviation of each column
  - byteSize
```
public long byteSize()
```
    The Vec.byteSize of all Vecs
    
    Returns:
    
    the Vec.byteSize of all Vecs
  - checksum_impl
```
protected long checksum_impl(boolean noCache)
```
    64-bit checksum of the checksums of the vecs. SHA-265 checksums of the chunks are XORed together. Since parse always parses the same pieces of files into the same offsets in some chunk this checksum will be consistent across reparses.
    
    Overrides:
    
    checksum_impl in class Keyed<Frame>
    
    Returns:
    
    64-bit Frame checksum
  - add
```
public void add(java.lang.String[] names,
                Vec[] vecs)
```
  - add
```
public void add(java.lang.String[] names,
                Vec[] vecs,
                int cols)
```
  - add
```
public Vec add(java.lang.String name,
               Vec vec)
```
    Append a named Vec to the Frame. Names are forced unique, by appending a unique number if needed.
    
    Returns:
    
    the added Vec, for flow-coding
  - add
```
public Frame add(Frame fr)
```
    Append a Frame onto this Frame. Names are forced unique, by appending unique numbers if needed.
    
    Returns:
    
    the expanded Frame, for flow-coding
  - prepend
```
public Frame prepend(java.lang.String name,
                     Vec vec)
```
    Insert a named column as the first column
  - swap
```
public void swap(int lo,
                 int hi)
```
    Swap two Vecs in-place; useful for sorting columns by some criteria
  - reOrder
```
public void reOrder(int[] newOrder)
```
    Re-order the columns according to the new order specified in newOrder.
    
    Parameters:
    
    newOrder -
  - moveFirst
```
public void moveFirst(int[] cols)
```
    move the provided columns to be first, in-place. For Merge currently since method='hash' was coded like that
  - subframe
```
public Frame subframe(java.lang.String[] names)
```
    Returns a subframe of this frame containing only vectors with desired names.
    
    Parameters:
    
    names - list of vector names
    
    Returns:
    
    a new frame which collects vectors from this frame with desired names.
    
    Throws:
    
    java.lang.IllegalArgumentException - if there is no vector with desired name in this frame.
  - postWrite
```
public Futures postWrite(Futures fs)
```
    Allow rollups for all written-into vecs; used by MRTask once writing is complete.
    
    Returns:
    
    the original Futures, for flow-coding
  - remove_impl
```
protected Futures remove_impl(Futures fs,
                              boolean cascade)
```
    Actually remove/delete all Vecs from memory, not just from the Frame.
    
    Overrides:
    
    remove_impl in class Keyed<Frame>
    
    Returns:
    
    the original Futures, for flow-coding
  - delete_and_lock
```
public Frame delete_and_lock(Key<Job> job_key)
```
    Overrides:
    
    delete_and_lock in class Lockable<Frame>
  - retain
```
public final Futures retain(Futures futures,
                            java.util.Set<Key> retainedKeys)
```
    Removes this Frame object and all directly linked Keyed objects and POJOs, while retaining the keys defined by the retainedKeys parameter. Aimed to be used for removal of Frame objects pointing to shared resources (Vectors, Chunks etc.) internally.
    WARNING: UNSTABLE API, might be removed/replaced at any time.
    
    Parameters:
    
    futures - An instance of Futures for synchronization
    
    retainedKeys - A Set of keys to retain. The set may be immutable, as it shall not be modified.
    
    Returns:
    
    An instance of Futures for synchronization
  - writeAll_impl
```
protected AutoBuffer writeAll_impl(AutoBuffer ab)
```
    Write out K/V pairs, in this case Vecs.
    
    Overrides:
    
    writeAll_impl in class Keyed<Frame>
  - readAll_impl
```
protected Keyed readAll_impl(AutoBuffer ab,
                             Futures fs)
```
    Overrides:
    
    readAll_impl in class Keyed<Frame>
  - replace
```
public Vec replace(int col,
                   Vec nv)
```
    Replace one column with another. Caller must perform global update (DKV.put) on this updated frame.
    
    Returns:
    
    The old column, for flow-coding
  - subframe
```
public Frame subframe(int startIdx,
                      int endIdx)
```
    Create a subframe from given interval of columns.
    
    Parameters:
    
    startIdx - index of first column (inclusive)
    
    endIdx - index of the last column (exclusive)
    
    Returns:
    
    a new Frame containing specified interval of columns
  - extractFrame
```
public Frame extractFrame(int startIdx,
                          int endIdx)
```
    Split this Frame; return a subframe created from the given column interval, and remove those columns from this Frame.
    
    Parameters:
    
    startIdx - index of first column (inclusive)
    
    endIdx - index of the last column (exclusive)
    
    Returns:
    
    a new Frame containing specified interval of columns
  - remove
```
public Vec remove(java.lang.String name)
```
    Removes the column with a matching name.
    
    Returns:
    
    The removed column
  - remove
```
public Frame remove(java.lang.String[] names)
```
  - remove
```
public Vec[] remove(int[] idxs)
```
    Removes a list of columns by index; the index list must be sorted
    
    Returns:
    
    an array of the removed columns
  - remove
```
public final Vec remove(int idx)
```
    Removes a numbered column.
    
    Returns:
    
    the removed column
  - removeAll
```
public Vec[] removeAll()
```
    Remove all the vecs from frame.
  - restructure
```
public void restructure(java.lang.String[] names,
                        Vec[] vecs)
```
    Restructure a Frame completely
  - restructure
```
public void restructure(java.lang.String[] names,
                        Vec[] vecs,
                        int cols)
```
    Restructure a Frame completely, but only for a specified number of columns (counting up)
  - deepSlice
```
public Frame deepSlice(java.lang.Object orows,
                       java.lang.Object ocols)
```
    In support of R, a generic Deep Copy and Slice.
    Semantics are a little odd, to match R's. Each dimension spec can be:
    - null - all of them
    - a sorted list of negative numbers (no dups) - all BUT these
    - an unordered list of positive - just these, allowing dups
    The numbering is 1-based; zero's are not allowed in the lists, nor are out-of-range values.
    Returns:
    
    the sliced Frame
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - toString
```
public java.lang.String toString(long off,
                                 int len)
```
  - toString
```
public java.lang.String toString(long off,
                                 int len,
                                 boolean rollups)
```
  - toTwoDimTable
```
public TwoDimTable toTwoDimTable()
```
  - toTwoDimTable
```
public TwoDimTable toTwoDimTable(long off,
                                 int len)
```
  - toTwoDimTable
```
public TwoDimTable toTwoDimTable(long off,
                                 int len,
                                 boolean rollups)
```
  - deepCopy
```
public Frame deepCopy(java.lang.String keyName)
```
    Create a copy of the input Frame and return that copied Frame. All Vecs in this are copied in parallel. Caller must do the DKV.put
    
    Parameters:
    
    keyName - Key for resulting frame. If null, no key will be given.
    
    Returns:
    
    The fresh copy of fr.
  - makeCompatible
```
public Vec[] makeCompatible(Frame f)
```
  - makeCompatible
```
public Vec[] makeCompatible(Frame f,
                            boolean force)
```
    Return array of Vectors if 'f' is compatible with 'this', else return a new array of Vectors compatible with 'this' and a copy of 'f's data otherwise. Note that this can, in the worst case, copy all of thiss' data.
    
    Returns:
    
    This Frame's data in an array of Vectors that is compatible with f.
  - makeSimilarlyDistributed
```
public Frame makeSimilarlyDistributed(Frame f,
                                      Key<Frame> newKey)
```
    Make rows of a given frame distributed similarly to this frame. This method is useful e.g. when we have a training frame, and we want to adapt the testing frame so that there is proportionally similar amount of testing data in each chunk to the amount of training data. The resulting frame will have the same number of chunks as this frame.
    
    Parameters:
    
    f - frame that we want to re-distributed
    
    newKey - key for a newly created frame
    
    Returns:
    
    new frame or the given frame if nothing needs to be done
  - export
```
public static Job export(Frame fr,
                         java.lang.String path,
                         java.lang.String frameName,
                         boolean overwrite,
                         int nParts)
```
  - export
```
public static Job export(Frame fr,
                         java.lang.String path,
                         java.lang.String frameName,
                         boolean overwrite,
                         int nParts,
                         java.lang.String compression,
                         Frame.CSVStreamParams csvParms)
```
  - export
```
public static Job export(Frame fr,
                         java.lang.String path,
                         java.lang.String frameName,
                         boolean overwrite,
                         int nParts,
                         boolean parallel,
                         java.lang.String compression,
                         Frame.CSVStreamParams csvParms)
```
  - exportParquet
```
public static Job exportParquet(Frame fr,
                                java.lang.String path,
                                boolean overwrite,
                                java.lang.String compression,
                                boolean writeChecksum)
```
  - toCSV
```
public java.io.InputStream toCSV(Frame.CSVStreamParams parms)
```
    Convert this Frame to a CSV (in an InputStream), that optionally is compatible with R 3.1's recent change to read.csv()'s behavior. WARNING: Note that the end of a file is denoted by the read function returning 0 instead of -1.
    
    Returns:
    
    An InputStream containing this Frame as a CSV
  - makeSchema
```
public java.lang.Class<KeyV3.FrameKeyV3> makeSchema()
```
    Overrides:
    
    makeSchema in class Keyed<Frame>
  - sort
```
public Frame sort(int[] cols)
```
    Sort rows of a frame, using the set of columns as keys. User can specify sorting direction for each sorting column in a integer array. For example, if we want to sort columns 0, 1, 2 and want to sort 0 in ascending direction, 1 and 2 in descending direction for frame fr, the call to make is fr.sort(new int[]{0,1,2}, new int[]{1, -1, -1}.
    
    Returns:
    
    Copy of frame, sorted
  - sort
```
public Frame sort(int[] cols,
                  int[] ascending)
```
  - frameVecRegistry
```
public Frame.FrameVecRegistry frameVecRegistry()
```
    A structure for fast lookup in the set of frame's vectors. Purpose of this class is to avoid multiple O(n) searches in Frame's vectors.
    
    Returns:
    
    An instance of Frame.FrameVecRegistry
  - toCategoricalCol
```
public Frame toCategoricalCol(int columIdx)
```
    Returns the original frame with specific column converted to categorical
  - toCategoricalCol
```
public Frame toCategoricalCol(java.lang.String column)
```
    Returns the original frame with specific column converted to categorical

Class Frame

Nested Class Summary

Field Summary

Fields inherited from class water.Lockable

Fields inherited from class water.Keyed

Constructor Summary

Method Summary

Methods inherited from class water.Lockable

Methods inherited from class water.Keyed

Methods inherited from class water.Iced

Methods inherited from class java.lang.Object

Field Detail

_names

Constructor Detail

Frame

Frame

Frame

Frame

Frame

Frame

Method Detail

deleteTempFrameAndItsNonSharedVecs

fetchAll

hasNAs

hasInfs

naCount

naFraction

setNames

defaultColName

uniquify

isCompatible

numCols

numRows

anyVec

names

name

keys

keysList

vecs

vecs

vecs

lastVec

lastVecName

reloadVecs

vec

vec

find

find

find

find

insertVec

types

typesStr

domains

cardinality

bulkRollups

modes

means

mults

byteSize

checksum_impl

add

add

add

add

prepend

swap

reOrder

moveFirst

subframe

postWrite

remove_impl

delete_and_lock

retain

writeAll_impl

readAll_impl

replace

subframe

extractFrame

remove