AJ-703: support tensor;

Author: chengyitian

src/com/xxdb/data/AbstractTensor.java

@@ -0,0 +1,15 @@
+package com.xxdb.data;
+
+public abstract class AbstractTensor  extends AbstractEntity implements Tensor {
+
+    @Override
+    public DATA_FORM getDataForm() {
+        return DATA_FORM.DF_TENSOR;
+    }
+
+    @Override
+    public int columns() {
+        return 1;
+    }
+
+}

src/com/xxdb/data/BasicEntityFactory.java

@@ -77,6 +77,8 @@ else if(form == Entity.DATA_FORM.DF_SET)
 			return new BasicSet(type, in);
 		else if(form == Entity.DATA_FORM.DF_CHUNK)
 			return new BasicChunkMeta(in);
+		else if (form == Entity.DATA_FORM.DF_TENSOR)
+			return new BasicTensor(type, in);
 		else if(type == Entity.DATA_TYPE.DT_ANY && (form == Entity.DATA_FORM.DF_VECTOR || form == Entity.DATA_FORM.DF_PAIR))
 			return new BasicAnyVector(in);
 		else if(type.getValue() >= Entity.DATA_TYPE.DT_BOOL_ARRAY.getValue() && type.getValue() <= DT_DECIMAL128_ARRAY.getValue())

src/com/xxdb/data/BasicTensor.java

@@ -0,0 +1,169 @@
+package com.xxdb.data;
+
+import com.xxdb.io.ExtendedDataInput;
+import com.xxdb.io.ExtendedDataOutput;
+import java.io.IOException;
+
+public class BasicTensor extends AbstractTensor {
+
+    private DATA_TYPE dataType;
+    private int tensorType;
+    private int deviceType;
+    private int tensorFlags;
+    private int dimensions;
+
+    /**
+     * shapes: shape[i] represents the size of the i-th dimension.
+     */
+    private long[] shapes;
+
+    /**
+     * strides: strides[i] represents the distance between elements in the i-th dimension.
+     */
+    private long[] strides;
+
+    private long preserveValue;
+
+    private long elemCount;
+
+    private Vector data;
+
+    protected BasicTensor(DATA_TYPE dataType, ExtendedDataInput in) throws IOException {
+        deserialize(dataType, in);
+    }
+
+    protected void deserialize(DATA_TYPE dataType, ExtendedDataInput in) throws IOException {
+        this.dataType = dataType;
+        tensorType = in.readByte();
+        deviceType = in.readByte();
+        tensorFlags = in.readInt();
+        dimensions = in.readInt();
+
+        shapes = new long[dimensions];
+        strides = new long[dimensions];
+
+        for (int d = 0; d < dimensions; d++)
+            shapes[d] = in.readLong();
+
+        for (int d = 0; d < dimensions; d++)
+            strides[d] = in.readLong();
+
+        preserveValue = in.readLong();
+        elemCount = in.readLong();
+
+        if (elemCount > Integer.MAX_VALUE)
+            throw new RuntimeException("tensor element count more than 2,147,483,647(Integer.MAX_VALUE).");
+
+        Vector subVector = BasicEntityFactory.instance().createVectorWithDefaultValue(dataType, (int) elemCount, -1);
+        subVector.deserialize(0, (int) elemCount, in);
+        this.data = subVector;
+    }
+
+    @Override
+    public DATA_CATEGORY getDataCategory() {
+        return getDataCategory(dataType);
+    }
+
+    @Override
+    public DATA_TYPE getDataType() {
+        return dataType;
+    }
+
+    @Override
+    public int rows() {
+        return data.rows();
+    }
+
+    @Override
+    public void write(ExtendedDataOutput output) throws IOException {
+        throw new RuntimeException("BasicTensor not support write method.");
+    }
+
+    public int getDimensions() {
+        return dimensions;
+    }
+
+    public long[] getShapes() {
+        return shapes;
+    }
+
+    public long[] getStrides() {
+        return strides;
+    }
+
+    public long getElemCount() {
+        return elemCount;
+    }
+
+    public Vector getData() {
+        return data;
+    }
+
+    @Override
+    public String getString() {
+        StringBuilder sb = new StringBuilder();
+        sb.append("tensor<").append(getDataTypeString());;
+        for (long shape : shapes) {
+            sb.append("[").append(shape).append("]");
+        }
+        sb.append(">(");
+        printTensor(sb, 0, 0, new int[dimensions]);
+        sb.append(")");
+        return sb.toString();
+    }
+
+    private void printTensor(StringBuilder sb, int depth, int index, int[] indices) {
+        if (depth == dimensions) {
+            int flatIndex = getFlatIndex(indices);
+            sb.append(data.get(flatIndex));
+            return;
+        }
+
+        sb.append("[");
+        long size = shapes[depth];
+        for (int i = 0; i < size; i++) {
+            indices[depth] = i;
+            if (depth == dimensions - 1 && size > 5 && i == 5) {
+                sb.append("...");
+                break;
+            } else {
+                if (i > 0) {
+                    sb.append(",");
+                }
+                printTensor(sb, depth + 1, index * (int) size + i, indices);
+            }
+        }
+        sb.append("]");
+    }
+
+    private String getDataTypeString() {
+        switch (dataType) {
+            case DT_BOOL:
+                return "bool";
+            case DT_BYTE:
+                return "char";
+            case DT_SHORT:
+                return "short";
+            case DT_INT:
+                return "int";
+            case DT_LONG:
+                return "long";
+            case DT_FLOAT:
+                return "float";
+            case DT_DOUBLE:
+                return "double";
+            default:
+                throw new IllegalArgumentException("Unsupported data type: " + dataType);
+        }
+    }
+
+    private int getFlatIndex(int[] indices) {
+        int flatIndex = 0;
+        int stride = 1;
+        for (int i = dimensions - 1; i >= 0; i--) {
+            flatIndex += indices[i] * stride;
+            stride *= shapes[i];
+        }
+        return flatIndex;
+    }
+}

src/com/xxdb/data/Entity.java

@@ -64,7 +64,7 @@ public static DATA_TYPE valueOfTypeName(String name){
 	};
 
 	enum DATA_CATEGORY {NOTHING,LOGICAL,INTEGRAL,FLOATING,TEMPORAL,LITERAL,SYSTEM,MIXED,BINARY,ARRAY,DENARY};
-	enum DATA_FORM {DF_SCALAR,DF_VECTOR,DF_PAIR,DF_MATRIX,DF_SET,DF_DICTIONARY,DF_TABLE,DF_CHART,DF_CHUNK,DF_SYSOBJ};
+	enum DATA_FORM {DF_SCALAR,DF_VECTOR,DF_PAIR,DF_MATRIX,DF_SET,DF_DICTIONARY,DF_TABLE,DF_CHART,DF_CHUNK,DF_SYSOBJ,DF_TENSOR};
 	enum PARTITION_TYPE {SEQ, VALUE, RANGE, LIST, COMPO, HASH}
 	enum DURATION {NS, US, MS, SECOND, MINUTE, HOUR, DAY, WEEK, MONTH, YEAR, BDAY, TDAY};
 	DATA_FORM getDataForm();

src/com/xxdb/data/Tensor.java

@@ -0,0 +1,4 @@
+package com.xxdb.data;
+
+public interface Tensor extends Entity {
+}