@Override public RNode create(ASTNode call, RSymbol[] names, RNode[] exprs) { ArgumentInfo ia = check(call, names, exprs); boolean product = false; if (ia.provided("FUN")) { RNode fnode = exprs[ia.position("FUN")]; if (fnode instanceof Constant) { RAny value = ((Constant) fnode).execute(null); if (value instanceof RString) { RString str = (RString) value; if (str.size() == 1) { if (str.getString(0).equals("*")) { product = true; } } } } } else { product = true; } if (product) { return new MatrixOperation.OuterProduct(call, exprs[ia.position("X")], exprs[ia.position("Y")]); } int cnArgs = 2 + names.length - 3; // "-2" because both FUN, X, Y RSymbol[] cnNames = new RSymbol[cnArgs]; RNode[] cnExprs = new RNode[cnArgs]; cnNames[0] = null; ValueProvider xArgProvider = new ValueProvider(call); cnExprs[0] = xArgProvider; ValueProvider yArgProvider = new ValueProvider(call); cnExprs[1] = yArgProvider; int j = 0; for (int i = 0; i < names.length; i++) { if (ia.position("X") == i || ia.position("Y") == i || ia.position("FUN") == i) { continue; } cnNames[2 + j] = names[i]; cnExprs[2 + j] = exprs[i]; j++; } final CallableProvider callableProvider = new CallableProvider(call, exprs[ia.position("FUN")]); final FunctionCall callNode = FunctionCall.getFunctionCall(call, callableProvider, cnNames, cnExprs); final int posX = ia.position("X"); final int posY = ia.position("Y"); final int posFUN = ia.position("FUN"); return new OuterBuiltIn(call, names, exprs, callNode, callableProvider, xArgProvider, yArgProvider) { @Override public RAny doBuiltIn(Frame frame, RAny[] args) { return outer(frame, args[posX], args[posY], args[posFUN]); } }; }
public static RString substring(RString text, RDouble first, RDouble last, ASTNode ast) { int textSize = text.size(); int firstSize = first.size(); int lastSize = last.size(); int textIndex = 0; int firstIndex = 0; int lastIndex = 0; if (textSize == 0) { return RString.EMPTY; } if (firstSize == 0) { throw RError.getInvalidArgument(ast, "first"); }// not exactly R-warning if (lastSize == 0) { throw RError.getInvalidArgument(ast, "last"); } // not exactly R-warning int n = Math.max(textSize, Math.max(firstSize, lastSize)); String[] content = new String[n]; for (int i = 0; i < n; i++) { double nfirst = first.getDouble(firstIndex++); if (firstIndex == firstSize) { firstIndex = 0; } double nlast = last.getDouble(lastIndex++); if (lastIndex == lastSize) { lastIndex = 0; } String str = text.getString(textIndex++); if (textIndex == textSize) { textIndex = 0; } if (!RDouble.RDoubleUtils.isNAorNaN(nfirst) && !RDouble.RDoubleUtils.isNAorNaN(nlast) && str != RString.NA) { int stp = (int) nlast; int len = str.length(); if (stp > len) { stp = len; } content[i] = str.substring(((int) nfirst) - 1, stp); } else { content[i] = RString.NA; } } return RString.RStringFactory.getFor(content); }
public static ASTNode create(boolean isSuper, ASTNode lhs, ASTNode rhs) { if (lhs instanceof SimpleAccessVariable) { return writeVariable(isSuper, ((SimpleAccessVariable) lhs).symbol, rhs); } else if (lhs instanceof AccessVector) { return writeVector(isSuper, (AccessVector) lhs, rhs); } else if (lhs instanceof FieldAccess) { return writeField(isSuper, (FieldAccess) lhs, rhs); } else if (lhs instanceof FunctionCall) { return writeFunction(isSuper, (FunctionCall) lhs, rhs); } else if (lhs instanceof Constant) { // TODO: move this to the parser? RAny value = ((Constant) lhs).getValue(); if (value instanceof RString) { RString svalue = (RString) value; if (svalue.size() == 1) { String name = svalue.getString(0); return writeVariable(isSuper, RSymbol.getSymbol(name), rhs); } } throw RError.getUnknownObject(rhs); // TODO it's own exception } Utils.nyi(); return null; }