@Test
public void test() {
Frame frame = null;
try {
Futures fs = new Futures();
Random random = new Random();
Vec[] vecs = new Vec[1];
AppendableVec vec = new AppendableVec(Vec.newKey(), Vec.T_NUM);
for (int i = 0; i < 2; i++) {
NewChunk chunk = new NewChunk(vec, i);
for (int r = 0; r < 1000; r++) chunk.addNum(random.nextInt(1000));
chunk.close(i, fs);
}
vecs[0] = vec.layout_and_close(fs);
fs.blockForPending();
frame = new Frame(Key.<Frame>make(), null, vecs);
// Make sure we test the multi-chunk case
vecs = frame.vecs();
assert vecs[0].nChunks() > 1;
long rows = frame.numRows();
Vec v = vecs[0];
double min = Double.POSITIVE_INFINITY, max = Double.NEGATIVE_INFINITY, mean = 0, sigma = 0;
for (int r = 0; r < rows; r++) {
double d = v.at(r);
if (d < min) min = d;
if (d > max) max = d;
mean += d;
}
mean /= rows;
for (int r = 0; r < rows; r++) {
double d = v.at(r);
sigma += (d - mean) * (d - mean);
}
sigma = Math.sqrt(sigma / (rows - 1));
double epsilon = 1e-9;
assertEquals(max, v.max(), epsilon);
assertEquals(min, v.min(), epsilon);
assertEquals(mean, v.mean(), epsilon);
assertEquals(sigma, v.sigma(), epsilon);
} finally {
if (frame != null) frame.delete();
}
}
@Override
public void map(Chunk cs) {
int idx = _chunkOffset + cs.cidx();
Key ckey = Vec.chunkKey(_v._key, idx);
if (_cmap != null) {
assert !cs.hasFloat()
: "Input chunk (" + cs.getClass() + ") has float, but is expected to be categorical";
NewChunk nc = new NewChunk(_v, idx);
// loop over rows and update ints for new domain mapping according to vecs[c].domain()
for (int r = 0; r < cs._len; ++r) {
if (cs.isNA(r)) nc.addNA();
else nc.addNum(_cmap[(int) cs.at8(r)], 0);
}
nc.close(_fs);
} else {
DKV.put(ckey, cs.deepCopy(), _fs, true);
}
}
private void rebalanceChunk(Vec srcVec, Chunk chk) {
NewChunk dst = new NewChunk(chk);
dst._len = dst._len2 = 0;
int rem = chk._len;
while (rem > 0 && dst._len2 < chk._len) {
Chunk srcRaw = srcVec.chunkForRow(chk._start + dst._len2);
NewChunk src = new NewChunk((srcRaw));
src = srcRaw.inflate_impl(src);
assert src._len2 == srcRaw._len;
int srcFrom = (int) (chk._start + dst._len2 - src._start);
// check if the result is sparse (not exact since we only take subset of src in general)
if ((src.sparse() && dst.sparse())
|| (src._len + dst._len < NewChunk.MIN_SPARSE_RATIO * (src._len2 + dst._len2))) {
src.set_sparse(src._len);
dst.set_sparse(dst._len);
}
final int srcTo = srcFrom + rem;
int off = srcFrom - 1;
Iterator<NewChunk.Value> it = src.values(Math.max(0, srcFrom), srcTo);
while (it.hasNext()) {
NewChunk.Value v = it.next();
final int rid = v.rowId0();
assert rid < srcTo;
int add = rid - off;
off = rid;
dst.addZeros(add - 1);
v.add2Chunk(dst);
rem -= add;
assert rem >= 0;
}
int trailingZeros = Math.min(rem, src._len2 - off - 1);
dst.addZeros(trailingZeros);
rem -= trailingZeros;
}
assert rem == 0 : "rem = " + rem;
assert dst._len2 == chk._len : "len2 = " + dst._len2 + ", _len = " + chk._len;
dst.close(dst.cidx(), _fs);
}
public void close(Futures fs) {
close(_cidx, fs);
}
public Frame deepSlice(Object orows, Object ocols) {
// ocols is either a long[] or a Frame-of-1-Vec
long[] cols;
if (ocols == null) {
cols = (long[]) ocols;
assert cols == null;
} else {
if (ocols instanceof long[]) {
cols = (long[]) ocols;
} else if (ocols instanceof Frame) {
Frame fr = (Frame) ocols;
if (fr.numCols() != 1) {
throw new IllegalArgumentException(
"Columns Frame must have only one column (actually has "
+ fr.numCols()
+ " columns)");
}
long n = fr.anyVec().length();
if (n > MAX_EQ2_COLS) {
throw new IllegalArgumentException(
"Too many requested columns (requested " + n + ", max " + MAX_EQ2_COLS + ")");
}
cols = new long[(int) n];
Vec v = fr._vecs[0];
for (long i = 0; i < v.length(); i++) {
cols[(int) i] = v.at8(i);
}
} else {
throw new IllegalArgumentException(
"Columns is specified by an unsupported data type ("
+ ocols.getClass().getName()
+ ")");
}
}
// Since cols is probably short convert to a positive list.
int c2[] = null;
if (cols == null) {
c2 = new int[numCols()];
for (int i = 0; i < c2.length; i++) c2[i] = i;
} else if (cols.length == 0) {
c2 = new int[0];
} else if (cols[0] > 0) {
c2 = new int[cols.length];
for (int i = 0; i < cols.length; i++)
c2[i] = (int) cols[i] - 1; // Convert 1-based cols to zero-based
} else {
c2 = new int[numCols() - cols.length];
int j = 0;
for (int i = 0; i < numCols(); i++) {
if (j >= cols.length || i < (-cols[j] - 1)) c2[i - j] = i;
else j++;
}
}
for (int i = 0; i < c2.length; i++)
if (c2[i] >= numCols())
throw new IllegalArgumentException(
"Trying to select column " + c2[i] + " but only " + numCols() + " present.");
if (c2.length == 0)
throw new IllegalArgumentException(
"No columns selected (did you try to select column 0 instead of column 1?)");
// Do Da Slice
// orows is either a long[] or a Vec
if (orows == null)
return new DeepSlice((long[]) orows, c2)
.doAll(c2.length, this)
.outputFrame(names(c2), domains(c2));
else if (orows instanceof long[]) {
final long CHK_ROWS = 1000000;
long[] rows = (long[]) orows;
if (rows.length == 0)
return new DeepSlice(rows, c2).doAll(c2.length, this).outputFrame(names(c2), domains(c2));
if (rows[0] < 0)
return new DeepSlice(rows, c2).doAll(c2.length, this).outputFrame(names(c2), domains(c2));
// Vec'ize the index array
AppendableVec av = new AppendableVec("rownames");
int r = 0;
int c = 0;
while (r < rows.length) {
NewChunk nc = new NewChunk(av, c);
long end = Math.min(r + CHK_ROWS, rows.length);
for (; r < end; r++) {
nc.addNum(rows[r]);
}
nc.close(c++, null);
}
Vec c0 = av.close(null); // c0 is the row index vec
Frame fr2 =
new Slice(c2, this)
.doAll(c2.length, new Frame(new String[] {"rownames"}, new Vec[] {c0}))
.outputFrame(names(c2), domains(c2));
UKV.remove(c0._key); // Remove hidden vector
return fr2;
}
Frame frows = (Frame) orows;
Vec vrows = frows.anyVec();
// It's a compatible Vec; use it as boolean selector.
// Build column names for the result.
Vec[] vecs = new Vec[c2.length + 1];
String[] names = new String[c2.length + 1];
for (int i = 0; i < c2.length; ++i) {
vecs[i] = _vecs[c2[i]];
names[i] = _names[c2[i]];
}
vecs[c2.length] = vrows;
names[c2.length] = "predicate";
return new DeepSelect()
.doAll(c2.length, new Frame(names, vecs))
.outputFrame(names(c2), domains(c2));
}