@Override
public Object execute(Frame frame) {
RAny lhsVal = (RAny) lhs.execute(frame);
RAny rowVal = (RAny) rowExpr.execute(frame);
boolean dropVal =
dropExpr.executeLogical(frame)
!= RLogical.FALSE; // FIXME: what is the correct execution order of these args?
int exactVal = exactExpr.executeLogical(frame);
if (!(lhsVal instanceof RArray)) {
throw RError.getObjectNotSubsettable(ast, lhsVal.typeOf());
}
RArray array = (RArray) lhsVal;
int[] dim = array.dimensions();
if (dim == null || dim.length != 2) {
throw RError.getIncorrectDimensions(getAST());
}
int m = dim[0];
int n = dim[1];
try {
int row;
if (rowVal instanceof ScalarIntImpl) {
row = ((ScalarIntImpl) rowVal).getInt();
} else if (rowVal instanceof ScalarDoubleImpl) {
row = Convert.double2int(((ScalarDoubleImpl) rowVal).getDouble());
} else {
throw new UnexpectedResultException(null);
}
if (row > n || row <= 0) {
throw new UnexpectedResultException(null);
}
int[] ndim;
if (dropVal) {
ndim = null;
} else {
ndim = new int[] {1, n};
}
// note: also could be lazy here
RArray res = Utils.createArray(array, n, ndim, null, null); // drop attributes
int offset = row - 1;
for (int i = 0; i < n; i++) {
res.set(i, array.getRef(offset));
offset += m;
}
return res;
} catch (UnexpectedResultException e) {
SelectorNode selIExpr = Selector.createSelectorNode(ast, true, rowExpr);
SelectorNode selJExpr = Selector.createSelectorNode(ast, true, null);
MatrixRead nn = new MatrixRead(ast, true, lhs, selIExpr, selJExpr, dropExpr, exactExpr);
replace(nn, "install MatrixRead from MatrixRowSubset");
Selector selI = selIExpr.executeSelector(rowVal);
Selector selJ = selJExpr.executeSelector(frame);
return nn.executeLoop(array, selI, selJ, dropVal, exactVal);
}
}
public static RRaw doubleToRaw(
RDouble value, ConversionStatus warn) { // eager to keep error semantics eager
int size = value.size();
byte[] content = new byte[size];
for (int i = 0; i < size; i++) {
double dval = value.getDouble(i);
content[i] = Convert.double2raw(dval, warn);
}
return RRaw.RRawFactory.getFor(content, value.dimensions(), value.names());
}
public static RInt double2int(
RDouble value, ConversionStatus warn) { // eager to keep error semantics eager
int size = value.size();
int[] content = new int[size];
for (int i = 0; i < size; i++) {
double d = value.getDouble(i);
content[i] = Convert.double2int(d, warn);
}
return RInt.RIntFactory.getFor(content, value.dimensions(), value.names());
}
@Override
public byte getRaw(int i) {
return Convert.double2raw(orig.getDouble(i));
}
@Override
public int getLogical(int i) {
return Convert.double2logical(orig.getDouble(i));
}
@Override
public int getInt(int i) {
return Convert.double2int(orig.getDouble(i));
}
@Override
public String getString(int i) {
return Convert.double2string(orig.getDouble(i));
}
@Override
public Object execute(Frame frame) {
RAny lhsVal = (RAny) lhs.execute(frame);
RAny colVal = (RAny) columnExpr.execute(frame);
boolean dropVal =
dropExpr.executeLogical(frame)
!= RLogical.FALSE; // FIXME: what is the correct execution order of these args?
int exactVal = exactExpr.executeLogical(frame);
// TODO: GNU-R has different behavior when selecting from arrays that have some dimension zero
if (!(lhsVal instanceof RArray)) {
throw RError.getObjectNotSubsettable(ast, lhsVal.typeOf());
}
RArray array = (RArray) lhsVal;
int[] dim = array.dimensions();
if (dim == null || dim.length != nSelectors) {
throw RError.getIncorrectDimensions(getAST());
}
int n = dim[nSelectors - 1]; // limit for the column (last dimension)
try {
int col;
if (colVal instanceof ScalarIntImpl) {
col = ((ScalarIntImpl) colVal).getInt();
} else if (colVal instanceof ScalarDoubleImpl) {
col = Convert.double2int(((ScalarDoubleImpl) colVal).getDouble());
} else {
throw new UnexpectedResultException(null);
}
if (col > n || col <= 0) {
throw new UnexpectedResultException(null);
}
int[] ndim;
int m; // size of the result
if (dropVal) {
boolean hasNonTrivialDimension = false;
boolean resultIsVector = true;
m = 1;
for (int i = 0; i < nSelectors - 1; i++) {
int d = dim[i];
if (d != 1) {
if (hasNonTrivialDimension) {
resultIsVector = false;
} else {
hasNonTrivialDimension = true;
}
}
m *= d;
}
if (resultIsVector) {
ndim = null;
} else {
ndim = new int[nSelectors - 1];
System.arraycopy(dim, 0, ndim, 0, ndim.length);
}
} else {
ndim = new int[nSelectors];
ndim[nSelectors - 1] = 1;
m = 1;
for (int i = 0; i < ndim.length - 1; i++) {
int d = dim[i];
ndim[i] = d;
m *= d;
}
}
// note: also could be lazy here
RArray res = Utils.createArray(array, m, ndim, null, null); // drop attributes
int offset = (col - 1) * m; // note: col is 1-based
for (int i = 0; i < m; i++) {
res.set(i, array.getRef(offset + i));
}
return res;
} catch (UnexpectedResultException e) {
SelectorNode[] selectorExprs = new SelectorNode[nSelectors];
for (int i = 0; i < nSelectors - 1; i++) {
selectorExprs[i] = Selector.createSelectorNode(ast, true, null);
}
selectorExprs[nSelectors - 1] = Selector.createSelectorNode(ast, true, columnExpr);
GenericRead gr = new GenericRead(ast, true, lhs, selectorExprs, dropExpr, exactExpr);
replace(gr, "install GenericRead from ArrayColumnSubset");
for (int i = 0; i < nSelectors - 1; i++) {
gr.selectorVals[i] = selectorExprs[i].executeSelector(frame);
}
gr.selectorVals[nSelectors - 1] = selectorExprs[nSelectors - 1].executeSelector(colVal);
return gr.executeLoop(array, dropVal, exactVal);
}
}