diff --git a/MatFileHandler/DataElementConverter.cs b/MatFileHandler/DataElementConverter.cs
index 1a1e252..3a52952 100755
--- a/MatFileHandler/DataElementConverter.cs
+++ b/MatFileHandler/DataElementConverter.cs
@@ -33,8 +33,8 @@ namespace MatFileHandler
             DataElement data,
             DataElement imaginaryData)
         {
-            var realParts = DataExtraction.GetDataAsDouble(data).ToArrayLazily();
-            var imaginaryParts = DataExtraction.GetDataAsDouble(imaginaryData).ToArrayLazily();
+            var realParts = DataExtraction.GetDataAsDouble(data);
+            var imaginaryParts = DataExtraction.GetDataAsDouble(imaginaryData);
             if (realParts == null)
             {
                 throw new HandlerException("Couldn't read sparse array.");
@@ -111,7 +111,7 @@ namespace MatFileHandler
         {
             if (flags.Variable.HasFlag(Variable.IsLogical))
             {
-                var data = DataExtraction.GetDataAsUInt8(realData).ToArrayLazily().Select(x => x != 0).ToArray();
+                var data = DataExtraction.GetDataAsUInt8(realData).Select(x => x != 0).ToArray();
                 return new MatNumericalArrayOf<bool>(flags, dimensions, name, data);
             }
             switch (flags.Class)
@@ -163,7 +163,7 @@ namespace MatFileHandler
             string name,
             MiNum<byte> dataElement)
         {
-            var data = dataElement?.Data;
+            var data = dataElement.Data;
             return new MatCharArrayOf<byte>(flags, dimensions, name, data, Encoding.UTF8.GetString(data));
         }
 
@@ -172,25 +172,25 @@ namespace MatFileHandler
             switch (arrayType)
             {
                 case ArrayType.MxDouble:
-                    return DataExtraction.GetDataAsDouble(data).ToArrayLazily() as T[];
+                    return DataExtraction.GetDataAsDouble(data) as T[];
                 case ArrayType.MxSingle:
-                    return DataExtraction.GetDataAsSingle(data).ToArrayLazily() as T[];
+                    return DataExtraction.GetDataAsSingle(data) as T[];
                 case ArrayType.MxInt8:
-                    return DataExtraction.GetDataAsInt8(data).ToArrayLazily() as T[];
+                    return DataExtraction.GetDataAsInt8(data) as T[];
                 case ArrayType.MxUInt8:
-                    return DataExtraction.GetDataAsUInt8(data).ToArrayLazily() as T[];
+                    return DataExtraction.GetDataAsUInt8(data) as T[];
                 case ArrayType.MxInt16:
-                    return DataExtraction.GetDataAsInt16(data).ToArrayLazily() as T[];
+                    return DataExtraction.GetDataAsInt16(data) as T[];
                 case ArrayType.MxUInt16:
-                    return DataExtraction.GetDataAsUInt16(data).ToArrayLazily() as T[];
+                    return DataExtraction.GetDataAsUInt16(data) as T[];
                 case ArrayType.MxInt32:
-                    return DataExtraction.GetDataAsInt32(data).ToArrayLazily() as T[];
+                    return DataExtraction.GetDataAsInt32(data) as T[];
                 case ArrayType.MxUInt32:
-                    return DataExtraction.GetDataAsUInt32(data).ToArrayLazily() as T[];
+                    return DataExtraction.GetDataAsUInt32(data) as T[];
                 case ArrayType.MxInt64:
-                    return DataExtraction.GetDataAsInt64(data).ToArrayLazily() as T[];
+                    return DataExtraction.GetDataAsInt64(data) as T[];
                 case ArrayType.MxUInt64:
-                    return DataExtraction.GetDataAsUInt64(data).ToArrayLazily() as T[];
+                    return DataExtraction.GetDataAsUInt64(data) as T[];
                 default:
                     throw new NotSupportedException();
             }
@@ -200,12 +200,12 @@ namespace MatFileHandler
         {
             if (isLogical)
             {
-                return DataExtraction.GetDataAsUInt8(data).ToArrayLazily().Select(x => x != 0).ToArray() as T[];
+                return DataExtraction.GetDataAsUInt8(data).Select(x => x != 0).ToArray() as T[];
             }
             switch (data)
             {
                 case MiNum<double> _:
-                    return DataExtraction.GetDataAsDouble(data).ToArrayLazily() as T[];
+                    return DataExtraction.GetDataAsDouble(data) as T[];
                 default:
                     throw new NotSupportedException();
             }
diff --git a/MatFileHandler/DataExtraction.cs b/MatFileHandler/DataExtraction.cs
index d5d9edd..a975acc 100755
--- a/MatFileHandler/DataExtraction.cs
+++ b/MatFileHandler/DataExtraction.cs
@@ -1,8 +1,6 @@
 // Copyright 2017-2018 Alexander Luzgarev
 
 using System;
-using System.Collections.Generic;
-using System.Linq;
 
 namespace MatFileHandler
 {
@@ -11,45 +9,33 @@ namespace MatFileHandler
     /// </summary>
     internal static class DataExtraction
     {
-        /// <summary>
-        /// Convert IEnumerable to array.
-        /// </summary>
-        /// <typeparam name="T">Element type.</typeparam>
-        /// <param name="somethingEnumerable">Input IEnumerable.</param>
-        /// <returns>An equivalent array.</returns>
-        /// <remarks>In contrast to the stanard ToArray() method, this doesn't create a copy if the input already was an array.</remarks>
-        public static T[] ToArrayLazily<T>(this IEnumerable<T> somethingEnumerable)
-        {
-            return somethingEnumerable as T[] ?? somethingEnumerable.ToArray();
-        }
-
         /// <summary>
         /// Convert the contents of the Matlab data element to a sequence of Double values.
         /// </summary>
         /// <param name="element">Data element.</param>
         /// <returns>Contents of the elements, converted to Double.</returns>
-        public static IEnumerable<double> GetDataAsDouble(DataElement element)
+        public static double[] GetDataAsDouble(DataElement element)
         {
             switch (element)
             {
                 case MiNum<sbyte> sbyteElement:
-                    return sbyteElement.Data.Select(Convert.ToDouble);
+                    return SbyteToDouble(sbyteElement.Data);
                 case MiNum<byte> byteElement:
-                    return byteElement.Data.Select(Convert.ToDouble);
+                    return ByteToDouble(byteElement.Data);
                 case MiNum<int> intElement:
-                    return intElement.Data.Select(Convert.ToDouble);
+                    return IntToDouble(intElement.Data);
                 case MiNum<uint> uintElement:
-                    return uintElement.Data.Select(Convert.ToDouble);
+                    return UintToDouble(uintElement.Data);
                 case MiNum<short> shortElement:
-                    return shortElement.Data.Select(Convert.ToDouble);
+                    return ShortToDouble(shortElement.Data);
                 case MiNum<ushort> ushortElement:
-                    return ushortElement.Data.Select(Convert.ToDouble);
+                    return UshortToDouble(ushortElement.Data);
                 case MiNum<long> longElement:
-                    return longElement.Data.Select(Convert.ToDouble);
+                    return LongToDouble(longElement.Data);
                 case MiNum<ulong> ulongElement:
-                    return ulongElement.Data.Select(Convert.ToDouble);
+                    return UlongToDouble(ulongElement.Data);
                 case MiNum<float> floatElement:
-                    return floatElement.Data.Select(Convert.ToDouble);
+                    return FloatToDouble(floatElement.Data);
                 case MiNum<double> doubleElement:
                     return doubleElement.Data;
             }
@@ -62,30 +48,30 @@ namespace MatFileHandler
         /// </summary>
         /// <param name="element">Data element.</param>
         /// <returns>Contents of the elements, converted to Single.</returns>
-        public static IEnumerable<float> GetDataAsSingle(DataElement element)
+        public static float[] GetDataAsSingle(DataElement element)
         {
             switch (element)
             {
                 case MiNum<sbyte> sbyteElement:
-                    return sbyteElement.Data.Select(Convert.ToSingle);
+                    return SbyteToSingle(sbyteElement.Data);
                 case MiNum<byte> byteElement:
-                    return byteElement.Data.Select(Convert.ToSingle);
+                    return ByteToSingle(byteElement.Data);
                 case MiNum<int> intElement:
-                    return intElement.Data.Select(Convert.ToSingle);
+                    return IntToSingle(intElement.Data);
                 case MiNum<uint> uintElement:
-                    return uintElement.Data.Select(Convert.ToSingle);
+                    return UintToSingle(uintElement.Data);
                 case MiNum<short> shortElement:
-                    return shortElement.Data.Select(Convert.ToSingle);
+                    return ShortToSingle(shortElement.Data);
                 case MiNum<ushort> ushortElement:
-                    return ushortElement.Data.Select(Convert.ToSingle);
+                    return UshortToSingle(ushortElement.Data);
                 case MiNum<long> longElement:
-                    return longElement.Data.Select(Convert.ToSingle);
+                    return LongToSingle(longElement.Data);
                 case MiNum<ulong> ulongElement:
-                    return ulongElement.Data.Select(Convert.ToSingle);
+                    return UlongToSingle(ulongElement.Data);
                 case MiNum<float> floatElement:
                     return floatElement.Data;
                 case MiNum<double> doubleElement:
-                    return doubleElement.Data.Select(Convert.ToSingle);
+                    return DoubleToSingle(doubleElement.Data);
             }
             throw new HandlerException(
                 $"Expected data element that would be convertible to float, found {element.GetType()}.");
@@ -96,30 +82,30 @@ namespace MatFileHandler
         /// </summary>
         /// <param name="element">Data element.</param>
         /// <returns>Contents of the elements, converted to Int8.</returns>
-        public static IEnumerable<sbyte> GetDataAsInt8(DataElement element)
+        public static sbyte[] GetDataAsInt8(DataElement element)
         {
             switch (element)
             {
                 case MiNum<sbyte> sbyteElement:
                     return sbyteElement.Data;
                 case MiNum<byte> byteElement:
-                    return byteElement.Data.Select(Convert.ToSByte);
+                    return ByteToSByte(byteElement.Data);
                 case MiNum<int> intElement:
-                    return intElement.Data.Select(Convert.ToSByte);
+                    return IntToSByte(intElement.Data);
                 case MiNum<uint> uintElement:
-                    return uintElement.Data.Select(Convert.ToSByte);
+                    return UintToSByte(uintElement.Data);
                 case MiNum<short> shortElement:
-                    return shortElement.Data.Select(Convert.ToSByte);
+                    return ShortToSByte(shortElement.Data);
                 case MiNum<ushort> ushortElement:
-                    return ushortElement.Data.Select(Convert.ToSByte);
+                    return UshortToSByte(ushortElement.Data);
                 case MiNum<long> longElement:
-                    return longElement.Data.Select(Convert.ToSByte);
+                    return LongToSByte(longElement.Data);
                 case MiNum<ulong> ulongElement:
-                    return ulongElement.Data.Select(Convert.ToSByte);
+                    return UlongToSByte(ulongElement.Data);
                 case MiNum<float> floatElement:
-                    return floatElement.Data.Select(Convert.ToSByte);
+                    return SingleToSByte(floatElement.Data);
                 case MiNum<double> doubleElement:
-                    return doubleElement.Data.Select(Convert.ToSByte);
+                    return DoubleToSByte(doubleElement.Data);
             }
             throw new HandlerException(
                 $"Expected data element that would be convertible to int8, found {element.GetType()}.");
@@ -130,30 +116,30 @@ namespace MatFileHandler
         /// </summary>
         /// <param name="element">Data element.</param>
         /// <returns>Contents of the elements, converted to UInt8.</returns>
-        public static IEnumerable<byte> GetDataAsUInt8(DataElement element)
+        public static byte[] GetDataAsUInt8(DataElement element)
         {
             switch (element)
             {
                 case MiNum<sbyte> sbyteElement:
-                    return sbyteElement.Data.Select(Convert.ToByte);
+                    return SbyteToByte(sbyteElement.Data);
                 case MiNum<byte> byteElement:
                     return byteElement.Data;
                 case MiNum<int> intElement:
-                    return intElement.Data.Select(Convert.ToByte);
+                    return IntToByte(intElement.Data);
                 case MiNum<uint> uintElement:
-                    return uintElement.Data.Select(Convert.ToByte);
+                    return UintToByte(uintElement.Data);
                 case MiNum<short> shortElement:
-                    return shortElement.Data.Select(Convert.ToByte);
+                    return ShortToByte(shortElement.Data);
                 case MiNum<ushort> ushortElement:
-                    return ushortElement.Data.Select(Convert.ToByte);
+                    return UshortToByte(ushortElement.Data);
                 case MiNum<long> longElement:
-                    return longElement.Data.Select(Convert.ToByte);
+                    return LongToByte(longElement.Data);
                 case MiNum<ulong> ulongElement:
-                    return ulongElement.Data.Select(Convert.ToByte);
+                    return UlongToByte(ulongElement.Data);
                 case MiNum<float> floatElement:
-                    return floatElement.Data.Select(Convert.ToByte);
+                    return SingleToByte(floatElement.Data);
                 case MiNum<double> doubleElement:
-                    return doubleElement.Data.Select(Convert.ToByte);
+                    return DoubleToByte(doubleElement.Data);
             }
             throw new HandlerException(
                 $"Expected data element that would be convertible to uint8, found {element.GetType()}.");
@@ -164,30 +150,30 @@ namespace MatFileHandler
         /// </summary>
         /// <param name="element">Data element.</param>
         /// <returns>Contents of the elements, converted to Int16.</returns>
-        public static IEnumerable<short> GetDataAsInt16(DataElement element)
+        public static short[] GetDataAsInt16(DataElement element)
         {
             switch (element)
             {
                 case MiNum<sbyte> sbyteElement:
-                    return sbyteElement.Data.Select(Convert.ToInt16);
+                    return SbyteToInt16(sbyteElement.Data);
                 case MiNum<byte> byteElement:
-                    return byteElement.Data.Select(Convert.ToInt16);
+                    return ByteToInt16(byteElement.Data);
                 case MiNum<int> intElement:
-                    return intElement.Data.Select(Convert.ToInt16);
+                    return IntToInt16(intElement.Data);
                 case MiNum<uint> uintElement:
-                    return uintElement.Data.Select(Convert.ToInt16);
+                    return UintToInt16(uintElement.Data);
                 case MiNum<short> shortElement:
                     return shortElement.Data;
                 case MiNum<ushort> ushortElement:
-                    return ushortElement.Data.Select(Convert.ToInt16);
+                    return UshortToInt16(ushortElement.Data);
                 case MiNum<long> longElement:
-                    return longElement.Data.Select(Convert.ToInt16);
+                    return LongToInt16(longElement.Data);
                 case MiNum<ulong> ulongElement:
-                    return ulongElement.Data.Select(Convert.ToInt16);
+                    return UlongToInt16(ulongElement.Data);
                 case MiNum<float> floatElement:
-                    return floatElement.Data.Select(Convert.ToInt16);
+                    return SingleToInt16(floatElement.Data);
                 case MiNum<double> doubleElement:
-                    return doubleElement.Data.Select(Convert.ToInt16);
+                    return DoubleToInt16(doubleElement.Data);
             }
             throw new HandlerException(
                 $"Expected data element that would be convertible to int16, found {element.GetType()}.");
@@ -198,30 +184,30 @@ namespace MatFileHandler
         /// </summary>
         /// <param name="element">Data element.</param>
         /// <returns>Contents of the elements, converted to UInt16.</returns>
-        public static IEnumerable<ushort> GetDataAsUInt16(DataElement element)
+        public static ushort[] GetDataAsUInt16(DataElement element)
         {
             switch (element)
             {
                 case MiNum<sbyte> sbyteElement:
-                    return sbyteElement.Data.Select(Convert.ToUInt16);
+                    return SbyteToUInt16(sbyteElement.Data);
                 case MiNum<byte> byteElement:
-                    return byteElement.Data.Select(Convert.ToUInt16);
+                    return ByteToUInt16(byteElement.Data);
                 case MiNum<int> intElement:
-                    return intElement.Data.Select(Convert.ToUInt16);
+                    return IntToUInt16(intElement.Data);
                 case MiNum<uint> uintElement:
-                    return uintElement.Data.Select(Convert.ToUInt16);
+                    return UintToUInt16(uintElement.Data);
                 case MiNum<short> shortElement:
-                    return shortElement.Data.Select(Convert.ToUInt16);
+                    return ShortToUInt16(shortElement.Data);
                 case MiNum<ushort> ushortElement:
                     return ushortElement.Data;
                 case MiNum<long> longElement:
-                    return longElement.Data.Select(Convert.ToUInt16);
+                    return LongToUInt16(longElement.Data);
                 case MiNum<ulong> ulongElement:
-                    return ulongElement.Data.Select(Convert.ToUInt16);
+                    return UlongToUInt16(ulongElement.Data);
                 case MiNum<float> floatElement:
-                    return floatElement.Data.Select(Convert.ToUInt16);
+                    return SingleToUInt16(floatElement.Data);
                 case MiNum<double> doubleElement:
-                    return doubleElement.Data.Select(Convert.ToUInt16);
+                    return DoubleToUInt16(doubleElement.Data);
             }
             throw new HandlerException(
                 $"Expected data element that would be convertible to uint16, found {element.GetType()}.");
@@ -232,30 +218,30 @@ namespace MatFileHandler
         /// </summary>
         /// <param name="element">Data element.</param>
         /// <returns>Contents of the elements, converted to Int32.</returns>
-        public static IEnumerable<int> GetDataAsInt32(DataElement element)
+        public static int[] GetDataAsInt32(DataElement element)
         {
             switch (element)
             {
                 case MiNum<sbyte> sbyteElement:
-                    return sbyteElement.Data.Select(Convert.ToInt32);
+                    return SbyteToInt32(sbyteElement.Data);
                 case MiNum<byte> byteElement:
-                    return byteElement.Data.Select(Convert.ToInt32);
+                    return ByteToInt32(byteElement.Data);
                 case MiNum<int> intElement:
                     return intElement.Data;
                 case MiNum<uint> uintElement:
-                    return uintElement.Data.Select(Convert.ToInt32);
+                    return UintToInt32(uintElement.Data);
                 case MiNum<short> shortElement:
-                    return shortElement.Data.Select(Convert.ToInt32);
+                    return ShortToInt32(shortElement.Data);
                 case MiNum<ushort> ushortElement:
-                    return ushortElement.Data.Select(Convert.ToInt32);
+                    return UshortToInt32(ushortElement.Data);
                 case MiNum<long> longElement:
-                    return longElement.Data.Select(Convert.ToInt32);
+                    return LongToInt32(longElement.Data);
                 case MiNum<ulong> ulongElement:
-                    return ulongElement.Data.Select(Convert.ToInt32);
+                    return UlongToInt32(ulongElement.Data);
                 case MiNum<float> floatElement:
-                    return floatElement.Data.Select(Convert.ToInt32);
+                    return SingleToInt32(floatElement.Data);
                 case MiNum<double> doubleElement:
-                    return doubleElement.Data.Select(Convert.ToInt32);
+                    return DoubleToInt32(doubleElement.Data);
             }
             throw new HandlerException(
                 $"Expected data element that would be convertible to int32, found {element.GetType()}.");
@@ -266,30 +252,30 @@ namespace MatFileHandler
         /// </summary>
         /// <param name="element">Data element.</param>
         /// <returns>Contents of the elements, converted to UInt32.</returns>
-        public static IEnumerable<uint> GetDataAsUInt32(DataElement element)
+        public static uint[] GetDataAsUInt32(DataElement element)
         {
             switch (element)
             {
                 case MiNum<sbyte> sbyteElement:
-                    return sbyteElement.Data.Select(Convert.ToUInt32);
+                    return SbyteToUInt32(sbyteElement.Data);
                 case MiNum<byte> byteElement:
-                    return byteElement.Data.Select(Convert.ToUInt32);
+                    return ByteToUInt32(byteElement.Data);
                 case MiNum<int> intElement:
-                    return intElement.Data.Select(Convert.ToUInt32);
+                    return IntToUInt32(intElement.Data);
                 case MiNum<uint> uintElement:
                     return uintElement.Data;
                 case MiNum<short> shortElement:
-                    return shortElement.Data.Select(Convert.ToUInt32);
+                    return ShortToUInt32(shortElement.Data);
                 case MiNum<ushort> ushortElement:
-                    return ushortElement.Data.Select(Convert.ToUInt32);
+                    return UshortToUInt32(ushortElement.Data);
                 case MiNum<long> longElement:
-                    return longElement.Data.Select(Convert.ToUInt32);
+                    return LongToUInt32(longElement.Data);
                 case MiNum<ulong> ulongElement:
-                    return ulongElement.Data.Select(Convert.ToUInt32);
+                    return UlongToUInt32(ulongElement.Data);
                 case MiNum<float> floatElement:
-                    return floatElement.Data.Select(Convert.ToUInt32);
+                    return SingleToUInt32(floatElement.Data);
                 case MiNum<double> doubleElement:
-                    return doubleElement.Data.Select(Convert.ToUInt32);
+                    return DoubleToUInt32(doubleElement.Data);
             }
             throw new HandlerException(
                 $"Expected data element that would be convertible to uint32, found {element.GetType()}.");
@@ -300,30 +286,30 @@ namespace MatFileHandler
         /// </summary>
         /// <param name="element">Data element.</param>
         /// <returns>Contents of the elements, converted to Int64.</returns>
-        public static IEnumerable<long> GetDataAsInt64(DataElement element)
+        public static long[] GetDataAsInt64(DataElement element)
         {
             switch (element)
             {
                 case MiNum<sbyte> sbyteElement:
-                    return sbyteElement.Data.Select(Convert.ToInt64);
+                    return SbyteToInt64(sbyteElement.Data);
                 case MiNum<byte> byteElement:
-                    return byteElement.Data.Select(Convert.ToInt64);
+                    return ByteToInt64(byteElement.Data);
                 case MiNum<int> intElement:
-                    return intElement.Data.Select(Convert.ToInt64);
+                    return IntToInt64(intElement.Data);
                 case MiNum<uint> uintElement:
-                    return uintElement.Data.Select(Convert.ToInt64);
+                    return UintToInt64(uintElement.Data);
                 case MiNum<short> shortElement:
-                    return shortElement.Data.Select(Convert.ToInt64);
+                    return ShortToInt64(shortElement.Data);
                 case MiNum<ushort> ushortElement:
-                    return ushortElement.Data.Select(Convert.ToInt64);
+                    return UshortToInt64(ushortElement.Data);
                 case MiNum<long> longElement:
                     return longElement.Data;
                 case MiNum<ulong> ulongElement:
-                    return ulongElement.Data.Select(Convert.ToInt64);
+                    return UlongToInt64(ulongElement.Data);
                 case MiNum<float> floatElement:
-                    return floatElement.Data.Select(Convert.ToInt64);
+                    return SingleToInt64(floatElement.Data);
                 case MiNum<double> doubleElement:
-                    return doubleElement.Data.Select(Convert.ToInt64);
+                    return DoubleToInt64(doubleElement.Data);
             }
             throw new HandlerException(
                 $"Expected data element that would be convertible to int64, found {element.GetType()}.");
@@ -334,33 +320,1033 @@ namespace MatFileHandler
         /// </summary>
         /// <param name="element">Data element.</param>
         /// <returns>Contents of the elements, converted to UInt64.</returns>
-        public static IEnumerable<ulong> GetDataAsUInt64(DataElement element)
+        public static ulong[] GetDataAsUInt64(DataElement element)
         {
             switch (element)
             {
                 case MiNum<sbyte> sbyteElement:
-                    return sbyteElement.Data.Select(Convert.ToUInt64);
+                    return SbyteToUInt64(sbyteElement.Data);
                 case MiNum<byte> byteElement:
-                    return byteElement.Data.Select(Convert.ToUInt64);
+                    return ByteToUInt64(byteElement.Data);
                 case MiNum<int> intElement:
-                    return intElement.Data.Select(Convert.ToUInt64);
+                    return IntToUInt64(intElement.Data);
                 case MiNum<uint> uintElement:
-                    return uintElement.Data.Select(Convert.ToUInt64);
+                    return UintToUInt64(uintElement.Data);
                 case MiNum<short> shortElement:
-                    return shortElement.Data.Select(Convert.ToUInt64);
+                    return ShortToUInt64(shortElement.Data);
                 case MiNum<ushort> ushortElement:
-                    return ushortElement.Data.Select(Convert.ToUInt64);
+                    return UshortToUInt64(ushortElement.Data);
                 case MiNum<long> longElement:
-                    return longElement.Data.Select(Convert.ToUInt64);
+                    return LongToUInt64(longElement.Data);
                 case MiNum<ulong> ulongElement:
                     return ulongElement.Data;
                 case MiNum<float> floatElement:
-                    return floatElement.Data.Select(Convert.ToUInt64);
+                    return SingleToUInt64(floatElement.Data);
                 case MiNum<double> doubleElement:
-                    return doubleElement.Data.Select(Convert.ToUInt64);
+                    return DoubleToUInt64(doubleElement.Data);
             }
             throw new HandlerException(
                 $"Expected data element that would be convertible to uint64, found {element.GetType()}.");
         }
+
+        // * to double
+        private static double[] SbyteToDouble(sbyte[] source)
+        {
+            var result = new double[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToDouble(source[i]);
+            }
+
+            return result;
+        }
+
+        private static double[] ByteToDouble(byte[] source)
+        {
+            var result = new double[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToDouble(source[i]);
+            }
+
+            return result;
+        }
+
+        private static double[] ShortToDouble(short[] source)
+        {
+            var result = new double[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToDouble(source[i]);
+            }
+
+            return result;
+        }
+
+        private static double[] UshortToDouble(ushort[] source)
+        {
+            var result = new double[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToDouble(source[i]);
+            }
+
+            return result;
+        }
+
+        private static double[] IntToDouble(int[] source)
+        {
+            var result = new double[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToDouble(source[i]);
+            }
+
+            return result;
+        }
+
+        private static double[] UintToDouble(uint[] source)
+        {
+            var result = new double[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToDouble(source[i]);
+            }
+
+            return result;
+        }
+
+        private static double[] LongToDouble(long[] source)
+        {
+            var result = new double[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToDouble(source[i]);
+            }
+
+            return result;
+        }
+
+        private static double[] UlongToDouble(ulong[] source)
+        {
+            var result = new double[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToDouble(source[i]);
+            }
+
+            return result;
+        }
+
+        private static double[] FloatToDouble(float[] source)
+        {
+            var result = new double[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToDouble(source[i]);
+            }
+
+            return result;
+        }
+
+        // * to single
+        private static float[] SbyteToSingle(sbyte[] source)
+        {
+            var result = new float[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSingle(source[i]);
+            }
+
+            return result;
+        }
+
+        private static float[] ByteToSingle(byte[] source)
+        {
+            var result = new float[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSingle(source[i]);
+            }
+
+            return result;
+        }
+
+        private static float[] ShortToSingle(short[] source)
+        {
+            var result = new float[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSingle(source[i]);
+            }
+
+            return result;
+        }
+
+        private static float[] UshortToSingle(ushort[] source)
+        {
+            var result = new float[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSingle(source[i]);
+            }
+
+            return result;
+        }
+
+        private static float[] IntToSingle(int[] source)
+        {
+            var result = new float[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSingle(source[i]);
+            }
+
+            return result;
+        }
+
+        private static float[] UintToSingle(uint[] source)
+        {
+            var result = new float[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSingle(source[i]);
+            }
+
+            return result;
+        }
+
+        private static float[] LongToSingle(long[] source)
+        {
+            var result = new float[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSingle(source[i]);
+            }
+
+            return result;
+        }
+
+        private static float[] UlongToSingle(ulong[] source)
+        {
+            var result = new float[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSingle(source[i]);
+            }
+
+            return result;
+        }
+
+        private static float[] DoubleToSingle(double[] source)
+        {
+            var result = new float[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSingle(source[i]);
+            }
+
+            return result;
+        }
+
+        // * to sbyte
+        private static sbyte[] ByteToSByte(byte[] source)
+        {
+            var result = new sbyte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static sbyte[] ShortToSByte(short[] source)
+        {
+            var result = new sbyte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static sbyte[] UshortToSByte(ushort[] source)
+        {
+            var result = new sbyte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static sbyte[] IntToSByte(int[] source)
+        {
+            var result = new sbyte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static sbyte[] UintToSByte(uint[] source)
+        {
+            var result = new sbyte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static sbyte[] LongToSByte(long[] source)
+        {
+            var result = new sbyte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static sbyte[] UlongToSByte(ulong[] source)
+        {
+            var result = new sbyte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static sbyte[] SingleToSByte(float[] source)
+        {
+            var result = new sbyte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static sbyte[] DoubleToSByte(double[] source)
+        {
+            var result = new sbyte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToSByte(source[i]);
+            }
+
+            return result;
+        }
+
+        // * to byte
+        private static byte[] SbyteToByte(sbyte[] source)
+        {
+            var result = new byte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static byte[] SingleToByte(float[] source)
+        {
+            var result = new byte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static byte[] ShortToByte(short[] source)
+        {
+            var result = new byte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static byte[] UshortToByte(ushort[] source)
+        {
+            var result = new byte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static byte[] IntToByte(int[] source)
+        {
+            var result = new byte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static byte[] UintToByte(uint[] source)
+        {
+            var result = new byte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static byte[] LongToByte(long[] source)
+        {
+            var result = new byte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static byte[] UlongToByte(ulong[] source)
+        {
+            var result = new byte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToByte(source[i]);
+            }
+
+            return result;
+        }
+
+        private static byte[] DoubleToByte(double[] source)
+        {
+            var result = new byte[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToByte(source[i]);
+            }
+
+            return result;
+        }
+
+        // * to int16
+        private static short[] SbyteToInt16(sbyte[] source)
+        {
+            var result = new short[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static short[] ByteToInt16(byte[] source)
+        {
+            var result = new short[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static short[] UshortToInt16(ushort[] source)
+        {
+            var result = new short[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static short[] IntToInt16(int[] source)
+        {
+            var result = new short[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static short[] UintToInt16(uint[] source)
+        {
+            var result = new short[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static short[] LongToInt16(long[] source)
+        {
+            var result = new short[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static short[] UlongToInt16(ulong[] source)
+        {
+            var result = new short[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static short[] SingleToInt16(float[] source)
+        {
+            var result = new short[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static short[] DoubleToInt16(double[] source)
+        {
+            var result = new short[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        // * to uint16
+        private static ushort[] SbyteToUInt16(sbyte[] source)
+        {
+            var result = new ushort[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ushort[] ByteToUInt16(byte[] source)
+        {
+            var result = new ushort[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ushort[] ShortToUInt16(short[] source)
+        {
+            var result = new ushort[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ushort[] IntToUInt16(int[] source)
+        {
+            var result = new ushort[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ushort[] UintToUInt16(uint[] source)
+        {
+            var result = new ushort[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ushort[] LongToUInt16(long[] source)
+        {
+            var result = new ushort[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ushort[] UlongToUInt16(ulong[] source)
+        {
+            var result = new ushort[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ushort[] SingleToUInt16(float[] source)
+        {
+            var result = new ushort[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ushort[] DoubleToUInt16(double[] source)
+        {
+            var result = new ushort[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt16(source[i]);
+            }
+
+            return result;
+        }
+
+        // * to int32
+        private static int[] SbyteToInt32(sbyte[] source)
+        {
+            var result = new int[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static int[] ByteToInt32(byte[] source)
+        {
+            var result = new int[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static int[] ShortToInt32(short[] source)
+        {
+            var result = new int[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static int[] UshortToInt32(ushort[] source)
+        {
+            var result = new int[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static int[] UintToInt32(uint[] source)
+        {
+            var result = new int[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static int[] LongToInt32(long[] source)
+        {
+            var result = new int[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static int[] UlongToInt32(ulong[] source)
+        {
+            var result = new int[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static int[] SingleToInt32(float[] source)
+        {
+            var result = new int[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static int[] DoubleToInt32(double[] source)
+        {
+            var result = new int[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        // * to uint32
+        private static uint[] SbyteToUInt32(sbyte[] source)
+        {
+            var result = new uint[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static uint[] ByteToUInt32(byte[] source)
+        {
+            var result = new uint[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static uint[] ShortToUInt32(short[] source)
+        {
+            var result = new uint[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static uint[] UshortToUInt32(ushort[] source)
+        {
+            var result = new uint[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static uint[] IntToUInt32(int[] source)
+        {
+            var result = new uint[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static uint[] LongToUInt32(long[] source)
+        {
+            var result = new uint[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static uint[] UlongToUInt32(ulong[] source)
+        {
+            var result = new uint[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static uint[] SingleToUInt32(float[] source)
+        {
+            var result = new uint[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        private static uint[] DoubleToUInt32(double[] source)
+        {
+            var result = new uint[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt32(source[i]);
+            }
+
+            return result;
+        }
+
+        // * to int64
+        private static long[] SbyteToInt64(sbyte[] source)
+        {
+            var result = new long[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static long[] ByteToInt64(byte[] source)
+        {
+            var result = new long[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static long[] ShortToInt64(short[] source)
+        {
+            var result = new long[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static long[] UshortToInt64(ushort[] source)
+        {
+            var result = new long[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static long[] IntToInt64(int[] source)
+        {
+            var result = new long[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static long[] UintToInt64(uint[] source)
+        {
+            var result = new long[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static long[] UlongToInt64(ulong[] source)
+        {
+            var result = new long[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static long[] SingleToInt64(float[] source)
+        {
+            var result = new long[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static long[] DoubleToInt64(double[] source)
+        {
+            var result = new long[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        // * to uint64
+        private static ulong[] SbyteToUInt64(sbyte[] source)
+        {
+            var result = new ulong[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ulong[] ByteToUInt64(byte[] source)
+        {
+            var result = new ulong[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ulong[] ShortToUInt64(short[] source)
+        {
+            var result = new ulong[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ulong[] UshortToUInt64(ushort[] source)
+        {
+            var result = new ulong[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ulong[] IntToUInt64(int[] source)
+        {
+            var result = new ulong[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ulong[] UintToUInt64(uint[] source)
+        {
+            var result = new ulong[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ulong[] LongToUInt64(long[] source)
+        {
+            var result = new ulong[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ulong[] SingleToUInt64(float[] source)
+        {
+            var result = new ulong[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt64(source[i]);
+            }
+
+            return result;
+        }
+
+        private static ulong[] DoubleToUInt64(double[] source)
+        {
+            var result = new ulong[source.Length];
+            for (var i = 0; i < source.Length; i++)
+            {
+                result[i] = Convert.ToUInt64(source[i]);
+            }
+
+            return result;
+        }
     }
 }
\ No newline at end of file