NewChunk (h2o-core version 3.10.0.3 API)

java.lang.Object
- water.Iced<Chunk>
- - water.fvec.Chunk
  - - water.fvec.NewChunk

All Implemented Interfaces:

java.io.Externalizable, java.io.Serializable, java.lang.Cloneable, Freezable<Chunk>
```
public class NewChunk
extends Chunk
```
See Also:
Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`NewChunk.Compress`
`static class`	`NewChunk.Exponents` Wrapper around exponent, stores values (only if there are non-zero exponents) in bytes or ints.
`static class`	`NewChunk.Mantissas` Class wrapping around mantissa.
`class`	`NewChunk.Value`

Field Summary

Fields
Modifier and Type	Field and Description
`int`	`_cidx`
`boolean`	`_isAllASCII`
`protected java.util.BitSet`	`_missing`
`protected NewChunk.Mantissas`	`_ms`
`int`	`_sparseLen`
`boolean`	`_sparseNA`
`byte[]`	`_ss`
`int`	`_sslen`
`int`	`_timCnt`
`protected NewChunk.Exponents`	`_xs`
`protected static int`	`MIN_SPARSE_RATIO`

Fields inherited from class water.fvec.Chunk
_len

Constructor Summary

Constructors
Constructor and Description
`NewChunk(Chunk c)`
`NewChunk(Chunk c, double[] vals)`
`NewChunk(double[] ds)`
`NewChunk(Vec vec, int cidx)`
`NewChunk(Vec vec, int cidx, boolean sparse)`
`NewChunk(Vec vec, int cidx, int len)`
`NewChunk(Vec vec, int cidx, long[] mantissa, int[] exponent, int[] indices, double[] doubles)`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`add(NewChunk nc)`
`void`	`add2Chunk(NewChunk c, int i)`
`void`	`addCategorical(int e)`
`void`	`addNA()`
`void`	`addNAs(int n)`
`void`	`addNum(double d)`
`void`	`addNum(long val, int exp)`
`void`	`addStr(Chunk c, int row)`
`void`	`addStr(Chunk c, long row)`
`void`	`addStr(java.lang.Object str)`
`void`	`addUUID(Chunk c, int row)`
`void`	`addUUID(Chunk c, long row)`
`void`	`addUUID(long lo, long hi)`
`void`	`addZeros(int n)`
`double[]`	`alloc_doubles(int l)`
`void`	`alloc_exponent(int sparseLen)`
`void`	`alloc_mantissa(int sparseLen)`
`void`	`alloc_nums(int len)`
`protected long`	`at16h_impl(int idx)`
`protected long`	`at16l_impl(int idx)`
`long`	`at8_impl(int i)`
`protected long`	`at8_impl2(int i)`
`double`	`atd_impl(int i)` Chunk-specific readers.
`BufferedString`	`atStr_impl(BufferedString bStr, int i)`
`void`	`cancel_sparse()`
`int`	`cidx()`
`void`	`close(Futures fs)`
`Chunk`	`compress()`
`protected double[]`	`doubles()`
`protected int[]`	`indices()`
`NewChunk`	`inflate_impl(NewChunk nc)` Chunk-specific bulk inflater back to NewChunk.
`protected void`	`initFromBytes()`
`int`	`is(int i)`
`protected boolean`	`isCategorical(int idx)`
`protected boolean`	`isCategorical2(int idx)`
`boolean`	`isNA_impl(int i)`
`protected boolean`	`isNA2(int idx)`
`boolean`	`isSparseNA()` Sparse Chunks have a significant number of NAs, and support for skipping over large runs of NAs in a row.
`boolean`	`isSparseZero()` Sparse Chunks have a significant number of zeros, and support for skipping over large runs of zeros in a row.
`boolean`	`isString()`
`boolean`	`isUUID()`
`protected int`	`naCnt()`
`Chunk`	`new_close()`
`boolean`	`set_impl(int i, double d)`
`void`	`set_is(int i, int val)`
`protected void`	`set_sparse(int num_noncompressibles, NewChunk.Compress sparsity_type)`
`void`	`set_vec(Vec vec)`
`void`	`setDoubles(double[] ds)`
`protected boolean`	`setNA_impl2(int i)`
`NewChunk`	`setSparseRatio(int s)`
`int`	`sparseLenNA()` Sparse Chunks have a significant number of NAs, and support for skipping over large runs of NAs in a row.
`int`	`sparseLenZero()` Sparse Chunks have a significant number of zeros, and support for skipping over large runs of zeros in a row.
`boolean`	`sparseNA()`
`boolean`	`sparseZero()`
`java.lang.String`	`toString()`
`java.util.Iterator<NewChunk.Value>`	`values()`
`java.util.Iterator<NewChunk.Value>`	`values(int fromIdx, int toIdx)`
`static AutoBuffer`	`write_impl(NewChunk nc, AutoBuffer bb)`

Methods inherited from class water.fvec.Chunk
asBytes, asSparseDoubles, asSparseDoubles, at16h, at16l, at8, atd, atStr, byteSize, chk2, close, crushBytes, deepCopy, getBytes, getDoubles, getDoubles, getDoubles, getIntegers, hasFloat, hasNA, inflate, isNA, len, nextChunk, nextNNA, nextNZ, nonnas, nonzeros, precision, read_impl, reloadFromBytes, replaceAll, reportBrokenCategorical, set_abs, set, set, set, set, set, setBytes, setNA, setStart, setVec, start, vec, write_impl

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

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

Field Detail

_cidx
```
public final int _cidx
```

_ms

protected transient NewChunk.Mantissas _ms

_missing

protected transient java.util.BitSet _missing

_xs

protected transient NewChunk.Exponents _xs

_ss
```
public transient byte[] _ss
```

_sparseNA
```
public boolean _sparseNA
```

_sslen
```
public int _sslen
```

_sparseLen
```
public int _sparseLen
```

_timCnt
```
public int _timCnt
```

MIN_SPARSE_RATIO
```
protected static final int MIN_SPARSE_RATIO
```
See Also:
Constant Field Values

_isAllASCII
```
public boolean _isAllASCII
```

Constructor Detail

NewChunk

public NewChunk(Vec vec,
        int cidx)

NewChunk

public NewChunk(Vec vec,
        int cidx,
        boolean sparse)

NewChunk
```
public NewChunk(double[] ds)
```

NewChunk

public NewChunk(Vec vec,
        int cidx,
        long[] mantissa,
        int[] exponent,
        int[] indices,
        double[] doubles)

NewChunk
```
public NewChunk(Chunk c)
```

NewChunk

public NewChunk(Chunk c,
        double[] vals)

NewChunk

public NewChunk(Vec vec,
        int cidx,
        int len)

Method Detail

alloc_mantissa

public void alloc_mantissa(int sparseLen)

alloc_exponent

public void alloc_exponent(int sparseLen)

is
```
public int is(int i)
```

set_is

public void set_is(int i,
          int val)

alloc_nums
```
public void alloc_nums(int len)
```

alloc_doubles
```
public double[] alloc_doubles(int l)
```

indices
```
protected final int[] indices()
```

doubles
```
protected final double[] doubles()
```

isSparseZero
```
public boolean isSparseZero()
```
Description copied from class: Chunk

Sparse Chunks have a significant number of zeros, and support for skipping over large runs of zeros in a row.

Overrides:

isSparseZero in class Chunk

Returns:
true if this Chunk is sparse.

isSparseNA
```
public boolean isSparseNA()
```
Description copied from class: Chunk

Sparse Chunks have a significant number of NAs, and support for skipping over large runs of NAs in a row.

Overrides:

isSparseNA in class Chunk

Returns:
true if this Chunk is sparseNA.

sparseLenZero
```
public int sparseLenZero()
```
Description copied from class: Chunk

Sparse Chunks have a significant number of zeros, and support for skipping over large runs of zeros in a row.

Overrides:

sparseLenZero in class Chunk

Returns:
At least as large as the count of non-zeros, but may be significantly smaller than the Chunk._len

sparseLenNA
```
public int sparseLenNA()
```
Description copied from class: Chunk

Sparse Chunks have a significant number of NAs, and support for skipping over large runs of NAs in a row.

Overrides:

sparseLenNA in class Chunk

Returns:
At least as large as the count of non-NAs, but may be significantly smaller than the Chunk._len

naCnt
```
protected int naCnt()
```

setSparseRatio

public NewChunk setSparseRatio(int s)

setDoubles
```
public void setDoubles(double[] ds)
```

set_vec
```
public void set_vec(Vec vec)
```

add2Chunk

public void add2Chunk(NewChunk c,
             int i)

values

public java.util.Iterator<NewChunk.Value> values()

values

public java.util.Iterator<NewChunk.Value> values(int fromIdx,
                                        int toIdx)

isNA2

protected final boolean isNA2(int idx)

isCategorical2

protected final boolean isCategorical2(int idx)

isCategorical

protected final boolean isCategorical(int idx)

addCategorical
```
public void addCategorical(int e)
```

addNA
```
public void addNA()
```

addNum

public void addNum(long val,
          int exp)

addNum
```
public void addNum(double d)
```

addStr

public void addStr(java.lang.Object str)

addStr

public void addStr(Chunk c,
          long row)

addStr

public void addStr(Chunk c,
          int row)

addUUID

public void addUUID(long lo,
           long hi)

addUUID

public void addUUID(Chunk c,
           long row)

addUUID

public void addUUID(Chunk c,
           int row)

isUUID
```
public final boolean isUUID()
```

isString
```
public final boolean isString()
```

sparseZero
```
public final boolean sparseZero()
```

sparseNA
```
public final boolean sparseNA()
```

addZeros
```
public void addZeros(int n)
```

addNAs
```
public void addNAs(int n)
```

add
```
public void add(NewChunk nc)
```

new_close
```
public Chunk new_close()
```

close
```
public void close(Futures fs)
```

set_sparse

protected void set_sparse(int num_noncompressibles,
              NewChunk.Compress sparsity_type)

cancel_sparse
```
public void cancel_sparse()
```

compress
```
public Chunk compress()
```

set_impl

public boolean set_impl(int i,
               double d)

setNA_impl2

protected final boolean setNA_impl2(int i)

at8_impl2

protected final long at8_impl2(int i)

at8_impl
```
public long at8_impl(int i)
```

atd_impl
```
public double atd_impl(int i)
```
Description copied from class: Chunk

Chunk-specific readers. Not a public API

at16l_impl
```
protected long at16l_impl(int idx)
```

at16h_impl
```
protected long at16h_impl(int idx)
```

isNA_impl
```
public boolean isNA_impl(int i)
```

atStr_impl

public BufferedString atStr_impl(BufferedString bStr,
                        int i)

initFromBytes
```
protected final void initFromBytes()
```
Specified by:

initFromBytes in class Chunk

write_impl

public static AutoBuffer write_impl(NewChunk nc,
                    AutoBuffer bb)

inflate_impl
```
public NewChunk inflate_impl(NewChunk nc)
```
Description copied from class: Chunk

Chunk-specific bulk inflater back to NewChunk. Used when writing into a chunk and written value is out-of-range for an update-in-place operation. Bulk copy from the compressed form into the nc._ls8 array.

Specified by:

inflate_impl in class Chunk

toString
```
public java.lang.String toString()
```
Overrides:

toString in class Chunk

Returns:
String version of a Chunk, currently just the class name

cidx
```
public int cidx()
```
Overrides:

cidx in class Chunk

Returns:
Chunk index

Class NewChunk

Nested Class Summary

Field Summary

Fields inherited from class water.fvec.Chunk

Constructor Summary

Method Summary

Methods inherited from class water.fvec.Chunk

Methods inherited from class water.Iced

Methods inherited from class java.lang.Object

Field Detail

_cidx

_ms

_missing

_xs

_ss

_sparseNA

_sslen

_sparseLen

_timCnt

MIN_SPARSE_RATIO

_isAllASCII

Constructor Detail

NewChunk

NewChunk

NewChunk

NewChunk

NewChunk

NewChunk

NewChunk

Method Detail

alloc_mantissa

alloc_exponent

is

set_is

alloc_nums

alloc_doubles

indices

doubles

isSparseZero

isSparseNA

sparseLenZero

sparseLenNA

naCnt

setSparseRatio

setDoubles

set_vec

add2Chunk

values

values

isNA2

isCategorical2

isCategorical

addCategorical

addNA

addNum

addNum

addStr

addStr

addStr

addUUID

addUUID

addUUID

isUUID

isString

sparseZero

sparseNA

addZeros

addNAs

add

new_close

close

set_sparse

cancel_sparse

compress

set_impl

setNA_impl2

at8_impl2

at8_impl

atd_impl

at16l_impl