org.apache.sysml.hops.LiteralOp Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of systemml Show documentation
Show all versions of systemml Show documentation
Declarative Machine Learning
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you under the Apache License, Version 2.0 (the
* "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.apache.sysml.hops;
import org.apache.sysml.lops.Data;
import org.apache.sysml.lops.Lop;
import org.apache.sysml.lops.LopProperties.ExecType;
import org.apache.sysml.lops.LopsException;
import org.apache.sysml.parser.Expression.DataType;
import org.apache.sysml.parser.Expression.ValueType;
import org.apache.sysml.runtime.util.UtilFunctions;
public class LiteralOp extends Hop
{
private double value_double = Double.NaN;
private long value_long = Long.MAX_VALUE;
private String value_string;
private boolean value_boolean;
// INT, DOUBLE, STRING, BOOLEAN
private LiteralOp() {
//default constructor for clone
}
public LiteralOp(double value) {
super(String.valueOf(value), DataType.SCALAR, ValueType.DOUBLE);
this.value_double = value;
}
public LiteralOp(long value) {
super(String.valueOf(value), DataType.SCALAR, ValueType.INT);
this.value_long = value;
}
public LiteralOp(String value) {
super(value, DataType.SCALAR, ValueType.STRING);
this.value_string = value;
}
public LiteralOp(boolean value) {
super(String.valueOf(value), DataType.SCALAR, ValueType.BOOLEAN);
this.value_boolean = value;
}
@Override
public Lop constructLops()
throws HopsException, LopsException
{
//return already created lops
if( getLops() != null )
return getLops();
try
{
Lop l = null;
switch (getValueType()) {
case DOUBLE:
l = Data.createLiteralLop(ValueType.DOUBLE, Double.toString(value_double));
break;
case BOOLEAN:
l = Data.createLiteralLop(ValueType.BOOLEAN, Boolean.toString(value_boolean));
break;
case STRING:
l = Data.createLiteralLop(ValueType.STRING, value_string);
break;
case INT:
l = Data.createLiteralLop(ValueType.INT, Long.toString(value_long));
break;
default:
throw new HopsException(this.printErrorLocation() +
"unexpected value type constructing lops for LiteralOp.\n");
}
l.getOutputParameters().setDimensions(0, 0, 0, 0, -1);
setLineNumbers(l);
setLops(l);
}
catch(LopsException e) {
throw new HopsException(e);
}
//note: no reblock lop because always scalar
return getLops();
}
public void printMe() throws HopsException {
if (LOG.isDebugEnabled()){
if (getVisited() != VisitStatus.DONE) {
super.printMe();
switch (getValueType()) {
case DOUBLE:
LOG.debug(" Value: " + value_double);
break;
case BOOLEAN:
LOG.debug(" Value: " + value_boolean);
break;
case STRING:
LOG.debug(" Value: " + value_string);
break;
case INT:
LOG.debug(" Value: " + value_long);
break;
default:
throw new HopsException(this.printErrorLocation() +
"unexpected value type printing LiteralOp.\n");
}
for (Hop h : getInput()) {
h.printMe();
}
}
setVisited(VisitStatus.DONE);
}
}
@Override
public String getOpString() {
String val = null;
switch (getValueType()) {
case DOUBLE:
val = Double.toString(value_double);
break;
case BOOLEAN:
val = Boolean.toString(value_boolean);
break;
case STRING:
val = value_string;
break;
case INT:
val = Long.toString(value_long);
break;
default:
val = "";
}
return "LiteralOp " + val;
}
@Override
protected double computeOutputMemEstimate( long dim1, long dim2, long nnz )
{
double ret = 0;
switch( getValueType() ) {
case INT:
ret = OptimizerUtils.INT_SIZE; break;
case DOUBLE:
ret = OptimizerUtils.DOUBLE_SIZE; break;
case BOOLEAN:
ret = OptimizerUtils.BOOLEAN_SIZE; break;
case STRING:
ret = this.value_string.length() * OptimizerUtils.CHAR_SIZE; break;
case OBJECT:
ret = OptimizerUtils.DEFAULT_SIZE; break;
default:
ret = 0;
}
return ret;
}
@Override
protected double computeIntermediateMemEstimate( long dim1, long dim2, long nnz )
{
return 0;
}
@Override
protected long[] inferOutputCharacteristics( MemoTable memo )
{
return null;
}
@Override
public boolean allowsAllExecTypes()
{
return false;
}
@Override
protected ExecType optFindExecType() throws HopsException {
// Since a Literal hop does not represent any computation,
// this function is not applicable.
return null;
}
@Override
public void refreshSizeInformation()
{
//do nothing; it is a scalar
}
public long getLongValue() throws HopsException
{
switch( getValueType() ) {
case INT:
return value_long;
case DOUBLE:
return UtilFunctions.toLong(value_double);
case STRING:
return Long.parseLong(value_string);
default:
throw new HopsException("Can not coerce an object of type " + getValueType() + " into Long.");
}
}
public double getDoubleValue() throws HopsException {
switch( getValueType() ) {
case INT:
return value_long;
case DOUBLE:
return value_double;
case STRING:
return Double.parseDouble(value_string);
default:
throw new HopsException("Can not coerce an object of type " + getValueType() + " into Double.");
}
}
public boolean getBooleanValue() throws HopsException {
if ( getValueType() == ValueType.BOOLEAN ) {
return value_boolean;
}
else
throw new HopsException("Can not coerce an object of type " + getValueType() + " into Boolean.");
}
public String getStringValue()
{
switch( getValueType() ) {
case BOOLEAN:
return String.valueOf(value_boolean);
case INT:
return String.valueOf(value_long);
case DOUBLE:
return String.valueOf(value_double);
case STRING:
return value_string;
case OBJECT:
case UNKNOWN:
//do nothing (return null)
}
return null;
}
@Override
public Object clone() throws CloneNotSupportedException
{
LiteralOp ret = new LiteralOp();
//copy generic attributes
ret.clone(this, false);
//copy specific attributes
ret.value_double = value_double;
ret.value_long = value_long;
ret.value_string = value_string;
ret.value_boolean = value_boolean;
return ret;
}
@Override
public boolean compare( Hop that )
{
return false;
}
}