Replace DvInt* with .NET standard data types. WIP

src/Microsoft.ML.Api/ApiUtils.cs

@@ -19,8 +19,7 @@ private static OpCode GetAssignmentOpCode(Type t)
         {
             // REVIEW: This should be a Dictionary<Type, OpCode> based solution.
             // DvTypes, strings, arrays, all nullable types, VBuffers and UInt128.
-            if (t == typeof(DvInt8) || t == typeof(DvInt4) || t == typeof(DvInt2) || t == typeof(DvInt1) ||
-                t == typeof(DvBool) || t == typeof(DvText) || t == typeof(string) || t.IsArray ||
+            if (t == typeof(DvText) || t == typeof(DvBool) || t == typeof(string) || t.IsArray ||
                 (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(VBuffer<>)) ||
                 (t.IsGenericType && t.GetGenericTypeDefinition() == typeof(Nullable<>)) ||
                 t == typeof(DvDateTime) || t == typeof(DvDateTimeZone) || t == typeof(DvTimeSpan) || t == typeof(UInt128))

src/Microsoft.ML.Api/DataViewConstructionUtils.cs

@@ -134,42 +134,22 @@ private Delegate CreateGetter(int index)
                         else if (outputType.GetElementType() == typeof(int))
                         {
                             Ch.Assert(colType.ItemType == NumberType.I4);
-                            return CreateConvertingArrayGetterDelegate<int, DvInt4>(index, x => x);
-                        }
-                        else if (outputType.GetElementType() == typeof(int?))
-                        {
-                            Ch.Assert(colType.ItemType == NumberType.I4);
-                            return CreateConvertingArrayGetterDelegate<int?, DvInt4>(index, x => x ?? DvInt4.NA);
+                            return CreateConvertingArrayGetterDelegate<int, int>(index, x => x);
                         }
                         else if (outputType.GetElementType() == typeof(long))
                         {
                             Ch.Assert(colType.ItemType == NumberType.I8);
-                            return CreateConvertingArrayGetterDelegate<long, DvInt8>(index, x => x);
-                        }
-                        else if (outputType.GetElementType() == typeof(long?))
-                        {
-                            Ch.Assert(colType.ItemType == NumberType.I8);
-                            return CreateConvertingArrayGetterDelegate<long?, DvInt8>(index, x => x ?? DvInt8.NA);
+                            return CreateConvertingArrayGetterDelegate<long, long>(index, x => x);
                         }
                         else if (outputType.GetElementType() == typeof(short))
                         {
                             Ch.Assert(colType.ItemType == NumberType.I2);
-                            return CreateConvertingArrayGetterDelegate<short, DvInt2>(index, x => x);
-                        }
-                        else if (outputType.GetElementType() == typeof(short?))
-                        {
-                            Ch.Assert(colType.ItemType == NumberType.I2);
-                            return CreateConvertingArrayGetterDelegate<short?, DvInt2>(index, x => x ?? DvInt2.NA);
+                            return CreateConvertingArrayGetterDelegate<short, short>(index, x => x);
                         }
                         else if (outputType.GetElementType() == typeof(sbyte))
                         {
                             Ch.Assert(colType.ItemType == NumberType.I1);
-                            return CreateConvertingArrayGetterDelegate<sbyte, DvInt1>(index, x => x);
-                        }
-                        else if (outputType.GetElementType() == typeof(sbyte?))
-                        {
-                            Ch.Assert(colType.ItemType == NumberType.I1);
-                            return CreateConvertingArrayGetterDelegate<sbyte?, DvInt1>(index, x => x ?? DvInt1.NA);
+                            return CreateConvertingArrayGetterDelegate<sbyte, sbyte>(index, x => x);
                         }
                         else if (outputType.GetElementType() == typeof(bool))
                         {
@@ -222,51 +202,27 @@ private Delegate CreateGetter(int index)
                         }
                         else if (outputType == typeof(int))
                         {
-                            // int -> DvInt4
+                            // int -> int
                             Ch.Assert(colType == NumberType.I4);
-                            return CreateConvertingGetterDelegate<int, DvInt4>(index, x => x);
-                        }
-                        else if (outputType == typeof(int?))
-                        {
-                            // int? -> DvInt4
-                            Ch.Assert(colType == NumberType.I4);
-                            return CreateConvertingGetterDelegate<int?, DvInt4>(index, x => x ?? DvInt4.NA);
+                            return CreateConvertingGetterDelegate<int, int>(index, x => x);
                         }
                         else if (outputType == typeof(short))
                         {
-                            // short -> DvInt2
-                            Ch.Assert(colType == NumberType.I2);
-                            return CreateConvertingGetterDelegate<short, DvInt2>(index, x => x);
-                        }
-                        else if (outputType == typeof(short?))
-                        {
-                            // short? -> DvInt2
+                            // short -> short
                             Ch.Assert(colType == NumberType.I2);
-                            return CreateConvertingGetterDelegate<short?, DvInt2>(index, x => x ?? DvInt2.NA);
+                            return CreateConvertingGetterDelegate<short, short>(index, x => x);
                         }
                         else if (outputType == typeof(long))
                         {
-                            // long -> DvInt8
+                            // long -> long
                             Ch.Assert(colType == NumberType.I8);
-                            return CreateConvertingGetterDelegate<long, DvInt8>(index, x => x);
-                        }
-                        else if (outputType == typeof(long?))
-                        {
-                            // long? -> DvInt8
-                            Ch.Assert(colType == NumberType.I8);
-                            return CreateConvertingGetterDelegate<long?, DvInt8>(index, x => x ?? DvInt8.NA);
+                            return CreateConvertingGetterDelegate<long, long>(index, x => x);
                         }
                         else if (outputType == typeof(sbyte))
                         {
-                            // sbyte -> DvInt1
-                            Ch.Assert(colType == NumberType.I1);
-                            return CreateConvertingGetterDelegate<sbyte, DvInt1>(index, x => x);
-                        }
-                        else if (outputType == typeof(sbyte?))
-                        {
-                            // sbyte? -> DvInt1
+                            // sbyte -> sbyte
                             Ch.Assert(colType == NumberType.I1);
-                            return CreateConvertingGetterDelegate<sbyte?, DvInt1>(index, x => x ?? DvInt1.NA);
+                            return CreateConvertingGetterDelegate<sbyte, sbyte>(index, x => x);
                         }
                         // T -> T
                         if (outputType.IsGenericType && outputType.GetGenericTypeDefinition() == typeof(Nullable<>))

src/Microsoft.ML.Api/TypedCursor.cs

@@ -292,42 +292,22 @@ private Action<TRow> GenerateSetter(IRow input, int index, InternalSchemaDefinit
                     else if (fieldType.GetElementType() == typeof(int))
                     {
                         Ch.Assert(colType.ItemType == NumberType.I4);
-                        return CreateConvertingVBufferSetter<DvInt4, int>(input, index, poke, peek, x => (int)x);
-                    }
-                    else if (fieldType.GetElementType() == typeof(int?))
-                    {
-                        Ch.Assert(colType.ItemType == NumberType.I4);
-                        return CreateConvertingVBufferSetter<DvInt4, int?>(input, index, poke, peek, x => (int?)x);
+                        return CreateConvertingVBufferSetter<int, int>(input, index, poke, peek, x => (int)x);
                     }
                     else if (fieldType.GetElementType() == typeof(short))
                     {
                         Ch.Assert(colType.ItemType == NumberType.I2);
-                        return CreateConvertingVBufferSetter<DvInt2, short>(input, index, poke, peek, x => (short)x);
-                    }
-                    else if (fieldType.GetElementType() == typeof(short?))
-                    {
-                        Ch.Assert(colType.ItemType == NumberType.I2);
-                        return CreateConvertingVBufferSetter<DvInt2, short?>(input, index, poke, peek, x => (short?)x);
+                        return CreateConvertingVBufferSetter<short, short>(input, index, poke, peek, x => x);
                     }
                     else if (fieldType.GetElementType() == typeof(long))
                     {
                         Ch.Assert(colType.ItemType == NumberType.I8);
-                        return CreateConvertingVBufferSetter<DvInt8, long>(input, index, poke, peek, x => (long)x);
-                    }
-                    else if (fieldType.GetElementType() == typeof(long?))
-                    {
-                        Ch.Assert(colType.ItemType == NumberType.I8);
-                        return CreateConvertingVBufferSetter<DvInt8, long?>(input, index, poke, peek, x => (long?)x);
+                        return CreateConvertingVBufferSetter<long, long>(input, index, poke, peek, x => x);
                     }
                     else if (fieldType.GetElementType() == typeof(sbyte))
                     {
                         Ch.Assert(colType.ItemType == NumberType.I1);
-                        return CreateConvertingVBufferSetter<DvInt1, sbyte>(input, index, poke, peek, x => (sbyte)x);
-                    }
-                    else if (fieldType.GetElementType() == typeof(sbyte?))
-                    {
-                        Ch.Assert(colType.ItemType == NumberType.I1);
-                        return CreateConvertingVBufferSetter<DvInt1, sbyte?>(input, index, poke, peek, x => (sbyte?)x);
+                        return CreateConvertingVBufferSetter<sbyte, sbyte>(input, index, poke, peek, x => x);
                     }
 
                     // VBuffer<T> -> T[]
@@ -373,49 +353,25 @@ private Action<TRow> GenerateSetter(IRow input, int index, InternalSchemaDefinit
                     {
                         Ch.Assert(colType == NumberType.I4);
                         Ch.Assert(peek == null);
-                        return CreateConvertingActionSetter<DvInt4, int>(input, index, poke, x => (int)x);
-                    }
-                    else if (fieldType == typeof(int?))
-                    {
-                        Ch.Assert(colType == NumberType.I4);
-                        Ch.Assert(peek == null);
-                        return CreateConvertingActionSetter<DvInt4, int?>(input, index, poke, x => (int?)x);
+                        return CreateConvertingActionSetter<int, int>(input, index, poke, x => x);
                     }
                     else if (fieldType == typeof(short))
                     {
                         Ch.Assert(colType == NumberType.I2);
                         Ch.Assert(peek == null);
-                        return CreateConvertingActionSetter<DvInt2, short>(input, index, poke, x => (short)x);
-                    }
-                    else if (fieldType == typeof(short?))
-                    {
-                        Ch.Assert(colType == NumberType.I2);
-                        Ch.Assert(peek == null);
-                        return CreateConvertingActionSetter<DvInt2, short?>(input, index, poke, x => (short?)x);
+                        return CreateConvertingActionSetter<short, short>(input, index, poke, x => x);
                     }
                     else if (fieldType == typeof(long))
                     {
                         Ch.Assert(colType == NumberType.I8);
                         Ch.Assert(peek == null);
-                        return CreateConvertingActionSetter<DvInt8, long>(input, index, poke, x => (long)x);
-                    }
-                    else if (fieldType == typeof(long?))
-                    {
-                        Ch.Assert(colType == NumberType.I8);
-                        Ch.Assert(peek == null);
-                        return CreateConvertingActionSetter<DvInt8, long?>(input, index, poke, x => (long?)x);
+                        return CreateConvertingActionSetter<long, long>(input, index, poke, x => x);
                     }
                     else if (fieldType == typeof(sbyte))
                     {
                         Ch.Assert(colType == NumberType.I1);
                         Ch.Assert(peek == null);
-                        return CreateConvertingActionSetter<DvInt1, sbyte>(input, index, poke, x => (sbyte)x);
-                    }
-                    else if (fieldType == typeof(sbyte?))
-                    {
-                        Ch.Assert(colType == NumberType.I1);
-                        Ch.Assert(peek == null);
-                        return CreateConvertingActionSetter<DvInt1, sbyte?>(input, index, poke, x => (sbyte?)x);
+                        return CreateConvertingActionSetter<sbyte, sbyte>(input, index, poke, x => x);
                     }
                     // T -> T
                     if (fieldType.IsGenericType && fieldType.GetGenericTypeDefinition() == typeof(Nullable<>))

src/Microsoft.ML.Core/CommandLine/CmdParser.cs

@@ -517,23 +517,23 @@ public static int GetConsoleWindowWidth()
 
         private struct Coord
         {
-            internal Int16 X;
-            internal Int16 Y;
+            internal short X;
+            internal short Y;
         }
 
         private struct SmallRect
         {
-            internal Int16 Left;
-            internal Int16 Top;
-            internal Int16 Right;
-            internal Int16 Bottom;
+            internal short Left;
+            internal short Top;
+            internal short Right;
+            internal short Bottom;
         }
 
         private struct ConsoleScreenBufferInfo
         {
             internal Coord DwSize;
             internal Coord DwCursorPosition;
-            internal Int16 WAttributes;
+            internal short WAttributes;
             internal SmallRect SrWindow;
             internal Coord DwMaximumWindowSize;
         }

src/Microsoft.ML.Core/Data/ColumnType.cs

@@ -567,14 +567,18 @@ public static BoolType Instance
             get
             {
                 if (_instance == null)
-                    Interlocked.CompareExchange(ref _instance, new BoolType(), null);
+                    Interlocked.CompareExchange(ref _instance, new BoolType(DataKind.BL, "Bool"), null);
                 return _instance;
             }
         }
 
-        private BoolType()
-            : base(typeof(DvBool), DataKind.BL)
+        private readonly string _name;
+
+        private BoolType(DataKind kind, string name)
+            : base(kind.ToType(), kind)
         {
+            Contracts.AssertNonEmpty(name);
+            _name = name;
         }
 
         public override bool Equals(ColumnType other)
@@ -587,7 +591,7 @@ public override bool Equals(ColumnType other)
 
         public override string ToString()
         {
-            return "Bool";
+            return _name;
         }
     }
 

src/Microsoft.ML.Core/Data/DataKind.cs

@@ -55,7 +55,7 @@ public enum DataKind : byte
     public static class DataKindExtensions
     {
         public const DataKind KindMin = DataKind.I1;
-        public const DataKind KindLim = DataKind.UG + 1;
+        public const DataKind KindLim = DataKind.U16 + 1;
         public const int KindCount = KindLim - KindMin;
 
         /// <summary>
@@ -141,19 +141,19 @@ public static Type ToType(this DataKind kind)
             switch (kind)
             {
                 case DataKind.I1:
-                    return typeof(DvInt1);
+                    return typeof(sbyte);
                 case DataKind.U1:
                     return typeof(byte);
                 case DataKind.I2:
-                    return typeof(DvInt2);
+                    return typeof(short);
                 case DataKind.U2:
                     return typeof(ushort);
                 case DataKind.I4:
-                    return typeof(DvInt4);
+                    return typeof(int);
                 case DataKind.U4:
                     return typeof(uint);
                 case DataKind.I8:
-                    return typeof(DvInt8);
+                    return typeof(long);
                 case DataKind.U8:
                     return typeof(ulong);
                 case DataKind.R4:
@@ -185,25 +185,25 @@ public static bool TryGetDataKind(this Type type, out DataKind kind)
             Contracts.CheckValueOrNull(type);
 
             // REVIEW: Make this more efficient. Should we have a global dictionary?
-            if (type == typeof(DvInt1) || type == typeof(sbyte) || type == typeof(sbyte?))
+            if (type == typeof(sbyte))
                 kind = DataKind.I1;
             else if (type == typeof(byte) || type == typeof(byte?))
                 kind = DataKind.U1;
-            else if (type == typeof(DvInt2)|| type== typeof(short) || type == typeof(short?))
+            else if (type == typeof(short))
                 kind = DataKind.I2;
-            else if (type == typeof(ushort)|| type == typeof(ushort?))
+            else if (type == typeof(ushort) || type == typeof(ushort?))
                 kind = DataKind.U2;
-            else if (type == typeof(DvInt4) || type == typeof(int)|| type == typeof(int?))
+            else if (type == typeof(int))
                 kind = DataKind.I4;
-            else if (type == typeof(uint)|| type == typeof(uint?))
+            else if (type == typeof(uint) || type == typeof(uint?))
                 kind = DataKind.U4;
-            else if (type == typeof(DvInt8) || type==typeof(long)|| type == typeof(long?))
+            else if (type == typeof(long))
                 kind = DataKind.I8;
-            else if (type == typeof(ulong)|| type == typeof(ulong?))
+            else if (type == typeof(ulong) || type == typeof(ulong?))
                 kind = DataKind.U8;
-            else if (type == typeof(Single)|| type == typeof(Single?))
+            else if (type == typeof(Single) || type == typeof(Single?))
                 kind = DataKind.R4;
-            else if (type == typeof(Double)|| type == typeof(Double?))
+            else if (type == typeof(Double) || type == typeof(Double?))
                 kind = DataKind.R8;
             else if (type == typeof(DvText))
                 kind = DataKind.TX;

src/Microsoft.ML.Core/Data/DateTime.cs

@@ -242,7 +242,7 @@ private static DvDateTime ValidateDate(DvDateTime dateTime, ref DvInt2 offset)
             Contracts.Assert(MinMinutesOffset <= offset.RawValue && offset.RawValue <= MaxMinutesOffset);
             var offsetTicks = offset.RawValue * TicksPerMinute;
             // This operation cannot overflow because offset should have already been validated to be within
-            // 14 hours and the DateTime instance is more than that distance from the boundaries of Int64.
+            // 14 hours and the DateTime instance is more than that distance from the boundaries of long.
             long utcTicks = dateTime.Ticks.RawValue - offsetTicks;
             var dvdt = new DvDateTime(utcTicks);
             if (dvdt.IsNA)