Example #1
0
        private static T[]? ConvertDataToSparseProperType <T>(DataElement data, bool isLogical)
        {
            if (isLogical)
            {
                return(DataExtraction.GetDataAsUInt8(data).Select(x => x != 0).ToArray() as T[]);
            }
            switch (data)
            {
            case MiNum <double> _:
                return(DataExtraction.GetDataAsDouble(data) as T[]);

            default:
                throw new NotSupportedException();
            }
        }
Example #2
0
        private static T[] ConvertDataToProperType <T>(DataElement data, ArrayType arrayType)
        {
            switch (arrayType)
            {
            case ArrayType.MxDouble:
                return(DataExtraction.GetDataAsDouble(data).ToArrayLazily() as T[]);

            case ArrayType.MxSingle:
                return(DataExtraction.GetDataAsSingle(data).ToArrayLazily() as T[]);

            case ArrayType.MxInt8:
                return(DataExtraction.GetDataAsInt8(data).ToArrayLazily() as T[]);

            case ArrayType.MxUInt8:
                return(DataExtraction.GetDataAsUInt8(data).ToArrayLazily() as T[]);

            case ArrayType.MxInt16:
                return(DataExtraction.GetDataAsInt16(data).ToArrayLazily() as T[]);

            case ArrayType.MxUInt16:
                return(DataExtraction.GetDataAsUInt16(data).ToArrayLazily() as T[]);

            case ArrayType.MxInt32:
                return(DataExtraction.GetDataAsInt32(data).ToArrayLazily() as T[]);

            case ArrayType.MxUInt32:
                return(DataExtraction.GetDataAsUInt32(data).ToArrayLazily() as T[]);

            case ArrayType.MxInt64:
                return(DataExtraction.GetDataAsInt64(data).ToArrayLazily() as T[]);

            case ArrayType.MxUInt64:
                return(DataExtraction.GetDataAsUInt64(data).ToArrayLazily() as T[]);

            default:
                throw new NotSupportedException();
            }
        }
Example #3
0
        /// <summary>
        /// Construct a complex sparse array.
        /// </summary>
        /// <param name="flags">Array flags.</param>
        /// <param name="dimensions">Array dimensions.</param>
        /// <param name="name">Array name.</param>
        /// <param name="rowIndex">Row indices.</param>
        /// <param name="columnIndex">Denotes index ranges for each column.</param>
        /// <param name="data">Real parts of the values.</param>
        /// <param name="imaginaryData">Imaginary parts of the values.</param>
        /// <returns>A constructed array.</returns>
        public static MatArray ConvertToMatSparseArrayOfComplex(
            SparseArrayFlags flags,
            int[] dimensions,
            string name,
            int[] rowIndex,
            int[] columnIndex,
            DataElement data,
            DataElement imaginaryData)
        {
            var realParts      = DataExtraction.GetDataAsDouble(data);
            var imaginaryParts = DataExtraction.GetDataAsDouble(imaginaryData);

            if (realParts == null)
            {
                throw new HandlerException("Couldn't read sparse array.");
            }
            var dataDictionary =
                ConvertMatlabSparseToDictionary(
                    rowIndex,
                    columnIndex,
                    j => new Complex(realParts[j], imaginaryParts[j]));

            return(new MatSparseArrayOf <Complex>(flags, dimensions, name, dataDictionary));
        }