H2OFrame

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def add(arg0: Frame): Frame

def add(arg0: String, arg1: Vec): Vec

def add(arg0: Array[String], arg1: Array[Vec], arg2: Int): Unit

def add(arg0: Array[String], arg1: Array[Vec]): Unit

final def anyVec(): Vec

def apply(transformation: VecTransformation, selector: VecSelector, removeVec: Boolean = true): H2OFrame

def apply(transformation: VecTransformation, colNames: Array[String]): H2OFrame

def apply(transformation: VecTransformation, colNames: Symbol*): H2OFrame

def apply(columnNames: Symbol*): H2OFrame

Create a sub-frame based on the list of column names.

def apply(columnNames: Array[String]): H2OFrame

Create a sub-frame based on the list of column names.

def asBytes(): Array[Byte]

final def asInstanceOf[T0]: T0

def bulkRollups(): Array[Vec]

def byteSize(): Long

def cardinality(): Array[Int]

final def checksum(arg0: Boolean): Long

final def checksum(): Long

def checksum_impl(arg0: Boolean): Long

def checksum_impl(): Long

final def clone(): Frame

def colToEnum(cols: Array[Int]): Unit

Transform columns in enum columns

def colToEnum(cols: Array[String]): Unit

Transform columns in enum columns

def copyOver(arg0: Frame): Unit

def deepCopy(arg0: String): Frame

def deepSlice(arg0: Any, arg1: Any): Frame

final def delete(arg0: Key[Job], arg1: Futures, arg2: Boolean): Futures

final def delete(arg0: Boolean): Unit

final def delete(): Unit

def delete_and_lock(arg0: Key[Job]): Frame

def delete_and_lock(arg0: Job): Frame

def delete_and_lock(): Frame

def domains(): Array[Array[String]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def extractFrame(arg0: Int, arg1: Int): Frame

def finalize(): Unit

def find(arg0: Array[String]): Array[Int]

def find(arg0: String): Int

def frameVecRegistry(): FrameVecRegistry

final def frozenType(): Int

final def getClass(): Class[_]

def getKey(): Key[Frame]

def hasInfs(): Boolean

def hasNAs(): Boolean

def hashCode(): Int

def insertVec(arg0: Int, arg1: String, arg2: Vec): Unit

def isCompatible(arg0: Frame): Boolean

final def isInstanceOf[T0]: Boolean

def key: Key[Frame]

Expose internal key via a method.

def keys(): Array[Key[Vec]]

def keysList(): Iterable[Key[Vec]]

def lastVec(): Vec

def lastVecName(): String

def makeCompatible(arg0: Frame, arg1: Boolean): Array[Vec]

def makeCompatible(arg0: Frame): Array[Vec]

def makeSchema(): Class[FrameKeyV3]

def means(): Array[Double]

def modes(): Array[Int]

def moveFirst(arg0: Array[Int]): Unit

def mults(): Array[Double]

def naCount(): Long

def naFraction(): Double

def name(arg0: Int): String

def names(): Array[String]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def numCols(): Int

def numRows(): Long

def postWrite(arg0: Futures): Futures

def prepend(arg0: String, arg1: Vec): Frame

def reOrder(arg0: Array[Int]): Unit

final def read(arg0: AutoBuffer): Frame

def readAll_impl(arg0: AutoBuffer, arg1: Futures): Keyed[_ <: Keyed]

def readExternal(arg0: ObjectInput): Unit

final def readJSON(arg0: AutoBuffer): Frame

def read_lock(arg0: Key[Job]): Unit

def reloadFromBytes(arg0: Array[Byte]): Frame

final def reloadVecs(): Array[Vec]

final def remove(arg0: Int): Vec

def remove(arg0: Array[Int]): Array[Vec]

def remove(arg0: Array[String]): Frame

def remove(arg0: String): Vec

final def remove(arg0: Futures, arg1: Boolean): Futures

final def remove(arg0: Futures): Futures

final def remove(arg0: Boolean): Unit

final def remove(): Unit

def removeAll(): Array[Vec]

def remove_impl(arg0: Futures, arg1: Boolean): Futures

def remove_self_key_impl(arg0: Futures): Futures

def rename(oldName: String, newName: String): Unit

Rename a column of your DataFrame

def rename(index: Int, newName: String): Unit

Rename a column of your DataFrame

def replace(arg0: Int, arg1: Vec): Vec

def restructure(arg0: Array[String], arg1: Array[Vec], arg2: Int): Unit

def restructure(arg0: Array[String], arg1: Array[Vec]): Unit

final def retain(arg0: Futures, arg1: Set[Key[_ <: Keyed]]): Futures

final def setNames(arg0: Array[String]): Unit

def sort(arg0: Array[Int], arg1: Array[Int]): Frame

def sort(arg0: Array[Int]): Frame

def subframe(arg0: Int, arg1: Int): Frame

def subframe(arg0: Array[String]): Frame

def swap(arg0: Int, arg1: Int): Unit

final def synchronized[T0](arg0: ⇒ T0): T0

def toCSV(arg0: CSVStreamParams): InputStream

def toCategoricalCol(arg0: String): Frame

def toCategoricalCol(arg0: Int): Frame

final def toJsonString(): String

def toString(): String

def toString(arg0: Long, arg1: Int, arg2: Boolean): String

def toString(arg0: Long, arg1: Int): String

def toTwoDimTable(arg0: Long, arg1: Int, arg2: Boolean): TwoDimTable

def toTwoDimTable(arg0: Long, arg1: Int): TwoDimTable

def toTwoDimTable(): TwoDimTable

def types(): Array[Byte]

def typesStr(): Array[String]

def uniquify(arg0: String): String

def unlock(arg0: Key[Job[_ <: Keyed[_ <: Keyed[_ <: AnyRef]]]], arg1: Boolean): Frame

def unlock(arg0: Key[Job[_ <: Keyed[_ <: Keyed[_ <: AnyRef]]]]): Frame

def unlock(arg0: Job[_ <: Keyed[_ <: Keyed[_ <: AnyRef]]]): Frame

def unlock(): Frame

def unlock_all(): Unit

def update(arg0: Key[Job[_ <: Keyed[_ <: Keyed[_ <: AnyRef]]]]): Frame

def update(arg0: Job[_ <: Keyed[_ <: Keyed[_ <: AnyRef]]]): Frame

def update(): Frame

def vec(arg0: String): Vec

final def vec(arg0: Int): Vec

def vecs(arg0: Array[String]): Array[Vec]

final def vecs(arg0: Array[Int]): Array[Vec]

final def vecs(): Array[Vec]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

final def write(arg0: AutoBuffer): AutoBuffer

def writeAll(arg0: AutoBuffer): AutoBuffer

def writeAll_impl(arg0: AutoBuffer): AutoBuffer

def writeExternal(arg0: ObjectOutput): Unit

def writeJSON(arg0: AutoBuffer): AutoBuffer

def write_lock(arg0: Key[Job]): Lockable[?0] forSome {type ?0 <: Lockable[?0]}

def write_lock(arg0: Job): Lockable[?0] forSome {type ?0 <: Lockable[?0]}

def write_lock(): Lockable[?0] forSome {type ?0 <: Lockable[?0]}

def write_lock_to_read_lock(arg0: Key[Job]): Unit

def find(arg0: Key[_ <: Keyed[_ <: AnyRef]]): Int

def find(arg0: Vec): Int

def remove_impl(arg0: Futures): Futures