Beispiel #1
0
        /// <summary>
        /// Constructor which takes .NET array
        /// dtype and shape is determined from array
        /// </summary>
        /// <param name="values"></param>
        /// <returns>Array with values</returns>
        public NDArray(Array values, Shape shape = null) : this(values.GetType().GetElementType())
        {
            int[] strgDim = new int[values.Rank];

            for (int idx = 0; idx < strgDim.Length; idx++)
            {
                strgDim[idx] = values.GetLength(idx);
            }

            Storage = new NDStorage(dtype);
            Storage.Allocate(dtype, new Shape(strgDim));

            switch (values.Rank)
            {
            case 1:
            {
                Storage.SetData(values);
                break;
            }
            }

            if (!(shape is null))
            {
                Storage.Reshape(shape);
            }
        }
Beispiel #2
0
        public void FromMultiDimArray(Array dotNetArray)
        {
            if (dotNetArray.GetType().GetElementType().IsArray)
            {
                throw new Exception("Jagged arrays are not allowed here!");
            }

            int[] dims = new int[dotNetArray.Rank];

            for (int idx = 0; idx < dims.Length; idx++)
            {
                dims[idx] = dotNetArray.GetLength(idx);
            }

            Storage = new NDStorage();
            Storage.Allocate(dotNetArray.GetType().GetElementType(), new Shape(dims));

            Array internalStrg = Storage.GetData();

            var pufferShape = new Shape(dims);

            pufferShape.ChangeTensorLayout();

            int[]  idxDims  = null;
            object valueIdx = null;

            for (int idx = 0; idx < Storage.Shape.Size; idx++)
            {
                idxDims  = pufferShape.GetDimIndexOutShape(idx);
                valueIdx = dotNetArray.GetValue(pufferShape.GetDimIndexOutShape(idx));
                internalStrg.SetValue(valueIdx, Storage.Shape.GetIndexInShape(idxDims));
            }
        }
Beispiel #3
0
        public StorageTester()
        {
            strg1D = new NDStorage(np.float64);
            strg1D.Allocate(np.float64, new Shape(10), 1);
            strg1D.SetData(new double[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });

            strg2D = new NDStorage(np.int64);
            strg2D.Allocate(np.int64, new Shape(3, 3), 1);
            strg2D.SetData(new Int64[] { 0, 1, 2, 3, 4, 5, 6, 7, 8 });

            strg2DNonFull = new NDStorage(np.float32);
            strg2DNonFull.Allocate(np.float32, new Shape(5, 2), 1);
            strg2DNonFull.SetData(new float[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 });

            strg3D = new NDStorage(typeof(Complex));
            strg3D.Allocate(typeof(Complex), new Shape(2, 2, 2));
            strg3D.SetData(new Complex[] { 1, 2, 3, 4, 5, 6, 7, 8 });

            strg3DNonFull = new NDStorage(typeof(Complex));
            strg3DNonFull.Allocate(typeof(Complex), new Shape(2, 3, 4));
            var puffer = new Complex[24];

            for (int idx = 1; idx < 25; idx++)
            {
                puffer[idx - 1] = new Complex(idx, 0);
            }

            strg3DNonFull.SetData(puffer);
        }
Beispiel #4
0
        //[TestMethod]
        public void CheckChangeTensorLayout2D()
        {
            var strg2DCpy = (NDStorage)strg2D.Clone();

            Assert.IsTrue(Enumerable.SequenceEqual(strg2DCpy.Shape.Dimensions, new int[] { 3, 3 }));
            Assert.IsTrue(Enumerable.SequenceEqual(strg2DCpy.GetData <Int64>(), new Int64[] { 0, 3, 6, 1, 4, 7, 2, 5, 8 }));

            Assert.IsTrue(Enumerable.SequenceEqual(strg2DCpy.Shape.Dimensions, new int[] { 3, 3 }));
            Assert.IsTrue(Enumerable.SequenceEqual(strg2DCpy.GetData <Int64>(), strg2D.GetData <Int64>()));

            strg2DCpy = (NDStorage)strg2DNonFull.Clone();

            Assert.IsTrue(Enumerable.SequenceEqual(strg2DCpy.Shape.Dimensions, new int[] { 5, 2 }));
            Assert.IsTrue(Enumerable.SequenceEqual(strg2DCpy.GetData <Int64>(), new Int64[] { 0, 5, 1, 6, 2, 7, 3, 8, 4, 9 }));

            Assert.IsTrue(Enumerable.SequenceEqual(strg2DCpy.Shape.Dimensions, new int[] { 5, 2 }));
            Assert.IsTrue(Enumerable.SequenceEqual(strg2DCpy.GetData <Int64>(), strg2DNonFull.GetData <Int64>()));

            strg2DCpy = new NDStorage(typeof(Int64));
            strg2DCpy.Allocate(new Shape(5, 2));

            strg2DCpy.SetData(strg2DNonFull.GetData());

            Assert.IsTrue(Enumerable.SequenceEqual(strg2DCpy.GetData <Int64>(), new Int64[] { 0, 2, 4, 6, 8, 1, 3, 5, 7, 9 }));
        }
Beispiel #5
0
        /// <summary>
        /// Constructor which takes .NET array
        /// dtype and shape is determined from array
        /// </summary>
        /// <param name="values"></param>
        /// <returns>Array with values</returns>
        public NDArray(Array values, Shape shape = null) : this(values.GetType().GetElementType())
        {
            if (shape is null)
            {
                shape = new Shape(values.Length);
            }

            Storage = new NDStorage(dtype);
            Storage.Allocate(new Shape(shape));
            Storage.SetData(values);
        }
Beispiel #6
0
        public StorageTester()
        {
            Storage1DInt = NDStorage.CreateByShapeAndType(typeof(int), new Shape(6));
            Storage1DInt.SetData(new int[] { 0, 1, 2, 3, 4, 5 });

            Storage1DDouble = NDStorage.CreateByShapeAndType(typeof(double), new Shape(6));
            Storage1DDouble.SetData(new double[] { 0.1, 1.5, 2.2, 3.5, 4.9, 5.0 });

            Storage2DInt = NDStorage.CreateByShapeAndType(typeof(int), new Shape(2, 3));
            Storage2DInt.SetData(new int[] { 0, 1, 2, 3, 4, 5 });
        }
Beispiel #7
0
 /// <summary>
 /// Constructor which initialize elements with 0
 /// type and shape are given.
 /// </summary>
 /// <param name="dtype">internal data type</param>
 /// <param name="shape">Shape of NDArray</param>
 public NDArray(Type dtype, Shape shape)
 {
     TensorEngine = BackendFactory.GetEngine();
     Storage      = new NDStorage(dtype);
     Storage.Allocate(shape);
 }
Beispiel #8
0
        /*public NDArray()
         * {
         *  throw new Exception("Don't use 0 parameter constructor.");
         * }*/

        /// <summary>
        /// Constructor for init data type
        /// internal storage is 1D with 1 element
        /// </summary>
        /// <param name="dtype">Data type of elements</param>
        public NDArray(Type dtype)
        {
            TensorEngine = BackendFactory.GetEngine();
            Storage      = new NDStorage(dtype);
        }
 public NDArray(Shape shape) : this()
 {
     Storage = new NDStorage(typeof(T));
     Storage.Allocate(this.dtype, shape, 1);
 }
Beispiel #10
0
 public NDArray()
 {
     Storage = new NDStorage(typeof(T));
     Storage.Allocate(this.dtype, new Shape(1), 1);
 }
Beispiel #11
0
 public NDArray(Shape shape) : this()
 {
     Storage = NDStorage.CreateByShapeAndType(Storage.dtype, shape);
 }
Beispiel #12
0
 public NDArray()
 {
     Storage.dtype = typeof(T);
     Storage       = NDStorage.CreateByShapeAndType(this.dtype, new Shape(1));
 }
Beispiel #13
0
 /// <summary>
 /// Default constructor
 /// Create a 1D double array with 1 element
 /// one element is 1
 /// </summary>
 public NDArray()
 {
     Storage      = new NDStorage();
     TensorEngine = BackendFactory.GetEngine();
 }