Chunk (h2o-core 0.1.4 API)

java.lang.Object
- water.Iced
- - water.fvec.Chunk

All Implemented Interfaces:

java.lang.Cloneable, Freezable

Direct Known Subclasses:

NewChunk
```
public abstract class Chunk
extends Iced
implements java.lang.Cloneable
```
A compression scheme, over a chunk - a single array of bytes. The *actual* vector header info is in the Vec struct - which contains info to find all the bytes of the distributed vector. This struct is basically a 1-entry chunk cache of the total vector. Subclasses of this abstract class implement (possibly empty) compression schemes.

Field Summary

Fields
Modifier and Type Field and Description

protected byte[] _mem

protected long _start

protected Vec _vec

Fields
Modifier and Type	Field and Description
`protected byte[]`	`_mem`
`protected long`	`_start`
`protected Vec`	`_vec`

Constructor Summary

Constructors
Constructor and Description

Chunk()

Constructors
Constructor and Description
`Chunk()`

Method Summary

Methods
Modifier and Type	Method and Description
`double`	`at(long i)` Load a double value.
`double`	`at0(int i)` The zero-based API.
`protected long`	`at16h_impl(int idx)`
`long`	`at16h(long i)`
`long`	`at16h0(int i)`
`protected long`	`at16l_impl(int idx)`
`long`	`at16l(long i)`
`long`	`at16l0(int i)`
`protected abstract long`	`at8_impl(int idx)`
`long`	`at80(int i)`
`protected abstract double`	`atd_impl(int idx)` Chunk-specific readers.
`protected ValueString`	`atStr_impl(ValueString vstr, int idx)`
`ValueString`	`atStr(ValueString vstr, long i)`
`ValueString`	`atStr0(ValueString vstr, int i)`
`long`	`byteSize()`
`Chunk`	`chk2()`
`int`	`cidx()`
`Futures`	`close(int cidx, Futures fs)` After writing we must call close() to register the bulk changes
`void`	`crushBytes()`
`byte[]`	`getBytes()`
`protected abstract boolean`	`isNA_impl(int idx)`
`boolean`	`isNA0(int i)`
`boolean`	`isSparse()`
`int`	`len()`
`int[]`	`nonzeros()` Get chunk-relative indices of values (nonzeros for sparse, all for dense) stored in this chunk.
`int`	`nonzeros(int[] res)` Get chunk-relative indices of values (nonzeros for sparse, all for dense) stored in this chunk.
`byte`	`precision()`
`abstract Chunk`	`read_impl(AutoBuffer ab)`
`int`	`set_len(int _len)`
`void`	`set(long i, double d)` Write element the slow way, as a double.
`void`	`set(long i, float f)` Write element the slow way, as a float.
`void`	`set(long i, long l)` Write element the slow way, as a long.
`void`	`set(long i, java.lang.String str)`
`double`	`set0(int idx, double d)` Set a double element in a chunk given a 0-based chunk local index.
`float`	`set0(int idx, float f)` Set a floating element in a chunk given a 0-based chunk local index.
`long`	`set0(int idx, long l)` Set a long element in a chunk given a 0-based chunk local index.
`java.lang.String`	`set0(int idx, java.lang.String str)`
`boolean`	`setNA0(int idx)` Set the element in a chunk as missing given a 0-based chunk local index.
`int`	`sparseLen()`
`long`	`start()`
`java.lang.String`	`toString()`
`Vec`	`vec()`
`abstract AutoBuffer`	`write_impl(AutoBuffer ab)`

Methods inherited from class water.Iced
clone, frozenType, read, readJSON_impl, readJSON, write, writeHTML_impl, writeHTML, writeJSON_impl, writeJSON

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

- Field Detail
  - _start
```
protected long _start
```
  - _vec
```
protected Vec _vec
```
  - _mem
```
protected byte[] _mem
```
- Constructor Detail
  - Chunk
```
public Chunk()
```
- Method Detail
  - start
```
public final long start()
```
  - len
```
public int len()
```
  - set_len
```
public int set_len(int _len)
```
  - chk2
```
public final Chunk chk2()
```
  - vec
```
public final Vec vec()
```
  - getBytes
```
public final byte[] getBytes()
```
  - crushBytes
```
public final void crushBytes()
```
  - at
```
public final double at(long i)
```
    Load a double value. Returns Double.NaN if value is missing.
    Loads from the 1-entry chunk cache, or misses-out. This version uses absolute element numbers, but must convert them to chunk-relative indices - requiring a load from an aliasing local var, leading to lower quality JIT'd code (similar issue to using iterator objects).
    Slightly slower than 'at80' since it range checks within a chunk.
  - at16l
```
public final long at16l(long i)
```
  - at16h
```
public final long at16h(long i)
```
  - atStr
```
public final ValueString atStr(ValueString vstr,
                long i)
```
  - at0
```
public final double at0(int i)
```
    The zero-based API. Somewhere between 10% to 30% faster in a tight-loop over the data than the generic at() API. Probably no gain on larger loops. The row reference is zero-based on the chunk, and should range-check by the JIT as expected.
  - at80
```
public final long at80(int i)
```
  - isNA0
```
public final boolean isNA0(int i)
```
  - at16l0
```
public final long at16l0(int i)
```
  - at16h0
```
public final long at16h0(int i)
```
  - atStr0
```
public final ValueString atStr0(ValueString vstr,
                 int i)
```
  - set
```
public final void set(long i,
       long l)
```
    Write element the slow way, as a long. There is no way to write a missing value with this call. Under rare circumstances this can throw: if the long does not fit in a double (value is larger magnitude than 2^52), AND float values are stored in Vector. In this case, there is no common compatible data representation.
  - set
```
public final void set(long i,
       double d)
```
    Write element the slow way, as a double. Double.NaN will be treated as a set of a missing element.
  - set
```
public final void set(long i,
       float f)
```
    Write element the slow way, as a float. Float.NaN will be treated as a set of a missing element.
  - set
```
public final void set(long i,
       java.lang.String str)
```
  - set0
```
public final long set0(int idx,
        long l)
```
    Set a long element in a chunk given a 0-based chunk local index. Write into a chunk. May rewrite/replace chunks if the chunk needs to be "inflated" to hold larger values. Returns the input value. Note that the idx is an int (instead of a long), which tells you that index 0 is the first row in the chunk, not the whole Vec.
  - set0
```
public final double set0(int idx,
          double d)
```
    Set a double element in a chunk given a 0-based chunk local index.
  - set0
```
public final float set0(int idx,
         float f)
```
    Set a floating element in a chunk given a 0-based chunk local index.
  - setNA0
```
public final boolean setNA0(int idx)
```
    Set the element in a chunk as missing given a 0-based chunk local index.
  - set0
```
public final java.lang.String set0(int idx,
                    java.lang.String str)
```
  - close
```
public Futures close(int cidx,
            Futures fs)
```
    After writing we must call close() to register the bulk changes
  - cidx
```
public int cidx()
```
  - atd_impl
```
protected abstract double atd_impl(int idx)
```
    Chunk-specific readers.
  - at8_impl
```
protected abstract long at8_impl(int idx)
```
  - isNA_impl
```
protected abstract boolean isNA_impl(int idx)
```
  - at16l_impl
```
protected long at16l_impl(int idx)
```
  - at16h_impl
```
protected long at16h_impl(int idx)
```
  - atStr_impl
```
protected ValueString atStr_impl(ValueString vstr,
                     int idx)
```
  - isSparse
```
public boolean isSparse()
```
  - sparseLen
```
public int sparseLen()
```
  - nonzeros
```
public int nonzeros(int[] res)
```
    Get chunk-relative indices of values (nonzeros for sparse, all for dense) stored in this chunk. For dense chunks, this will contain indices of all the rows in this chunk.
    
    Returns:
    array of chunk-relative indices of values stored in this chunk.
  - nonzeros
```
public final int[] nonzeros()
```
    Get chunk-relative indices of values (nonzeros for sparse, all for dense) stored in this chunk. For dense chunks, this will contain indices of all the rows in this chunk.
    
    Returns:
    array of chunk-relative indices of values stored in this chunk.
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - byteSize
```
public long byteSize()
```
  - write_impl
```
public abstract AutoBuffer write_impl(AutoBuffer ab)
```
    Specified by:
    
    write_impl in interface Freezable
    
    Overrides:
    
    write_impl in class Iced
  - read_impl
```
public abstract Chunk read_impl(AutoBuffer ab)
```
    Specified by:
    
    read_impl in interface Freezable
    
    Overrides:
    
    read_impl in class Iced
  - precision
```
public byte precision()
```

Class Chunk

Field Summary

Constructor Summary

Method Summary

Methods inherited from class water.Iced

Methods inherited from class java.lang.Object

Field Detail

_start

_vec

_mem

Constructor Detail

Chunk

Method Detail

start

len

set_len

chk2

vec

getBytes

crushBytes

at

at16l

at16h

atStr

at0

at80

isNA0

at16l0

at16h0

atStr0

set

set

set

set

set0

set0

set0

setNA0

set0

close

cidx

atd_impl

at8_impl

isNA_impl

at16l_impl

at16h_impl

atStr_impl

isSparse

sparseLen

nonzeros

nonzeros

toString

byteSize

write_impl

read_impl

precision