/// <summary>
 /// Construct a grouped output field.
 /// </summary>
 /// <param name="group">The group that this field belongs to.</param>
 /// <param name="sourceField">The source field for this output field.</param>
 protected OutputFieldGrouped(IOutputFieldGroup group,
                           IInputField sourceField)
 {
     _group = group;
     _sourceField = sourceField;
     _group.GroupedFields.Add(this);
 }

 /// <summary>
 /// Create a nominal item.
 /// </summary>
 /// <param name="inputField">The field that this item is based on.</param>
 /// <param name="high">The high value.</param>
 /// <param name="low">The low value.</param>
 public NominalItem(IInputField inputField, double high,
          double low)
 {
     this.high = high;
     this.low = low;
     this.inputField = inputField;
 }

 /// <summary>
 /// Construct a range mapped output field.
 /// </summary>
 /// <param name="field">The input field to base this on.</param>
 /// <param name="low">The low value.</param>
 /// <param name="high">The high value.</param>
 public OutputFieldRangeMapped(IInputField field, double low,
                               double high)
 {
     _field = field;
     _low = low;
     _high = high;
 }

 /// <summary>
 /// Construct a grouped output field.
 /// </summary>
 /// <param name="group">The group that this field belongs to.</param>
 /// <param name="sourceField">The source field for this output field.</param>
 public OutputFieldGrouped(IOutputFieldGroup group,
          IInputField sourceField)
 {
     this.group = group;
     this.sourceField = sourceField;
     this.group.GroupedFields.Add(this);
 }

 /// <summary>
 /// Construct a range mapped output field.
 /// </summary>
 /// <param name="field">The input field to base this on.</param>
 /// <param name="low">The low value.</param>
 /// <param name="high">The high value.</param>
 public OutputFieldRangeMapped(IInputField field, double low,
          double high)
 {
     this.field = field;
     this.low = low;
     this.high = high;
 }

 /// <summary>
 /// Create a nominal item.
 /// </summary>
 /// <param name="inputField">The field that this item is based on.</param>
 /// <param name="high">The high value.</param>
 /// <param name="low">The low value.</param>
 public NominalItem(IInputField inputField, double low,
                    double high)
 {
     _high = high;
     _low = low;
     _inputField = inputField;
 }

 public OutputFieldMultiplicative(IOutputFieldGroup group, IInputField field)
     : base(group, field)
 {
     while (!(group is MultiplicativeGroup))
     {
         throw new NormalizationError("Must use MultiplicativeGroup with OutputFieldMultiplicative.");
     }
 }

 public OutputFieldZAxis(IOutputFieldGroup group, IInputField field)
     : base(group, field)
 {
     while (!(group is ZAxisGroup))
     {
         throw new NormalizationError("Must use ZAxisGroup with OutputFieldZAxis.");
     }
 }

 public void BuildOutputOneOf(DataNormalization norm, IInputField coverType)
 {
     var outType = new OutputOneOf();
     outType.AddItem(coverType, 1);
     outType.AddItem(coverType, 2);
     outType.AddItem(coverType, 3);
     outType.AddItem(coverType, 4);
     outType.AddItem(coverType, 5);
     outType.AddItem(coverType, 6);
     outType.AddItem(coverType, 7);
     norm.AddOutputField(outType, true);
 }

        public void Copy(FileInfo source, FileInfo target, int start, int stop, int size)
        {
            var inputField = new IInputField[55];

            var norm = new DataNormalization {Report = this, Storage = new NormalizationStorageCSV(target.ToString())};
            for (int i = 0; i < 55; i++)
            {
                inputField[i] = new InputFieldCSV(true, source.ToString(), i);
                norm.AddInputField(inputField[i]);
                IOutputField outputField = new OutputFieldDirect(inputField[i]);
                norm.AddOutputField(outputField);
            }

            // load only the part we actually want, i.e. training or eval
            var segregator2 = new IndexSampleSegregator(start, stop, size);
            norm.AddSegregator(segregator2);

            norm.Process();
        }

        public void Narrow(FileInfo source, FileInfo target, int field, int count)
        {
            var inputField = new IInputField[55];

            var norm = new DataNormalization {Report = this, Storage = new NormalizationStorageCSV(target.ToString())};
            for (int i = 0; i < 55; i++)
            {
                inputField[i] = new InputFieldCSV(true, source.ToString(), i);
                norm.AddInputField(inputField[i]);
                IOutputField outputField = new OutputFieldDirect(inputField[i]);
                norm.AddOutputField(outputField);
            }

            var segregator = new IntegerBalanceSegregator(inputField[field], count);
            norm.AddSegregator(segregator);

            norm.Process();
            Console.WriteLine(@"Samples per tree type:");
            Console.WriteLine(segregator.DumpCounts());
        }

        /// <summary>
        /// Called internally to obtain the current value for an input field.
        /// </summary>
        /// <param name="field">The input field to determine.</param>
        /// <param name="index">The current index.</param>
        /// <returns>The value for this input field.</returns>
        private void DetermineInputFieldValue(IInputField field, int index)
        {
            double result;

            if (field is InputFieldCSV)
            {
                var fieldCSV = (InputFieldCSV)field;
                ReadCSV csv = _csvMap[field];
                result = csv.GetDouble(fieldCSV.Offset);

            }
            else if (field is InputFieldMLDataSet)
            {
                var mlField = (InputFieldMLDataSet)field;
                MLDataFieldHolder holder = _dataSetFieldMap
                    [field];
                IMLDataPair pair = holder.Pair;
                int offset = mlField.Offset;
                if (offset < pair.Input.Count)
                {
                    result = pair.Input[offset];
                }
                else
                {
                    offset -= pair.Input.Count;
                    result = pair.Ideal[offset];
                }
            }
            else
            {
                result = field.GetValue(index);
            }

            field.CurrentValue = result;
            return;
        }

 /// <summary>
 /// Construct a balanced segregator.
 /// </summary>
 /// <param name="target">The input field to base this on, should 
 /// be an integer value.</param>
 /// <param name="count">The number of rows to accept from each 
 /// unique value for the input.</param>
 public IntegerBalanceSegregator(IInputField target, int count)
 {
     _target = target;
     _count = count;
 }

 /// <summary>
 /// Construct an encoded field.
 /// </summary>
 /// <param name="sourceField">The field that this is based on.</param>
 public OutputFieldEncode(IInputField sourceField)
 {
     this.sourceField = sourceField;
 }

 /// <summary>
 /// Add an input field.
 /// </summary>
 /// <param name="f">The input field to add.</param>
 public void AddInputField(IInputField f)
 {
     _inputFields.Add(f);
 }

        /// <summary>
        /// Creates a field column in a table.
        /// </summary>
        /// <param name="field">A field object</param>
        /// <param name="tableName">Name of the table.</param>
        public void CreateTableColumn(IInputField field, string tableName)
        {
            if (!dbDriver.ColumnExists(tableName, ((Epi.INamedObject)field).Name))
            {
                string fieldLength = string.Empty;
                string fieldType = field.GetDbSpecificColumnType();
                Query query;

                switch (fieldType)
                {
                    case "nvarchar":
                    case "nchar":
                        fieldLength = "(4000)";
                        break;
                    case "text":
                        fieldLength = "(255)";
                        break;
                    case "double":
                        break;
                    default:
                        break;
                }

                query = dbDriver.CreateQuery("alter table [" + tableName + "] add [" + ((Epi.INamedObject)field).Name + "] " + fieldType + fieldLength);

                dbDriver.ExecuteNonQuery(query);
            }
        }

 /// <summary>
 /// Construct a range segregator.
 /// </summary>
 /// <param name="sourceField">The source field.</param>
 /// <param name="include">Default action, if the data is not in any of the ranges,
 /// should it be included.</param>
 public RangeSegregator(IInputField sourceField, bool include)
 {
     _sourceField = sourceField;
     _include = include;
 }

 private void DetermineInputFieldValue(IInputField field, int index)
 {
     double num;
     InputFieldCSV dcsv;
     if (field is InputFieldCSV)
     {
         goto Label_00F5;
     }
     if (field is InputFieldMLDataSet)
     {
         InputFieldMLDataSet set = (InputFieldMLDataSet) field;
         MLDataFieldHolder holder = this._dataSetFieldMap[field];
         IMLDataPair pair = holder.Pair;
         int offset = set.Offset;
         if ((((uint) index) >= 0) && (offset >= pair.Input.Count))
         {
             offset -= pair.Input.Count;
             num = pair.Ideal[offset];
             if ((((uint) index) + ((uint) num)) > uint.MaxValue)
             {
                 return;
             }
             if (((uint) offset) >= 0)
             {
                 if (0 != 0)
                 {
                     return;
                 }
                 goto Label_0022;
             }
             goto Label_00F5;
         }
         num = pair.Input[offset];
     }
     else
     {
         num = field.GetValue(index);
     }
     Label_0022:
     field.CurrentValue = num;
     return;
     Label_00F5:
     dcsv = (InputFieldCSV) field;
     num = this._csvMap[field].GetDouble(dcsv.Offset);
     goto Label_0022;
 }

 /// <summary>
 /// Construct a direct output field.
 /// </summary>
 /// <param name="sourceField">The source field to pass directly on.</param>
 public OutputFieldDirect(IInputField sourceField)
 {
     _sourceField = sourceField;
 }

 /// <summary>
 /// Construct a balanced segregator.
 /// </summary>
 /// <param name="target">The input field to base this on, should 
 /// be an integer value.</param>
 /// <param name="count">The number of rows to accept from each 
 /// unique value for the input.</param>
 public IntegerBalanceSegregator(IInputField target, int count)
 {
     this.target = target;
     this.count = count;
 }