in src/main/java/org/apache/sysds/parser/DataExpression.java [901:2161]
public void validateExpression(HashMap<String, DataIdentifier> ids, HashMap<String, ConstIdentifier> currConstVars, boolean conditional)
{
// validate all input parameters
for ( Entry<String,Expression> e : getVarParams().entrySet() ) {
String s = e.getKey();
Expression inputParamExpr = e.getValue();
if (inputParamExpr instanceof FunctionCallIdentifier) {
raiseValidateError("UDF function call not supported as parameter to built-in function call", false,LanguageErrorCodes.INVALID_PARAMETERS);
}
inputParamExpr.validateExpression(ids, currConstVars, conditional);
if (s != null && !s.equals(RAND_DATA) && !s.equals(RAND_DIMS) && !s.equals(FED_ADDRESSES) && !s.equals(FED_RANGES) && !s.equals(FED_LOCAL_OBJECT)
&& !s.equals(DELIM_NA_STRINGS) && !s.equals(SCHEMAPARAM) && getVarParam(s).getOutput().getDataType() != DataType.SCALAR ) {
raiseValidateError("Non-scalar data types are not supported for data expression.", conditional,LanguageErrorCodes.INVALID_PARAMETERS);
}
}
//general data expression constant propagation
performConstantPropagationRand( currConstVars );
performConstantPropagationReadWrite( currConstVars );
// check if data parameter of matrix is scalar or matrix -- if scalar, use Rand instead
Expression dataParam1 = getVarParam(RAND_DATA);
if (dataParam1 == null && (getOpCode().equals(DataOp.MATRIX) || getOpCode().equals(DataOp.TENSOR))){
raiseValidateError("for matrix, frame or tensor, must defined data parameter", conditional, LanguageErrorCodes.INVALID_PARAMETERS);
}
// We need to remember the operation if we replace the OpCode by rand so we have the correct output
if (dataParam1!=null && dataParam1.getOutput()!=null && dataParam1.getOutput().getDataType() == DataType.SCALAR &&
(_opcode == DataOp.MATRIX || _opcode == DataOp.TENSOR)/*&& dataParam instanceof ConstIdentifier*/ ){
//MB: note we must not check for const identifiers here, because otherwise all matrix constructors with
//variable input are routed to a reshape operation (but it works only on matrices and hence, crashes)
// replace DataOp MATRIX with RAND -- Rand handles matrix generation for Scalar values
// replace data parameter with min / max within Rand case below
this.setOpCode(DataOp.RAND);
}
// IMPORTANT: for each operation, one must handle unnamed parameters
switch (this.getOpCode()) {
case READ:
if (getVarParam(DATATYPEPARAM) != null && !(getVarParam(DATATYPEPARAM) instanceof StringIdentifier)){
raiseValidateError("for read statement, parameter " + DATATYPEPARAM + " can only be a string. " +
"Valid values are: " + Statement.MATRIX_DATA_TYPE +", " + Statement.SCALAR_DATA_TYPE, conditional);
}
String dataTypeString = (getVarParam(DATATYPEPARAM) == null) ? null : getVarParam(DATATYPEPARAM).toString();
// disallow certain parameters while reading a scalar
if (dataTypeString != null && dataTypeString.equalsIgnoreCase(Statement.SCALAR_DATA_TYPE)){
if ( getVarParam(READROWPARAM) != null
|| getVarParam(READCOLPARAM) != null
|| getVarParam(ROWBLOCKCOUNTPARAM) != null
|| getVarParam(COLUMNBLOCKCOUNTPARAM) != null
|| getVarParam(FORMAT_TYPE) != null
|| getVarParam(DELIM_DELIMITER) != null
|| getVarParam(LIBSVM_INDEX_DELIM) != null
|| getVarParam(DELIM_HAS_HEADER_ROW) != null
|| getVarParam(DELIM_FILL) != null
|| getVarParam(DELIM_FILL_VALUE) != null
|| getVarParam(DELIM_NA_STRINGS) != null
)
{
raiseValidateError("Invalid parameters in read statement of a scalar: " +
toString() + ". Only " + VALUETYPEPARAM + " is allowed.", conditional, LanguageErrorCodes.INVALID_PARAMETERS);
}
}
MetaDataAll configObj = new MetaDataAll();
// Process expressions in input filename
String inputFileName = getInputFileName(currConstVars, conditional);
// Obtain and validate metadata filename
String mtdFileName = getMTDFileName(inputFileName);
// track whether should attempt to read MTD file or not
boolean shouldReadMTD = _checkMetadata
&& !(dataTypeString!= null && getVarParam(VALUETYPEPARAM) != null
&& dataTypeString.equalsIgnoreCase(Statement.SCALAR_DATA_TYPE))
&& (!ConfigurationManager.getCompilerConfigFlag(ConfigType.IGNORE_READ_WRITE_METADATA)
|| HDFSTool.existsFileOnHDFS(mtdFileName)); // existing mtd file
// Check for file existence (before metadata parsing for meaningful error messages)
if( shouldReadMTD //skip check for jmlc/mlcontext
&& !HDFSTool.existsFileOnHDFS(inputFileName)
&& !ConfigurationManager.getCompilerConfigFlag(ConfigType.RESOURCE_OPTIMIZATION))
{
String fsext = InfrastructureAnalyzer.isLocalMode() ? "FS (local mode)" : "HDFS";
raiseValidateError("Read input file does not exist on "+fsext+": " +
inputFileName, conditional);
}
// track whether format type has been inferred
boolean inferredFormatType = false;
// get format type string
String formatTypeString = (getVarParam(FORMAT_TYPE) == null) ?
null : getVarParam(FORMAT_TYPE).toString();
// check if file is matrix market format
if (formatTypeString == null && shouldReadMTD){
if ( MetaDataAll.checkHasMatrixMarketFormat(inputFileName, mtdFileName, conditional) ) {
formatTypeString = FileFormat.MM.toString();
addVarParam(FORMAT_TYPE, new StringIdentifier(formatTypeString, this));
configObj.setFormatTypeString(formatTypeString);
inferredFormatType = true;
shouldReadMTD = false;
}
}
// check if file is delimited format
if (formatTypeString == null && shouldReadMTD ) {
formatTypeString = MetaDataAll.checkHasDelimitedFormat(inputFileName, conditional);
if (formatTypeString != null) {
addVarParam(FORMAT_TYPE, new StringIdentifier(formatTypeString, this));
configObj.setFormatTypeString(formatTypeString);
inferredFormatType = true;
}
}
if (formatTypeString != null && formatTypeString.equalsIgnoreCase(FileFormat.MM.toString())){
/*
* handle MATRIXMARKET_FORMAT_TYPE format
*
* 1) only allow IO_FILENAME as ONLY valid parameter
*
* 2) open the file
* A) verify header line (1st line) equals
* B) read and discard comment lines
* C) get size information from sizing info line --- M N L
*/
// should NOT attempt to read MTD file for MatrixMarket format
shouldReadMTD = false;
// get metadata from MatrixMarket format file
String[] headerLines = null;
try {
headerLines = IOUtilFunctions.readMatrixMarketHeader(inputFileName);
}
catch(DMLRuntimeException ex) {
raiseValidateError(ex.getMessage(), conditional);
}
if (headerLines != null && headerLines.length >= 2){
// process 1st line of MatrixMarket format to check for support types
String firstLine = headerLines[0].trim();
FileFormatPropertiesMM props = FileFormatPropertiesMM.parse(firstLine);
// process 2nd line of MatrixMarket format -- must have size information
String secondLine = headerLines[1];
String[] sizeInfo = secondLine.trim().split("\\s+");
if (sizeInfo.length != 3){
raiseValidateError("Unsupported size line in MatrixMarket file: " +
headerLines[1] + ". Only supported format in MatrixMarket file has size line: <NUM ROWS> <NUM COLS> <NUM NON-ZEROS>, where each value is an integer.", conditional);
}
long rowsCount = Long.parseLong(sizeInfo[0]);
if (rowsCount < 0)
raiseValidateError("MM file: invalid number of rows: "+rowsCount);
else if( getVarParam(READROWPARAM) != null ) {
long rowsCount2 = Long.parseLong(getVarParam(READROWPARAM).toString());
if( rowsCount2 != rowsCount )
raiseValidateError("MM file: invalid specified number of rows: "+rowsCount2+" vs "+rowsCount);
}
addVarParam(READROWPARAM, new IntIdentifier(rowsCount, this));
long colsCount = Long.parseLong(sizeInfo[1]);
if (colsCount < 0)
raiseValidateError("MM file: invalid number of columns: "+colsCount);
else if( getVarParam(READCOLPARAM) != null ) {
long colsCount2 = Long.parseLong(getVarParam(READCOLPARAM).toString());
if( colsCount2 != colsCount )
raiseValidateError("MM file: invalid specified number of columns: "+colsCount2+" vs "+colsCount);
}
addVarParam(READCOLPARAM, new IntIdentifier(colsCount, this));
configObj.setDimensions(rowsCount, colsCount);
long nnzCount = Long.parseLong(sizeInfo[2]) * (props.isSymmetric() ? 2 : 1);
if (nnzCount < 0)
raiseValidateError("MM file: invalid number of non-zeros: "+nnzCount);
else if( getVarParam(READNNZPARAM) != null ) {
long nnzCount2 = Long.parseLong(getVarParam(READNNZPARAM).toString());
if( nnzCount2 != nnzCount )
raiseValidateError("MM file: invalid specified number of non-zeros: "+nnzCount2+" vs "+nnzCount);
}
addVarParam(READNNZPARAM, new IntIdentifier(nnzCount, this));
configObj.setNnz(nnzCount);
}
}
boolean isCSV = (formatTypeString != null && formatTypeString.equalsIgnoreCase(FileFormat.CSV.toString()));
if (shouldReadMTD){
configObj = new MetaDataAll(mtdFileName, conditional, false);
if (configObj.mtdExists()){
_varParams = configObj.parseMetaDataFileParameters(mtdFileName, conditional, _varParams);
inferredFormatType = true;
}
else {
if(!isCSV){
LOG.warn("Metadata file: " + new Path(mtdFileName) + " not provided");
}
}
}
if (isCSV){
// there should be no MTD file for delimited file format
shouldReadMTD = true;
// Handle valid ParamNames.
if( !inferredFormatType ){
for (String key : _varParams.keySet()){
if (! READ_VALID_PARAM_NAMES.contains(key))
{
String msg = "Only parameters allowed are: " + READ_VALID_PARAM_NAMES;
raiseValidateError("Invalid parameter " + key + " in read statement: " +
toString() + ". " + msg, conditional, LanguageErrorCodes.INVALID_PARAMETERS);
}
}
}
//handle all csv default parameters
handleCSVDefaultParam(DELIM_DELIMITER, ValueType.STRING, conditional);
handleCSVDefaultParam(DELIM_FILL_VALUE, ValueType.FP64, conditional);
handleCSVDefaultParam(DELIM_HAS_HEADER_ROW, ValueType.BOOLEAN, conditional);
handleCSVDefaultParam(DELIM_FILL, ValueType.BOOLEAN, conditional);
handleCSVDefaultParam(DELIM_NA_STRINGS, ValueType.STRING, conditional);
}
boolean isLIBSVM = false;
isLIBSVM = (formatTypeString != null && formatTypeString.equalsIgnoreCase(FileFormat.LIBSVM.toString()));
if (isLIBSVM) {
// Handle libsvm file format
shouldReadMTD = true;
// only allow IO_FILENAME, READROWPARAM, READCOLPARAM
// as valid parameters
if( !inferredFormatType ) {
for (String key : _varParams.keySet()) {
if (!(key.equals(IO_FILENAME) || key.equals(FORMAT_TYPE)
|| key.equals(READROWPARAM) || key.equals(READCOLPARAM)
|| key.equals(READNNZPARAM) || key.equals(DATATYPEPARAM)
|| key.equals(VALUETYPEPARAM) || key.equals(DELIM_DELIMITER)
|| key.equals(LIBSVM_INDEX_DELIM)))
{
String msg = "Only parameters allowed are: " + IO_FILENAME + ","
+ READROWPARAM + "," + READCOLPARAM
+ DELIM_DELIMITER + "," + LIBSVM_INDEX_DELIM;
raiseValidateError("Invalid parameter " + key + " in read statement: " +
toString() + ". " + msg, conditional, LanguageErrorCodes.INVALID_PARAMETERS);
}
}
}
//handle all default parameters
handleCSVDefaultParam(DELIM_DELIMITER, ValueType.STRING, conditional);
handleCSVDefaultParam(LIBSVM_INDEX_DELIM, ValueType.STRING, conditional);
}
boolean isHDF5 = (formatTypeString != null && formatTypeString.equalsIgnoreCase(FileFormat.HDF5.toString()));
boolean isCOG = (formatTypeString != null && formatTypeString.equalsIgnoreCase(FileFormat.COG.toString()));
dataTypeString = (getVarParam(DATATYPEPARAM) == null) ? null : getVarParam(DATATYPEPARAM).toString();
if ( dataTypeString == null || dataTypeString.equalsIgnoreCase(Statement.MATRIX_DATA_TYPE)
|| dataTypeString.equalsIgnoreCase(Statement.FRAME_DATA_TYPE)) {
boolean isMatrix = false;
if ( dataTypeString == null || dataTypeString.equalsIgnoreCase(Statement.MATRIX_DATA_TYPE))
isMatrix = true;
// set data type
getOutput().setDataType(isMatrix ? DataType.MATRIX : DataType.FRAME);
// set number non-zeros
Expression ennz = getVarParam("nnz");
long nnz = -1;
if( ennz != null ) {
nnz = Long.valueOf(ennz.toString());
getOutput().setNnz(nnz);
}
// Following dimension checks must be done when data type = MATRIX_DATA_TYPE
// initialize size of target data identifier to UNKNOWN
getOutput().setDimensions(-1, -1);
if (!isCSV && !isLIBSVM && !isHDF5 && !isCOG && ConfigurationManager.getCompilerConfig()
.getBool(ConfigType.REJECT_READ_WRITE_UNKNOWNS) //skip check for csv/libsvm format / jmlc api
&& (getVarParam(READROWPARAM) == null || getVarParam(READCOLPARAM) == null) ) {
raiseValidateError("Missing or incomplete dimension information in read statement: "
+ mtdFileName, conditional, LanguageErrorCodes.INVALID_PARAMETERS);
}
if (getVarParam(READROWPARAM) instanceof ConstIdentifier
&& getVarParam(READCOLPARAM) instanceof ConstIdentifier)
{
// these are strings that are long values
Long dim1 = (getVarParam(READROWPARAM) == null) ? null : Long.valueOf( getVarParam(READROWPARAM).toString());
Long dim2 = (getVarParam(READCOLPARAM) == null) ? null : Long.valueOf( getVarParam(READCOLPARAM).toString());
if ( !isCSV && (dim1 < 0 || dim2 < 0) && ConfigurationManager
.getCompilerConfig().getBool(ConfigType.REJECT_READ_WRITE_UNKNOWNS) ) {
raiseValidateError("Invalid dimension information in read statement", conditional, LanguageErrorCodes.INVALID_PARAMETERS);
}
// set dim1 and dim2 values
if (dim1 != null && dim2 != null){
getOutput().setDimensions(dim1, dim2);
} else if (!isCSV && ((dim1 != null) || (dim2 != null))) {
raiseValidateError("Partial dimension information in read statement", conditional, LanguageErrorCodes.INVALID_PARAMETERS);
}
}
if(isLIBSVM) {
Long dim2 = (getVarParam(READCOLPARAM) == null) ? null : Long.valueOf(getVarParam(READCOLPARAM).toString());
if(dim2 < 0 && ConfigurationManager.getCompilerConfig()
.getBool(ConfigType.REJECT_READ_WRITE_UNKNOWNS)) {
raiseValidateError("Invalid dimension information in read statement", conditional, LanguageErrorCodes.INVALID_PARAMETERS);
}
getOutput().setDimensions(-1, dim2 + 1);
}
// initialize block dimensions to UNKNOWN
getOutput().setBlocksize(-1);
String fmt = (getVarParam(FORMAT_TYPE) == null ?
FileFormat.defaultFormatString() : getVarParam(FORMAT_TYPE).toString());
try {
getOutput().setFileFormat(FileFormat.safeValueOf(fmt));
}
catch(Exception ex) {
raiseValidateError("Invalid format '" + fmt+ "' in statement: " + toString(), conditional);
}
if (getVarParam(ROWBLOCKCOUNTPARAM) instanceof ConstIdentifier && getVarParam(COLUMNBLOCKCOUNTPARAM) instanceof ConstIdentifier) {
Integer rowBlockCount = (getVarParam(ROWBLOCKCOUNTPARAM) == null) ?
null : Integer.valueOf(getVarParam(ROWBLOCKCOUNTPARAM).toString());
getOutput().setBlocksize(rowBlockCount != null ? rowBlockCount : -1);
}
// block dimensions must be -1x-1 when format="text"
// NOTE MB: disabled validate of default blocksize for inputs w/ format="binary"
// because we automatically introduce reblocks if blocksizes don't match
if ( (getOutput().getFileFormat().isTextFormat() || !isMatrix) && getOutput().getBlocksize() != -1 ){
raiseValidateError("Invalid block dimensions (" + getOutput().getBlocksize() + ") when format=" + getVarParam(FORMAT_TYPE) + " in \"" + this.toString() + "\".", conditional);
}
}
else if ( dataTypeString.equalsIgnoreCase(Statement.SCALAR_DATA_TYPE)) {
getOutput().setDataType(DataType.SCALAR);
getOutput().setNnz(-1L);
}
else if ( dataTypeString.equalsIgnoreCase(DataType.LIST.name())) {
getOutput().setDataType(DataType.LIST);
}
else{
raiseValidateError("Unknown Data Type " + dataTypeString + ". Valid values: "
+ Statement.SCALAR_DATA_TYPE +", " + Statement.MATRIX_DATA_TYPE+", " + Statement.FRAME_DATA_TYPE
+", " + DataType.LIST.name().toLowerCase(), conditional, LanguageErrorCodes.INVALID_PARAMETERS);
}
// handle value type parameter
if (getVarParam(VALUETYPEPARAM) != null && !(getVarParam(VALUETYPEPARAM) instanceof StringIdentifier)){
raiseValidateError("for read method, parameter " + VALUETYPEPARAM + " can only be a string. " +
"Valid values are: " + Statement.DOUBLE_VALUE_TYPE +", " + Statement.INT_VALUE_TYPE + ", " + Statement.BOOLEAN_VALUE_TYPE + ", " + Statement.STRING_VALUE_TYPE, conditional);
}
// Identify the value type (used only for read method)
String valueTypeString = getVarParam(VALUETYPEPARAM) == null ? null : getVarParam(VALUETYPEPARAM).toString();
if (valueTypeString != null) {
if (valueTypeString.equalsIgnoreCase(Statement.DOUBLE_VALUE_TYPE))
getOutput().setValueType(ValueType.FP64);
else if (valueTypeString.equalsIgnoreCase(Statement.STRING_VALUE_TYPE))
getOutput().setValueType(ValueType.STRING);
else if (valueTypeString.equalsIgnoreCase(Statement.INT_VALUE_TYPE))
getOutput().setValueType(ValueType.INT64);
else if (valueTypeString.equalsIgnoreCase(Statement.BOOLEAN_VALUE_TYPE))
getOutput().setValueType(ValueType.BOOLEAN);
else if (valueTypeString.equalsIgnoreCase(ValueType.UNKNOWN.name()))
getOutput().setValueType(ValueType.UNKNOWN);
else {
raiseValidateError("Unknown Value Type " + valueTypeString
+ ". Valid values are: " + Statement.DOUBLE_VALUE_TYPE +", " + Statement.INT_VALUE_TYPE + ", " + Statement.BOOLEAN_VALUE_TYPE + ", " + Statement.STRING_VALUE_TYPE, conditional);
}
} else {
getOutput().setValueType(ValueType.FP64);
}
break;
case WRITE:
// for CSV format, if no delimiter specified THEN set default ","
if (getVarParam(FORMAT_TYPE) == null || checkFormatType(FileFormat.CSV) ){
if (getVarParam(DELIM_DELIMITER) == null) {
addVarParam(DELIM_DELIMITER, new StringIdentifier(DEFAULT_DELIM_DELIMITER, this));
}
if (getVarParam(DELIM_HAS_HEADER_ROW) == null) {
addVarParam(DELIM_HAS_HEADER_ROW, new BooleanIdentifier(DEFAULT_DELIM_HAS_HEADER_ROW, this));
}
if (getVarParam(DELIM_SPARSE) == null) {
addVarParam(DELIM_SPARSE, new BooleanIdentifier(DEFAULT_DELIM_SPARSE, this));
}
}
// for LIBSVM format, add the default separators if not specified
if (getVarParam(FORMAT_TYPE) == null || checkFormatType(FileFormat.LIBSVM)) {
if(getVarParam(DELIM_DELIMITER) == null) {
addVarParam(DELIM_DELIMITER, new StringIdentifier(DEFAULT_DELIM_DELIMITER, this));
}
if(getVarParam(LIBSVM_INDEX_DELIM) == null) {
addVarParam(LIBSVM_INDEX_DELIM, new StringIdentifier(DEFAULT_LIBSVM_INDEX_DELIM, this));
}
if(getVarParam(DELIM_SPARSE) == null) {
addVarParam(DELIM_SPARSE, new BooleanIdentifier(DEFAULT_DELIM_SPARSE, this));
}
}
//validate read filename
if (getVarParam(FORMAT_TYPE) == null || FileFormat.isTextFormat(getVarParam(FORMAT_TYPE).toString()))
getOutput().setBlocksize(-1);
else if (checkFormatType(FileFormat.BINARY, FileFormat.COMPRESSED, FileFormat.UNKNOWN)) {
if( getVarParam(ROWBLOCKCOUNTPARAM)!=null )
getOutput().setBlocksize(Integer.parseInt(getVarParam(ROWBLOCKCOUNTPARAM).toString()));
else
getOutput().setBlocksize(ConfigurationManager.getBlocksize());
}
else if( getVarParam(FORMAT_TYPE) instanceof StringIdentifier ) //literal format
raiseValidateError("Invalid format " + getVarParam(FORMAT_TYPE)
+ " in statement: " + toString(), conditional);
break;
case RAND:
Expression dataParam = getVarParam(RAND_DATA);
if( dataParam != null )
{
// handle input variable (matrix/scalar)
if( dataParam instanceof DataIdentifier )
{
addVarParam(RAND_MIN, dataParam);
addVarParam(RAND_MAX, dataParam);
}
// handle integer constant
else if (dataParam instanceof IntIdentifier) {
addVarParam(RAND_MIN, dataParam);
addVarParam(RAND_MAX, dataParam);
}
// handle double constant
else if (dataParam instanceof DoubleIdentifier) {
double roundedValue = ((DoubleIdentifier)dataParam).getValue();
Expression minExpr = new DoubleIdentifier(roundedValue, this);
addVarParam(RAND_MIN, minExpr);
addVarParam(RAND_MAX, minExpr);
}
// handle string constant (string init)
else if (dataParam instanceof StringIdentifier) {
String data = ((StringIdentifier)dataParam).getValue();
Expression minExpr = new StringIdentifier(data, this);
addVarParam(RAND_MIN, minExpr);
addVarParam(RAND_MAX, minExpr);
_strInit = true;
}
else {
// handle general expression
dataParam.validateExpression(ids, currConstVars, conditional);
addVarParam(RAND_MIN, dataParam);
addVarParam(RAND_MAX, dataParam);
}
removeVarParam(RAND_DATA);
removeVarParam(RAND_BY_ROW);
this.setRandDefault();
}
//check valid parameters
validateParams(conditional, RAND_VALID_PARAM_NAMES, "Legal parameters for Rand statement are "
+ "(capitalization-sensitive): " + RAND_ROWS + ", " + RAND_COLS + ", " + RAND_DIMS + ", "
+ RAND_MIN + ", " + RAND_MAX + ", " + RAND_SPARSITY + ", " + RAND_SEED + ", "
+ RAND_PDF + ", " + RAND_LAMBDA);
//parameters w/ support for variable inputs
if (getVarParam(RAND_ROWS) instanceof StringIdentifier || getVarParam(RAND_ROWS) instanceof BooleanIdentifier){
raiseValidateError("for Rand statement " + RAND_ROWS + " has incorrect value type", conditional);
}
if (getVarParam(RAND_COLS) instanceof StringIdentifier || getVarParam(RAND_COLS) instanceof BooleanIdentifier){
raiseValidateError("for Rand statement " + RAND_COLS + " has incorrect value type", conditional);
}
if (getVarParam(RAND_DIMS) instanceof IntIdentifier || getVarParam(RAND_DIMS) instanceof DoubleIdentifier
|| getVarParam(RAND_DIMS) instanceof BooleanIdentifier){
raiseValidateError("for Rand statement " + RAND_DIMS + " has incorrect value type", conditional);
}
if (getVarParam(RAND_SEED) instanceof StringIdentifier || getVarParam(RAND_SEED) instanceof BooleanIdentifier) {
raiseValidateError("for Rand statement " + RAND_SEED + " has incorrect value type", conditional);
}
boolean isTensorOperation = getVarParam(RAND_DIMS) != null;
if ((getVarParam(RAND_MAX) instanceof StringIdentifier && !_strInit) ||
(getVarParam(RAND_MAX) instanceof BooleanIdentifier && !isTensorOperation)) {
raiseValidateError("for Rand statement " + RAND_MAX + " has incorrect value type", conditional);
}
if ((getVarParam(RAND_MIN) instanceof StringIdentifier && !_strInit) ||
getVarParam(RAND_MIN) instanceof BooleanIdentifier && !isTensorOperation)
raiseValidateError("for Rand statement " + RAND_MIN + " has incorrect value type", conditional);
// Since sparsity can be arbitrary expression (SYSTEMML-515), no validation check for DoubleIdentifier/IntIdentifier required.
if (!(getVarParam(RAND_PDF) instanceof StringIdentifier)) {
raiseValidateError("for Rand statement " + RAND_PDF + " has incorrect value type", conditional);
}
Expression lambda = getVarParam(RAND_LAMBDA);
if (!( (lambda instanceof DataIdentifier
|| lambda instanceof ConstIdentifier)
&& (lambda.getOutput().getValueType() == ValueType.FP64
|| lambda.getOutput().getValueType() == ValueType.INT64) )) {
raiseValidateError("for Rand statement " + RAND_LAMBDA + " has incorrect data type", conditional);
}
long rowsLong = -1L, colsLong = -1L;
Expression rowsExpr = getVarParam(RAND_ROWS);
Expression colsExpr = getVarParam(RAND_COLS);
if (!isTensorOperation) {
///////////////////////////////////////////////////////////////////
// HANDLE ROWS
///////////////////////////////////////////////////////////////////
if( rowsExpr instanceof IntIdentifier ) {
if( ((IntIdentifier) rowsExpr).getValue() < 0 ) {
raiseValidateError("In rand statement, can only assign rows a long " +
"(integer) value >= 0 -- attempted to assign value: " + ((IntIdentifier) rowsExpr).getValue(), conditional);
}
rowsLong = ((IntIdentifier) rowsExpr).getValue();
}
else if( rowsExpr instanceof DoubleIdentifier ) {
if( ((DoubleIdentifier) rowsExpr).getValue() < 0 ) {
raiseValidateError("In rand statement, can only assign rows a long " +
"(integer) value >= 0 -- attempted to assign value: " + rowsExpr.toString(), conditional);
}
rowsLong = UtilFunctions.toLong(Math.floor(((DoubleIdentifier) rowsExpr).getValue()));
}
else if( rowsExpr instanceof DataIdentifier && !(rowsExpr instanceof IndexedIdentifier) ) {
// check if the DataIdentifier variable is a ConstIdentifier
String identifierName = ((DataIdentifier) rowsExpr).getName();
if( currConstVars.containsKey(identifierName) ) {
// handle int constant
ConstIdentifier constValue = currConstVars.get(identifierName);
if( constValue instanceof IntIdentifier ) {
// check rows is >= 1 --- throw exception
if( ((IntIdentifier) constValue).getValue() < 0 ) {
raiseValidateError("In rand statement, can only assign rows a long " +
"(integer) value >= 0 -- attempted to assign value: " + constValue.toString(), conditional);
}
// update row expr with new IntIdentifier
long roundedValue = ((IntIdentifier) constValue).getValue();
rowsExpr = new IntIdentifier(roundedValue, this);
addVarParam(RAND_ROWS, rowsExpr);
rowsLong = roundedValue;
}
// handle double constant
else if( constValue instanceof DoubleIdentifier ) {
if( ((DoubleIdentifier) constValue).getValue() < 0 ) {
raiseValidateError("In rand statement, can only assign rows a long " +
"(double) value >= 0 -- attempted to assign value: " + constValue.toString(), conditional);
}
// update row expr with new IntIdentifier (rounded down)
long roundedValue = Double.valueOf(Math.floor(((DoubleIdentifier) constValue).getValue())).longValue();
rowsExpr = new IntIdentifier(roundedValue, this);
addVarParam(RAND_ROWS, rowsExpr);
rowsLong = roundedValue;
}
else {
// exception -- rows must be integer or double constant
raiseValidateError("In rand statement, can only assign rows a long " +
"(integer) value >= 0 -- attempted to assign value: " + constValue.toString(), conditional);
}
}
else {
// handle general expression
rowsExpr.validateExpression(ids, currConstVars, conditional);
}
}
else {
// handle general expression
rowsExpr.validateExpression(ids, currConstVars, conditional);
}
///////////////////////////////////////////////////////////////////
// HANDLE COLUMNS
///////////////////////////////////////////////////////////////////
if( colsExpr instanceof IntIdentifier ) {
if( ((IntIdentifier) colsExpr).getValue() < 0 ) {
raiseValidateError("In rand statement, can only assign cols a long " +
"(integer) value >= 0 -- attempted to assign value: " + colsExpr.toString(), conditional);
}
colsLong = ((IntIdentifier) colsExpr).getValue();
}
else if( colsExpr instanceof DoubleIdentifier ) {
if( ((DoubleIdentifier) colsExpr).getValue() < 0 ) {
raiseValidateError("In rand statement, can only assign cols a long " +
"(integer) value >= 0 -- attempted to assign value: " + colsExpr.toString(), conditional);
}
colsLong = Double.valueOf((Math.floor(((DoubleIdentifier) colsExpr).getValue()))).longValue();
}
else if( colsExpr instanceof DataIdentifier && !(colsExpr instanceof IndexedIdentifier) ) {
// check if the DataIdentifier variable is a ConstIdentifier
String identifierName = ((DataIdentifier) colsExpr).getName();
if( currConstVars.containsKey(identifierName) ) {
// handle int constant
ConstIdentifier constValue = currConstVars.get(identifierName);
if( constValue instanceof IntIdentifier ) {
if( ((IntIdentifier) constValue).getValue() < 0 ) {
raiseValidateError("In rand statement, can only assign cols a long " +
"(integer) value >= 0 -- attempted to assign value: " + constValue.toString(), conditional);
}
// update col expr with new IntIdentifier
long roundedValue = ((IntIdentifier) constValue).getValue();
colsExpr = new IntIdentifier(roundedValue, this);
addVarParam(RAND_COLS, colsExpr);
colsLong = roundedValue;
}
// handle double constant
else if( constValue instanceof DoubleIdentifier ) {
if( ((DoubleIdentifier) constValue).getValue() < 0 ) {
raiseValidateError("In rand statement, can only assign cols a long " +
"(double) value >= 0 -- attempted to assign value: " + constValue.toString(), conditional);
}
// update col expr with new IntIdentifier (rounded down)
long roundedValue = Double.valueOf(Math.floor(((DoubleIdentifier) constValue).getValue())).longValue();
colsExpr = new IntIdentifier(roundedValue, this);
addVarParam(RAND_COLS, colsExpr);
colsLong = roundedValue;
}
else {
// exception -- rows must be integer or double constant
raiseValidateError("In rand statement, can only assign cols a long " +
"(integer) value >= 0 -- attempted to assign value: " + constValue.toString(), conditional);
}
}
else {
// handle general expression
colsExpr.validateExpression(ids, currConstVars, conditional);
}
}
else {
// handle general expression
colsExpr.validateExpression(ids, currConstVars, conditional);
}
}
///////////////////////////////////////////////////////////////////
// HANDLE MIN
///////////////////////////////////////////////////////////////////
Expression minExpr = getVarParam(RAND_MIN);
// perform constant propogation
if (minExpr instanceof DataIdentifier && !(minExpr instanceof IndexedIdentifier)) {
// check if the DataIdentifier variable is a ConstIdentifier
String identifierName = ((DataIdentifier)minExpr).getName();
if (currConstVars.containsKey(identifierName)){
// handle int constant
ConstIdentifier constValue = currConstVars.get(identifierName);
if (constValue instanceof IntIdentifier){
// update min expr with new IntIdentifier
long roundedValue = ((IntIdentifier)constValue).getValue();
minExpr = new DoubleIdentifier(roundedValue, this);
addVarParam(RAND_MIN, minExpr);
}
// handle double constant
else if (constValue instanceof DoubleIdentifier){
// update col expr with new IntIdentifier (rounded down)
double roundedValue = ((DoubleIdentifier)constValue).getValue();
minExpr = new DoubleIdentifier(roundedValue, this);
addVarParam(RAND_MIN, minExpr);
}
else {
// exception -- rows must be integer or double constant
raiseValidateError("In rand statement, can only assign min a numerical " +
"value -- attempted to assign: " + constValue.toString(), conditional);
}
}
else {
// handle general expression
minExpr.validateExpression(ids, currConstVars, conditional);
}
}
else {
// handle general expression
minExpr.validateExpression(ids, currConstVars, conditional);
}
///////////////////////////////////////////////////////////////////
// HANDLE MAX
///////////////////////////////////////////////////////////////////
Expression maxExpr = getVarParam(RAND_MAX);
// perform constant propogation
if (maxExpr instanceof DataIdentifier && !(maxExpr instanceof IndexedIdentifier)) {
// check if the DataIdentifier variable is a ConstIdentifier
String identifierName = ((DataIdentifier)maxExpr).getName();
if (currConstVars.containsKey(identifierName)) {
// handle int constant
ConstIdentifier constValue = currConstVars.get(identifierName);
if (constValue instanceof IntIdentifier) {
// update min expr with new IntIdentifier
long roundedValue = ((IntIdentifier)constValue).getValue();
maxExpr = new DoubleIdentifier(roundedValue, this);
addVarParam(RAND_MAX, maxExpr);
}
// handle double constant
else if (constValue instanceof DoubleIdentifier) {
// update col expr with new IntIdentifier (rounded down)
double roundedValue = ((DoubleIdentifier)constValue).getValue();
maxExpr = new DoubleIdentifier(roundedValue, this);
addVarParam(RAND_MAX, maxExpr);
}
else {
// exception -- rows must be integer or double constant
raiseValidateError("In rand statement, can only assign max a numerical " +
"value -- attempted to assign: " + constValue.toString(), conditional);
}
}
else {
// handle general expression
maxExpr.validateExpression(ids, currConstVars, conditional);
}
}
else {
// handle general expression
maxExpr.validateExpression(ids, currConstVars, conditional);
}
getOutput().setFileFormat(FileFormat.BINARY);
if (isTensorOperation) {
getOutput().setDataType(DataType.TENSOR);
getOutput().setValueType(getVarParam(RAND_MIN).getOutput().getValueType());
// TODO set correct dimensions
getOutput().setDimensions(-1, -1);
} else {
getOutput().setDataType(DataType.MATRIX);
getOutput().setValueType(ValueType.FP64);
getOutput().setDimensions(rowsLong, colsLong);
}
if (getOutput() instanceof IndexedIdentifier){
// process the "target" being indexed
DataIdentifier targetAsSeen = ids.get(((DataIdentifier)getOutput()).getName());
if (targetAsSeen == null){
raiseValidateError("cannot assign value to indexed identifier " + ((DataIdentifier)getOutput()).getName() + " without first initializing " + ((DataIdentifier)getOutput()).getName(), conditional);
}
//_output.setProperties(targetAsSeen);
((IndexedIdentifier) getOutput()).setOriginalDimensions(targetAsSeen.getDim1(), targetAsSeen.getDim2());
//((IndexedIdentifier) getOutput()).setOriginalDimensions(getOutput().getDim1(), getOutput().getDim2());
}
if (getOutput() instanceof IndexedIdentifier){
LOG.warn(this.printWarningLocation() + "Output for Rand Statement may have incorrect size information");
}
break;
case MATRIX:
//handle default and input arguments
setMatrixDefault();
validateParams(conditional, RESHAPE_VALID_PARAM_NAMES,
"Legal parameters for matrix statement are (case-sensitive): "
+ RAND_DATA + ", " + RAND_ROWS + ", " + RAND_COLS + ", " + RAND_BY_ROW);
//validate correct value types
if (getVarParam(RAND_DATA) != null && (getVarParam(RAND_DATA) instanceof BooleanIdentifier)){
raiseValidateError("for matrix statement " + RAND_DATA + " has incorrect value type", conditional);
}
if (getVarParam(RAND_ROWS) != null && (getVarParam(RAND_ROWS) instanceof StringIdentifier || getVarParam(RAND_ROWS) instanceof BooleanIdentifier)){
raiseValidateError("for matrix statement " + RAND_ROWS + " has incorrect value type", conditional);
}
if (getVarParam(RAND_COLS) != null && (getVarParam(RAND_COLS) instanceof StringIdentifier || getVarParam(RAND_COLS) instanceof BooleanIdentifier)){
raiseValidateError("for matrix statement " + RAND_COLS + " has incorrect value type", conditional);
}
if ( !(getVarParam(RAND_BY_ROW) instanceof BooleanIdentifier)) {
raiseValidateError("for matrix statement " + RAND_BY_ROW + " has incorrect value type", conditional);
}
//validate general data expression
getVarParam(RAND_DATA).validateExpression(ids, currConstVars, conditional);
rowsLong = -1L;
colsLong = -1L;
///////////////////////////////////////////////////////////////////
// HANDLE ROWS
///////////////////////////////////////////////////////////////////
rowsExpr = getVarParam(RAND_ROWS);
if (rowsExpr != null){
if (rowsExpr instanceof IntIdentifier) {
if (((IntIdentifier)rowsExpr).getValue() >= 1 ) {
rowsLong = ((IntIdentifier)rowsExpr).getValue();
}
else {
raiseValidateError("In matrix statement, can only assign rows a long " +
"(integer) value >= 1 -- attempted to assign value: " + ((IntIdentifier)rowsExpr).getValue(), conditional);
}
}
else if (rowsExpr instanceof DoubleIdentifier) {
if (((DoubleIdentifier)rowsExpr).getValue() >= 1 ) {
rowsLong = Double.valueOf((Math.floor(((DoubleIdentifier)rowsExpr).getValue()))).longValue();
}
else {
raiseValidateError("In matrix statement, can only assign rows a long " +
"(integer) value >= 1 -- attempted to assign value: " + rowsExpr.toString(), conditional);
}
}
else if (rowsExpr instanceof DataIdentifier && !(rowsExpr instanceof IndexedIdentifier)) {
// check if the DataIdentifier variable is a ConstIdentifier
String identifierName = ((DataIdentifier)rowsExpr).getName();
if (currConstVars.containsKey(identifierName)){
// handle int constant
ConstIdentifier constValue = currConstVars.get(identifierName);
if (constValue instanceof IntIdentifier){
// check rows is >= 1 --- throw exception
if (((IntIdentifier)constValue).getValue() < 1){
raiseValidateError("In matrix statement, can only assign rows a long " +
"(integer) value >= 1 -- attempted to assign value: " + constValue.toString(), conditional);
}
// update row expr with new IntIdentifier
long roundedValue = ((IntIdentifier)constValue).getValue();
rowsExpr = new IntIdentifier(roundedValue, this);
addVarParam(RAND_ROWS, rowsExpr);
rowsLong = roundedValue;
}
// handle double constant
else if (constValue instanceof DoubleIdentifier){
if (((DoubleIdentifier)constValue).getValue() < 1.0){
raiseValidateError("In matrix statement, can only assign rows a long " +
"(integer) value >= 1 -- attempted to assign value: " + constValue.toString(), conditional);
}
// update row expr with new IntIdentifier (rounded down)
long roundedValue = Double.valueOf(Math.floor(((DoubleIdentifier)constValue).getValue())).longValue();
rowsExpr = new IntIdentifier(roundedValue, this);
addVarParam(RAND_ROWS, rowsExpr);
rowsLong = roundedValue;
}
else {
// exception -- rows must be integer or double constant
raiseValidateError("In matrix statement, can only assign rows a long " +
"(integer) value >= 1 -- attempted to assign value: " + constValue.toString(), conditional);
}
}
else {
// handle general expression
rowsExpr.validateExpression(ids, currConstVars, conditional);
}
}
else {
// handle general expression
rowsExpr.validateExpression(ids, currConstVars, conditional);
}
}
///////////////////////////////////////////////////////////////////
// HANDLE COLUMNS
///////////////////////////////////////////////////////////////////
colsExpr = getVarParam(RAND_COLS);
if (colsExpr != null){
if (colsExpr instanceof IntIdentifier) {
if (((IntIdentifier)colsExpr).getValue() >= 1 ) {
colsLong = ((IntIdentifier)colsExpr).getValue();
}
else {
raiseValidateError("In matrix statement, can only assign cols a long " +
"(integer) value >= 1 -- attempted to assign value: " + colsExpr.toString(), conditional);
}
}
else if (colsExpr instanceof DoubleIdentifier) {
if (((DoubleIdentifier)colsExpr).getValue() >= 1 ) {
colsLong = Double.valueOf((Math.floor(((DoubleIdentifier)colsExpr).getValue()))).longValue();
}
else {
raiseValidateError("In matrix statement, can only assign rows a long " +
"(integer) value >= 1 -- attempted to assign value: " + colsExpr.toString(), conditional);
}
}
else if (colsExpr instanceof DataIdentifier && !(colsExpr instanceof IndexedIdentifier)) {
// check if the DataIdentifier variable is a ConstIdentifier
String identifierName = ((DataIdentifier)colsExpr).getName();
if (currConstVars.containsKey(identifierName)){
// handle int constant
ConstIdentifier constValue = currConstVars.get(identifierName);
if (constValue instanceof IntIdentifier){
// check cols is >= 1 --- throw exception
if (((IntIdentifier)constValue).getValue() < 1){
raiseValidateError("In matrix statement, can only assign cols a long " +
"(integer) value >= 1 -- attempted to assign value: "
+ constValue.toString(), conditional);
}
// update col expr with new IntIdentifier
long roundedValue = ((IntIdentifier)constValue).getValue();
colsExpr = new IntIdentifier(roundedValue, this);
addVarParam(RAND_COLS, colsExpr);
colsLong = roundedValue;
}
// handle double constant
else if (constValue instanceof DoubleIdentifier){
if (((DoubleIdentifier)constValue).getValue() < 1){
raiseValidateError("In matrix statement, can only assign cols a long " +
"(integer) value >= 1 -- attempted to assign value: "
+ constValue.toString(), conditional);
}
// update col expr with new IntIdentifier (rounded down)
long roundedValue = Double.valueOf(Math.floor(((DoubleIdentifier)constValue).getValue())).longValue();
colsExpr = new IntIdentifier(roundedValue, this);
addVarParam(RAND_COLS, colsExpr);
colsLong = roundedValue;
}
else {
// exception -- rows must be integer or double constant
raiseValidateError("In matrix statement, can only assign cols a long " +
"(integer) value >= 1 -- attempted to assign value: " + constValue.toString(), conditional);
}
}
else {
// handle general expression
colsExpr.validateExpression(ids, currConstVars, conditional);
}
}
else {
// handle general expression
colsExpr.validateExpression(ids, currConstVars, conditional);
}
}
getOutput().setFileFormat(FileFormat.BINARY);
getOutput().setDataType(DataType.MATRIX);
getOutput().setValueType(ValueType.FP64);
getOutput().setDimensions(rowsLong, colsLong);
if (getOutput() instanceof IndexedIdentifier){
((IndexedIdentifier) getOutput()).setOriginalDimensions(getOutput().getDim1(), getOutput().getDim2());
LOG.warn(this.printWarningLocation() + "Output for matrix Statement may have incorrect size information");
}
break;
case FRAME:
//handle default and input arguments
setFrameDefault();
validateParams(conditional, FRAME_VALID_PARAM_NAMES,
"Legal parameters for frame statement are (case-sensitive): "
+ RAND_DATA + ", " + RAND_ROWS + ", " + RAND_COLS + ", " + SCHEMAPARAM);
//validate correct value types
if (getVarParam(RAND_ROWS) != null && (getVarParam(RAND_ROWS) instanceof StringIdentifier || getVarParam(RAND_ROWS) instanceof BooleanIdentifier)){
raiseValidateError("for frame statement " + RAND_ROWS + " has incorrect value type", conditional);
}
if (getVarParam(RAND_COLS) != null && (getVarParam(RAND_COLS) instanceof StringIdentifier || getVarParam(RAND_COLS) instanceof BooleanIdentifier)){
raiseValidateError("for frame statement " + RAND_COLS + " has incorrect value type", conditional);
}
//validate general data expression
getVarParam(RAND_DATA).validateExpression(ids, currConstVars, conditional);
rowsLong = -1L;
colsLong = -1L;
///////////////////////////////////////////////////////////////////
// HANDLE ROWS
///////////////////////////////////////////////////////////////////
rowsExpr = getVarParam(RAND_ROWS);
if (rowsExpr != null){
if (rowsExpr instanceof IntIdentifier) {
if (((IntIdentifier)rowsExpr).getValue() >= 1 )
rowsLong = ((IntIdentifier)rowsExpr).getValue();
else
raiseValidateError("In frame statement, can only assign rows a long " +
"(integer) value >= 1 -- attempted to assign value: " + ((IntIdentifier)rowsExpr).getValue(), conditional);
}
else if (rowsExpr instanceof DoubleIdentifier) {
if (((DoubleIdentifier)rowsExpr).getValue() >= 1 )
rowsLong = Double.valueOf((Math.floor(((DoubleIdentifier)rowsExpr).getValue()))).longValue();
else
raiseValidateError("In frame statement, can only assign rows a long " +
"(integer) value >= 1 -- attempted to assign value: " + rowsExpr.toString(), conditional);
}
else if (rowsExpr instanceof DataIdentifier && !(rowsExpr instanceof IndexedIdentifier)) {
// check if the DataIdentifier variable is a ConstIdentifier
String identifierName = ((DataIdentifier)rowsExpr).getName();
if (currConstVars.containsKey(identifierName)){
// handle int constant
ConstIdentifier constValue = currConstVars.get(identifierName);
if (constValue instanceof IntIdentifier){
// check rows is >= 1 --- throw exception
if (((IntIdentifier)constValue).getValue() < 1){
raiseValidateError("In frame statement, can only assign rows a long " +
"(integer) value >= 1 -- attempted to assign value: " + constValue.toString(), conditional);
}
// update row expr with new IntIdentifier
long roundedValue = ((IntIdentifier)constValue).getValue();
rowsExpr = new IntIdentifier(roundedValue, this);
addVarParam(RAND_ROWS, rowsExpr);
rowsLong = roundedValue;
}
// handle double constant
else if (constValue instanceof DoubleIdentifier){
if (((DoubleIdentifier)constValue).getValue() < 1.0){
raiseValidateError("In frame statement, can only assign rows a long " +
"(integer) value >= 1 -- attempted to assign value: " + constValue.toString(), conditional);
}
// update row expr with new IntIdentifier (rounded down)
long roundedValue = Double.valueOf(Math.floor(((DoubleIdentifier)constValue).getValue())).longValue();
rowsExpr = new IntIdentifier(roundedValue, this);
addVarParam(RAND_ROWS, rowsExpr);
rowsLong = roundedValue;
}
else {
// exception -- rows must be integer or double constant
raiseValidateError("In frame statement, can only assign rows a long " +
"(integer) value >= 1 -- attempted to assign value: " + constValue.toString(), conditional);
}
}
else {
// handle general expression
rowsExpr.validateExpression(ids, currConstVars, conditional);
}
}
else {
// handle general expression
rowsExpr.validateExpression(ids, currConstVars, conditional);
}
}
///////////////////////////////////////////////////////////////////
// HANDLE COLUMNS
///////////////////////////////////////////////////////////////////
colsExpr = getVarParam(RAND_COLS);
if (colsExpr != null){
if (colsExpr instanceof IntIdentifier) {
if (((IntIdentifier)colsExpr).getValue() >= 1 )
colsLong = ((IntIdentifier)colsExpr).getValue();
else
raiseValidateError("In frame statement, can only assign cols a long " +
"(integer) value >= 1 -- attempted to assign value: " + colsExpr.toString(), conditional);
}
else if (colsExpr instanceof DoubleIdentifier) {
if (((DoubleIdentifier)colsExpr).getValue() >= 1 )
colsLong = Double.valueOf((Math.floor(((DoubleIdentifier)colsExpr).getValue()))).longValue();
else
raiseValidateError("In frame statement, can only assign rows a long " +
"(integer) value >= 1 -- attempted to assign value: " + colsExpr.toString(), conditional);
}
else if (colsExpr instanceof DataIdentifier && !(colsExpr instanceof IndexedIdentifier)) {
// check if the DataIdentifier variable is a ConstIdentifier
String identifierName = ((DataIdentifier)colsExpr).getName();
if (currConstVars.containsKey(identifierName)){
// handle int constant
ConstIdentifier constValue = currConstVars.get(identifierName);
if (constValue instanceof IntIdentifier){
// check cols is >= 1 --- throw exception
if (((IntIdentifier)constValue).getValue() < 1){
raiseValidateError("In frame statement, can only assign cols a long " +
"(integer) value >= 1 -- attempted to assign value: "
+ constValue.toString(), conditional);
}
// update col expr with new IntIdentifier
long roundedValue = ((IntIdentifier)constValue).getValue();
colsExpr = new IntIdentifier(roundedValue, this);
addVarParam(RAND_COLS, colsExpr);
colsLong = roundedValue;
}
// handle double constant
else if (constValue instanceof DoubleIdentifier){
if (((DoubleIdentifier)constValue).getValue() < 1){
raiseValidateError("In frame statement, can only assign cols a long " +
"(integer) value >= 1 -- attempted to assign value: "
+ constValue.toString(), conditional);
}
// update col expr with new IntIdentifier (rounded down)
long roundedValue = Double.valueOf(Math.floor(((DoubleIdentifier)constValue).getValue())).longValue();
colsExpr = new IntIdentifier(roundedValue, this);
addVarParam(RAND_COLS, colsExpr);
colsLong = roundedValue;
}
else {
// exception -- rows must be integer or double constant
raiseValidateError("In frame statement, can only assign cols a long " +
"(integer) value >= 1 -- attempted to assign value: " + constValue.toString(), conditional);
}
}
else {
// handle general expression
colsExpr.validateExpression(ids, currConstVars, conditional);
}
}
else {
// handle general expression
colsExpr.validateExpression(ids, currConstVars, conditional);
}
}
getOutput().setFileFormat(FileFormat.BINARY);
getOutput().setDataType(DataType.FRAME);
getOutput().setValueType(ValueType.UNKNOWN);
getOutput().setDimensions(rowsLong, colsLong);
if (getOutput() instanceof IndexedIdentifier){
((IndexedIdentifier) getOutput()).setOriginalDimensions(getOutput().getDim1(), getOutput().getDim2());
LOG.warn(this.printWarningLocation() + "Output for frame Statement may have incorrect size information");
}
break;
case TENSOR:
//handle default and input arguments
setTensorDefault();
validateParams(conditional, RESHAPE_VALID_PARAM_NAMES,
"Legal parameters for tensor statement are (case-sensitive): "
+ RAND_DATA + ", " + RAND_DIMS + ", " + RAND_BY_ROW);
//validate correct value types
/*if (getVarParam(RAND_DATA) != null && (getVarParam(RAND_DATA) instanceof BooleanIdentifier)){
raiseValidateError("for tensor statement " + RAND_DATA + " has incorrect value type", conditional);
}*/
if (getVarParam(RAND_DIMS) != null && (getVarParam(RAND_DIMS) instanceof BooleanIdentifier)){
raiseValidateError("for tensor statement " + RAND_DIMS + " has incorrect value type", conditional);
}
if ( !(getVarParam(RAND_BY_ROW) instanceof BooleanIdentifier)) {
raiseValidateError("for tensor statement " + RAND_BY_ROW + " has incorrect value type", conditional);
}
//validate general data expression
getVarParam(RAND_DATA).validateExpression(ids, currConstVars, conditional);
getVarParam(RAND_DIMS).validateExpression(ids, currConstVars, conditional);
getOutput().setFileFormat(FileFormat.BINARY);
getOutput().setDataType(DataType.TENSOR);
getOutput().setValueType(getVarParam(RAND_DATA).getOutput().getValueType());
// TODO get size
getOutput().setDimensions(-1, -1);
if (getOutput() instanceof IndexedIdentifier){
((IndexedIdentifier) getOutput()).setOriginalDimensions(getOutput().getDim1(), getOutput().getDim2());
}
//getOutput().computeDataType();
if (getOutput() instanceof IndexedIdentifier){
LOG.warn(this.printWarningLocation() + "Output for tensor Statement may have incorrect size information");
}
break;
case SQL:
//handle default and input arguments
setSqlDefault();
validateParams(conditional, SQL_VALID_PARAM_NAMES,
"Legal parameters for tensor statement are (case-sensitive): " + SQL_CONN + ", " +
SQL_USER + ", " + SQL_PASS + ", " + SQL_QUERY);
//validate correct value types
Expression exp = getVarParam(SQL_CONN);
if( !(exp instanceof StringIdentifier) && exp instanceof Identifier ) {
raiseValidateError("for tensor statement " + SQL_CONN + " has incorrect value type", conditional);
}
exp = getVarParam(SQL_USER);
if( !(exp instanceof StringIdentifier) && exp instanceof Identifier ) {
raiseValidateError("for tensor statement " + SQL_USER + " has incorrect value type", conditional);
}
exp = getVarParam(SQL_PASS);
if( !(exp instanceof StringIdentifier) && exp instanceof Identifier ) {
raiseValidateError("for tensor statement " + SQL_PASS + " has incorrect value type", conditional);
}
exp = getVarParam(SQL_QUERY);
if( !(exp instanceof StringIdentifier) && exp instanceof Identifier ) {
raiseValidateError("for tensor statement " + SQL_QUERY + " has incorrect value type", conditional);
}
//validate general data expression
getVarParam(SQL_CONN).validateExpression(ids, currConstVars, conditional);
getVarParam(SQL_USER).validateExpression(ids, currConstVars, conditional);
getVarParam(SQL_PASS).validateExpression(ids, currConstVars, conditional);
getVarParam(SQL_QUERY).validateExpression(ids, currConstVars, conditional);
getOutput().setFileFormat(FileFormat.BINARY);
getOutput().setDataType(DataType.TENSOR);
getOutput().setValueType(ValueType.UNKNOWN);
getOutput().setDimensions(-1, -1);
if (getOutput() instanceof IndexedIdentifier){
LOG.warn(this.printWarningLocation() + "Output for sql statement may have incorrect size information");
}
break;
case FEDERATED:
validateParams(conditional, FEDERATED_VALID_PARAM_NAMES,
"Legal parameters for federated statement are (case-sensitive): "
+ FED_TYPE + ", " + FED_ADDRESSES + ", " + FED_RANGES);
exp = getVarParam(FED_ADDRESSES);
if( !(exp instanceof DataIdentifier) ) {
raiseValidateError("for federated statement " + FED_ADDRESSES + " has incorrect value type", conditional);
}
getVarParam(FED_ADDRESSES).validateExpression(ids, currConstVars, conditional);
exp = getVarParam(FED_RANGES);
if( !(exp instanceof DataIdentifier) ) {
raiseValidateError("for federated statement " + FED_RANGES + " has incorrect value type", conditional);
}
getVarParam(FED_RANGES).validateExpression(ids, currConstVars, conditional);
exp = getVarParam(FED_TYPE);
if( !(exp instanceof StringIdentifier) ) {
raiseValidateError("for federated statement " + FED_TYPE + " has incorrect value type", conditional);
}
getVarParam(FED_TYPE).validateExpression(ids, currConstVars, conditional);
getOutput().setFileFormat(FileFormat.BINARY);
StringIdentifier fedType = (StringIdentifier) exp;
if(fedType.getValue().equalsIgnoreCase(FED_MATRIX_IDENTIFIER)) {
getOutput().setDataType(DataType.MATRIX);
// TODO value type for federated object
getOutput().setValueType(ValueType.FP64);
}
else if(fedType.getValue().equalsIgnoreCase(FED_FRAME_IDENTIFIER)) {
getOutput().setDataType(DataType.FRAME);
}
if(_varParams.size() == 4) {
exp = getVarParam(FED_LOCAL_OBJECT);
if( !(exp instanceof DataIdentifier) ) {
raiseValidateError("for federated statement " + FED_LOCAL_OBJECT + " has incorrect value type", conditional);
}
getVarParam(FED_LOCAL_OBJECT).validateExpression(ids, currConstVars, conditional);
}
getOutput().setDimensions(-1, -1);
break;
default:
raiseValidateError("Unsupported Data expression "+ this.getOpCode(), false, LanguageErrorCodes.INVALID_PARAMETERS); //always unconditional
}
}