public void TestOldSavingAndLoading()
        {
            var data = new[] { new TestClass()
                               {
                                   A = 1, B = new int[2] {
                                       1, 4
                                   }
                               },
                               new TestClass()
                               {
                                   A = 2, B = new int[2] {
                                       3, 4
                                   }
                               } };
            var dataView = ComponentCreation.CreateDataView(Env, data);
            var pipe     = new ConvertingEstimator(Env, columns: new[] { new ConvertingTransform.ColumnInfo("A", "ConvA", DataKind.R8),
                                                                         new ConvertingTransform.ColumnInfo("B", "ConvB", DataKind.R8) });

            var result      = pipe.Fit(dataView).Transform(dataView);
            var resultRoles = new RoleMappedData(result);

            using (var ms = new MemoryStream())
            {
                TrainUtils.SaveModel(Env, Env.Start("saving"), ms, null, resultRoles);
                ms.Position = 0;
                var loadedView = ModelFileUtils.LoadTransforms(Env, dataView, ms);
            }
        }
        public void TestConvertWorkout()
        {
            var data = new[] { new TestClass()
                               {
                                   A = 1, B = new int[2] {
                                       1, 4
                                   }
                               },
                               new TestClass()
                               {
                                   A = 2, B = new int[2] {
                                       3, 4
                                   }
                               } };
            var dataView = ComponentCreation.CreateDataView(Env, data);
            var pipe     = new ConvertingEstimator(Env, columns: new[] { new ConvertingTransform.ColumnInfo("A", "ConvA", DataKind.R4),
                                                                         new ConvertingTransform.ColumnInfo("B", "ConvB", DataKind.R4) });

            TestEstimatorCore(pipe, dataView);
            var allTypesData = new[]
            {
                new TestPrimitiveClass()
                {
                    AA = new [] { "a", "b" },
                    AB = new [] { false, true },
                    AC = new [] { -1, 1 },
                    AD = new uint[] { 0, 1 },
                    AE = new byte[] { 0, 1 },
                    AF = new sbyte[] { -1, 1 },
                    AG = new short[] { -1, 1 },
                    AH = new ushort[] { 0, 1 },
                    AK = new long[] { -1, 1 },
                    AL = new ulong[] { 0, 1 },
                    AM = new float[] { 1.0f, 1.0f, },
                    AN = new double[] { 1.0d, 1.0d, }
                },
                new TestPrimitiveClass()
                {
                    AA = new [] { "0", "1" },
                    AB = new [] { false, true },
                    AC = new [] { int.MinValue, int.MaxValue },
                    AD = new uint[] { uint.MinValue, uint.MaxValue },
                    AE = new byte[] { byte.MinValue, byte.MaxValue },
                    AF = new sbyte[] { sbyte.MinValue, sbyte.MaxValue },
                    AG = new short[] { short.MinValue, short.MaxValue },
                    AH = new ushort[] { ushort.MinValue, ushort.MaxValue },
                    AK = new long[] { long.MinValue, long.MaxValue },
                    AL = new ulong[] { ulong.MinValue, ulong.MaxValue },
                    AM = new float[] { float.MinValue, float.MaxValue, },
                    AN = new double[] { double.MinValue, double.MaxValue, }
                }
            };

            var allTypesDataView = ComponentCreation.CreateDataView(Env, allTypesData);
            var allTypesPipe     = new ConvertingEstimator(Env, columns: new[] {
                new ConvertingTransform.ColumnInfo("AA", "ConvA", DataKind.R4),
                new ConvertingTransform.ColumnInfo("AB", "ConvB", DataKind.R4),
                new ConvertingTransform.ColumnInfo("AC", "ConvC", DataKind.R4),
                new ConvertingTransform.ColumnInfo("AD", "ConvD", DataKind.R4),
                new ConvertingTransform.ColumnInfo("AE", "ConvE", DataKind.R4),
                new ConvertingTransform.ColumnInfo("AF", "ConvF", DataKind.R4),
                new ConvertingTransform.ColumnInfo("AG", "ConvG", DataKind.R4),
                new ConvertingTransform.ColumnInfo("AH", "ConvH", DataKind.R4),
                new ConvertingTransform.ColumnInfo("AK", "ConvK", DataKind.R4),
                new ConvertingTransform.ColumnInfo("AL", "ConvL", DataKind.R4),
                new ConvertingTransform.ColumnInfo("AM", "ConvM", DataKind.R4),
                new ConvertingTransform.ColumnInfo("AN", "ConvN", DataKind.R4)
            }
                                                           );

            TestEstimatorCore(allTypesPipe, allTypesDataView);

            var outputPath = GetOutputPath("Convert", "Types.tsv");

            using (var ch = Env.Start("save"))
            {
                var saver = new TextSaver(Env, new TextSaver.Arguments {
                    Silent = true
                });
                var savedData = TakeFilter.Create(Env, allTypesPipe.Fit(allTypesDataView).Transform(allTypesDataView), 2);
                using (var fs = File.Create(outputPath))
                    DataSaverUtils.SaveDataView(ch, saver, savedData, fs, keepHidden: true);
            }

            CheckEquality("Convert", "Types.tsv");
            Done();
        }