data_set.cpp

/****************************************************************************************************************/
/*                                                                                                              */
/*   OpenNN: Open Neural Networks Library                                                                       */
/*   www.artelnics.com/opennn                                                                                   */
/*                                                                                                              */
/*   D A T A   S E T   C L A S S                                                                                */
/*                                                                                                              */ 
/*   Roberto Lopez                                                                                              */ 
/*   Artelnics - Making intelligent use of data                                                                 */
/*   [email protected]                                                                                 */
/*                                                                                                              */
/****************************************************************************************************************/

// OpenNN includes

#include "data_set.h"


namespace OpenNN
{

// DEFAULT CONSTRUCTOR


DataSet::DataSet(void)
{
   set();  

   set_default();
}


// DATA CONSTRUCTOR


DataSet::DataSet(const Matrix<double>& data)
{
   set(data);

   set_default();
}


// GENERAL CONSTRUCTOR


DataSet::DataSet(const size_t& new_variables_number, const size_t& new_instances_number)
{
   set(new_variables_number, new_instances_number);

   set_default();
}


// INSTANCES, INPUTS AND TARGETS NUMBERS CONSTRUCTORS


DataSet::DataSet(const size_t& new_inputs_number, const size_t& new_targets_number, const size_t& new_instances_number)
{
   set(new_inputs_number, new_targets_number, new_instances_number);


   set_default();
}


// XML CONSTRUCTOR


DataSet::DataSet(const tinyxml2::XMLDocument& data_set_document)
{
   set_default();

   from_XML(data_set_document);
}


// FILE CONSTRUCTOR


DataSet::DataSet(const std::string& file_name)
{
   set();

   set_default();

   load(file_name);

}


// COPY CONSTRUCTOR


DataSet::DataSet(const DataSet& other_data_set)
{
   set_default();

   set(other_data_set);
}


// DESTRUCTOR


DataSet::~DataSet(void)
{
}


// ASSIGNMENT OPERATOR


DataSet& DataSet::operator = (const DataSet& other_data_set)
{
   if(this != &other_data_set) 
   {
      data_file_name = other_data_set.data_file_name;

      // Data matrix

      data = other_data_set.data;

      // Variables

      variables = other_data_set.variables;

      // Instances

      instances = other_data_set.instances;

      // Utilities

      display = other_data_set.display;
   }

   return(*this);
}


// EQUAL TO OPERATOR

// bool operator == (const DataSet&) const method


bool DataSet::operator == (const DataSet& other_data_set) const
{
   if(data_file_name == other_data_set.data_file_name
   && data == other_data_set.data
   && variables == other_data_set.variables
   && instances == other_data_set.instances
   && display == other_data_set.display)
   {
      return(true);
   }
   else
   {
      return(false);
   }
}


// METHODS

// const Variables& get_variables(void) const


const Variables& DataSet::get_variables(void) const
{
   return(variables);
}


// Variables* get_variables_pointer(void) const


Variables* DataSet::get_variables_pointer(void) 
{
   return(&variables);
}


// const Instances& get_instances(void) const


const Instances& DataSet::get_instances(void) const
{
   return(instances);
}


// Instances* get_instances_pointer(void)


Instances* DataSet::get_instances_pointer(void) 
{
   return(&instances);
}


// const bool& get_display(void) const method


const bool& DataSet::get_display(void) const
{
   return(display);   
}


// bool empty(void) const method


bool DataSet::empty(void) const
{
   return(data.empty());
}


// const Matrix<double>& get_data(void) const method


const Matrix<double>& DataSet::get_data(void) const
{
   return(data);
}


// const MissingValues& get_missing_values(void) const method


const MissingValues& DataSet::get_missing_values(void) const
{
   return(missing_values);
}


// MissingValues* get_missing_values_pointer(void) method


MissingValues* DataSet::get_missing_values_pointer(void)
{
   return(&missing_values);
}


// const std::string& get_data_file_name(void) const method


const std::string& DataSet::get_data_file_name(void) const
{
   return(data_file_name);
}


// const bool& get_header(void) const


const bool& DataSet::get_header_line(void) const
{
    return(header_line);
}


// const Separator& get_separator(void) const


const DataSet::Separator& DataSet::get_separator(void) const
{
    return(separator);
}


// std::string get_separator_string(void) const


std::string DataSet::get_separator_string(void) const
{
    switch(separator)
    {
       case Space:
       {
          return(" ");
       }
       break;

       case Tab:
       {
          return("\t");
       }
       break;

        case Comma:
        {
           return(",");
        }
        break;

        case Semicolon:
        {
           return(";");
        }
        break;

       default:
       {
          std::ostringstream buffer;

          buffer << "OpenNN Exception: DataSet class.\n"
                 << "std::string get_separator_string(void) const method.\n"
                 << "Unknown separator.\n";

          throw std::logic_error(buffer.str());
       }
       break;
    }
}


// std::string write_separator(void) const


std::string DataSet::write_separator(void) const
{
    switch(separator)
    {
       case Space:
       {
          return("Space");
       }
       break;

       case Tab:
       {
          return("Tab");
       }
       break;

        case Comma:
        {
           return("Comma");
        }
        break;

        case Semicolon:
        {
           return("Semicolon");
        }
        break;

       default:
       {
          std::ostringstream buffer;

          buffer << "OpenNN Exception: DataSet class.\n"
                 << "std::string write_separator(void) const method.\n"
                 << "Unknown separator.\n";

          throw std::logic_error(buffer.str());
       }
       break;
    }
}


// const std::string& get_missing_values_label(void) const


const std::string& DataSet::get_missing_values_label(void) const
{
    return(missing_values_label);
}


// const size_t& get_lags_number(void) const


const size_t& DataSet::get_lags_number(void) const
{
    return(lags_number);
}


// const bool& get_autoassociation(void) const


const bool& DataSet::get_autoassociation(void) const
{
    return(autoassociation);
}


// const Vector<size_t>& get_angular_variables(void) const method


const Vector<size_t>& DataSet::get_angular_variables(void) const
{
    return(angular_variables);
}


// const AngularUnits& get_angular_units(void) const method


const DataSet::AngularUnits& DataSet::get_angular_units(void) const
{
    return(angular_units);
}


// static ScalingUnscalingMethod get_scaling_unscaling_method(const std::string&) method


DataSet::ScalingUnscalingMethod DataSet::get_scaling_unscaling_method(const std::string& scaling_unscaling_method)
{
    if(scaling_unscaling_method == "MinimumMaximum")
    {
        return(MinimumMaximum);
    }
    else if(scaling_unscaling_method == "MeanStandardDeviation")
    {
        return(MeanStandardDeviation);
    }
    else
    {
        std::ostringstream buffer;

        buffer << "OpenNN Exception: DataSet class.\n"
               << "static ScalingUnscalingMethod get_scaling_unscaling_method(const std::string).\n"
               << "Unknown scaling-unscaling method: " << scaling_unscaling_method << ".\n";

        throw std::logic_error(buffer.str());
    }
}


// Matrix<double> arrange_training_data(void) const method


Matrix<double> DataSet::arrange_training_data(void) const
{
   const size_t variables_number = variables.get_variables_number();
   
   Vector<size_t> variables_indices(0, 1, (int)variables_number-1);

   const Vector<size_t> training_indices = instances.arrange_training_indices();

   return(data.arrange_submatrix(training_indices, variables_indices));
}


// Matrix<double> arrange_generalization_data(void) const method


Matrix<double> DataSet::arrange_generalization_data(void) const
{
   const size_t variables_number = variables.get_variables_number();

   const Vector<size_t> generalization_indices = instances.arrange_generalization_indices();

   Vector<size_t> variables_indices(0, 1, (int)variables_number-1);

   return(data.arrange_submatrix(generalization_indices, variables_indices));
}


// Matrix<double> arrange_testing_data(void) const method


Matrix<double> DataSet::arrange_testing_data(void) const
{
   const size_t variables_number = variables.get_variables_number();
   Vector<size_t> variables_indices(0, 1, (int)variables_number-1);

   const Vector<size_t> testing_indices = instances.arrange_testing_indices();

   return(data.arrange_submatrix(testing_indices, variables_indices));
}


// Matrix<double> arrange_input_data(void) const method


Matrix<double> DataSet::arrange_input_data(void) const
{
   const size_t instances_number = instances.get_instances_number();
   Vector<size_t> indices(0, 1, (int)instances_number-1);

   const Vector<size_t> inputs_indices = variables.arrange_inputs_indices();

   return(data.arrange_submatrix(indices, inputs_indices));
}


// Matrix<double> arrange_target_data(void) const method


Matrix<double> DataSet::arrange_target_data(void) const
{
   const size_t instances_number = instances.get_instances_number();
   Vector<size_t> indices(0, 1, (size_t)instances_number-1);

   const Vector<size_t> targets_indices = variables.arrange_targets_indices();

   return(data.arrange_submatrix(indices, targets_indices));
}


// Matrix<double> arrange_training_input_data(void) const method


Matrix<double> DataSet::arrange_training_input_data(void) const
{
   const Vector<size_t> inputs_indices = variables.arrange_inputs_indices();

   const Vector<size_t> training_indices = instances.arrange_training_indices();

   return(data.arrange_submatrix(training_indices, inputs_indices));
}


// Matrix<double> arrange_training_target_data(void) const method


Matrix<double> DataSet::arrange_training_target_data(void) const 
{
   const Vector<size_t> training_indices = instances.arrange_training_indices();

   const Vector<size_t> targets_indices = variables.arrange_targets_indices();

   return(data.arrange_submatrix(training_indices, targets_indices));
}


// Matrix<double> get_generalization_input_data(void) const method


Matrix<double> DataSet::get_generalization_input_data(void) const
{
   const Vector<size_t> generalization_indices = instances.arrange_generalization_indices();

   const Vector<size_t> inputs_indices = variables.arrange_inputs_indices();

   return(data.arrange_submatrix(generalization_indices, inputs_indices));
}


// Matrix<double> get_generalization_target_data(void) const method


Matrix<double> DataSet::get_generalization_target_data(void) const
{
   const Vector<size_t> generalization_indices = instances.arrange_generalization_indices();

   const Vector<size_t> targets_indices = variables.arrange_targets_indices();

   return(data.arrange_submatrix(generalization_indices, targets_indices));
}


// Matrix<double> arrange_testing_input_data(void) const method


Matrix<double> DataSet::arrange_testing_input_data(void) const
{
   const Vector<size_t> inputs_indices = variables.arrange_inputs_indices();

   const Vector<size_t> testing_indices = instances.arrange_testing_indices();

   return(data.arrange_submatrix(testing_indices, inputs_indices));
}


// Matrix<double> arrange_testing_target_data(void) const method


Matrix<double> DataSet::arrange_testing_target_data(void) const
{
   const Vector<size_t> targets_indices = variables.arrange_targets_indices();

   const Vector<size_t> testing_indices = instances.arrange_testing_indices();

   return(data.arrange_submatrix(testing_indices, targets_indices));
}


// Vector<double> get_instance(const size_t&) const method


Vector<double> DataSet::get_instance(const size_t& i) const
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t instances_number = instances.get_instances_number();

   if(i >= instances_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n"
             << "Vector<double> get_instance(const size_t&) const method.\n"
             << "Index of instance must be less than number of instances.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   // Get instance

   return(data.arrange_row(i));
}


// Vector<double> get_instance(const size_t&, const Vector<size_t>&) const method


Vector<double> DataSet::get_instance(const size_t& instance_index, const Vector<size_t>& variables_indices) const
{
   // Control sentence (if debug)

   #ifndef NDEBUG

   const size_t instances_number = instances.get_instances_number();

   if(instance_index >= instances_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n"
             << "Vector<double> get_instance(const size_t&, const Vector<size_t>&) const method.\n"
             << "Index of instance must be less than number of instances.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   // Get instance

   return(data.arrange_row(instance_index, variables_indices));
}


// Vector<double> get_variable(const size_t&) const method


Vector<double> DataSet::get_variable(const size_t& i) const
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t variables_number = variables.get_variables_number();

   if(i >= variables_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n"
             << "Vector<double> get_variable(const size_t&) const method.\n"
             << "Index of variable must be less than number of instances.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   // Get variable

   return(data.arrange_column(i));
}


// Vector<double> get_variable(const size_t&, const Vector<size_t>&) const method


Vector<double> DataSet::get_variable(const size_t& variable_index, const Vector<size_t>& instances_indices) const
{
   // Control sentence (if debug)

   #ifndef NDEBUG

   const size_t variables_number = variables.get_variables_number();

   if(variable_index >= variables_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n"
             << "Vector<double> get_variable(const size_t&, const Vector<double>&) const method.\n"
             << "Index of variable must be less than number of instances.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   // Get variable

   return(data.arrange_column(variable_index, instances_indices));
}


// void set(void) method


void DataSet::set(void)
{
   data_file_name = "";

   data.set();

   variables.set();
   instances.set();

   missing_values.set();

   display = true;
}


// void set(const Matrix<double>&) method


void DataSet::set(const Matrix<double>& new_data)
{
   data_file_name = "";

   const size_t variables_number = new_data.get_columns_number();
   const size_t instances_number = new_data.get_rows_number();

   data = new_data;

   variables.set(variables_number);
   instances.set(instances_number);

   missing_values.set(instances_number, variables_number);

   display = true;
}


// void set(const size_t&, const size_t&) method


void DataSet::set(const size_t& new_variables_number, const size_t& new_instances_number)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    if(new_variables_number == 0)
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception: DataSet class.\n"
              << "void set(const size_t&, const size_t&) method.\n"
              << "Number of variables must be greater than zero.\n";

       throw std::logic_error(buffer.str());
    }

    if(new_instances_number == 0)
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception: DataSet class.\n"
              << "void set(const size_t&, const size_t&) method.\n"
              << "Number of instances must be greater than zero.\n";

       throw std::logic_error(buffer.str());
    }

    #endif

   data.set(new_instances_number, new_variables_number);

   instances.set(new_instances_number);

   variables.set(new_variables_number);

   missing_values.set(new_instances_number, new_variables_number);

   display = true;
}


// void set(const size_t&, const size_t&, const size_t&) method


void DataSet::set(const size_t& new_inputs_number, const size_t& new_targets_number, const size_t& new_instances_number)
{   
   data_file_name = "";

   const size_t new_variables_number = new_inputs_number + new_targets_number;

   data.set(new_instances_number, new_variables_number);

   variables.set(new_inputs_number, new_targets_number);

   instances.set(new_instances_number);

   missing_values.set(new_instances_number, new_variables_number);

   display = true;
}


// void set(const DataSet& other_data_set)


void DataSet::set(const DataSet& other_data_set)
{
   data_file_name = other_data_set.data_file_name;

   header_line = other_data_set.header_line;

   separator = other_data_set.separator;

   missing_values_label = other_data_set.missing_values_label;

   data = other_data_set.data;

   variables = other_data_set.variables;

   instances = other_data_set.instances;

   missing_values = other_data_set.missing_values;

   display = other_data_set.display;
}


// void set(const tinyxml2::XMLDocument&) method


void DataSet::set(const tinyxml2::XMLDocument& data_set_document)
{
    set_default();

   from_XML(data_set_document);
}


// void set(const std::string&) method


void DataSet::set(const std::string& file_name)
{
   load(file_name);
}


// void set_display(const bool&) method


void DataSet::set_display(const bool& new_display)
{
   display = new_display;
}


// void set_default(void) method


void DataSet::set_default(void)
{
    header_line = false;

    separator = Space;

    missing_values_label = "?";

    lags_number = 0;

    autoassociation = false;

    angular_units = Degrees;

    display = true;
}


// void set_data(const Matrix<double>&) method


void DataSet::set_data(const Matrix<double>& new_data)
{
   // Control sentence (if debug)
/*
   #ifndef NDEBUG 

   const size_t rows_number = new_data.get_rows_number();
   const size_t instances_number = instances.get_instances_number();

   if(rows_number != instances_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n"
             << "void set_data(const Matrix<double>&) method.\n"
             << "Number of rows (" << rows_number << ") must be equal to number of instances (" << instances_number << ").\n";

      throw std::logic_error(buffer.str());
   }

   const size_t columns_number = new_data.get_columns_number();
   const size_t variables_number = variables.get_variables_number();

   if(columns_number != variables_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n"
             << "void set_data(const Matrix<double>&) method.\n"
             << "Number of columns (" << columns_number << ") must be equal to number of variables (" << variables_number << ").\n";

      throw std::logic_error(buffer.str());
   }

   #endif
*/
   // Set data
   
   data = new_data;   

   instances.set_instances_number(data.get_rows_number());
   variables.set_variables_number(data.get_columns_number());

}


// void set_data_file_name(const std::string&) method


void DataSet::set_data_file_name(const std::string& new_data_file_name)
{   
   data_file_name = new_data_file_name;
}


// void set_header_line(const bool&) method


void DataSet::set_header_line(const bool& new_header_line)
{
    header_line = new_header_line;
}


// void set_separator(const Separator&) method


void DataSet::set_separator(const Separator& new_separator)
{
    separator = new_separator;
}


// void set_separator(const std::string&) method


void DataSet::set_separator(const std::string& new_separator)
{
    if(new_separator == "Space")
    {
        separator = Space;
    }
    else if(new_separator == "Tab")
    {
        separator = Tab;
    }
    else if(new_separator == "Comma")
    {
        separator = Comma;
    }
    else if(new_separator == "Semicolon")
    {
        separator = Semicolon;
    }
    else
    {
        std::ostringstream buffer;

        buffer << "OpenNN Exception: DataSet class.\n"
               << "void set_separator(const std::string&) method.\n"
               << "Unknown separator: " << new_separator << ".\n";

        throw std::logic_error(buffer.str());
    }
}


// void set_missing_values_label(const std::string&) method


void DataSet::set_missing_values_label(const std::string& new_missing_values_label)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    if(get_trimmed(new_missing_values_label).empty())
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception: DataSet class.\n"
              << "void set_missing_values_label(const std::string&) method.\n"
              << "Missing values label cannot be empty.\n";

       throw std::logic_error(buffer.str());
    }

    #endif


    missing_values_label = new_missing_values_label;
}


// void set_lags_number(const size_t&)


void DataSet::set_lags_number(const size_t& new_lags_number)
{
    lags_number = new_lags_number;
}


// void set_autoassociation(const size_t&)


void DataSet::set_autoassociation(const bool& new_autoassociation)
{
    autoassociation = new_autoassociation;
}


// void set_angular_variables(const Vector<size_t>&)


void DataSet::set_angular_variables(const Vector<size_t>& new_angular_variables)
{
    angular_variables = new_angular_variables;
}


// void set_angular_units(AngularUnits&)


void DataSet::set_angular_units(AngularUnits& new_angular_units)
{
    angular_units = new_angular_units;
}



// void set_instances_number(const size_t&) method


void DataSet::set_instances_number(const size_t& new_instances_number)
{
   const size_t variables_number = variables.get_variables_number();

   data.set(new_instances_number, variables_number);

   instances.set(new_instances_number);
}


// void set_variables_number(const size_t&) method


void DataSet::set_variables_number(const size_t& new_variables_number)
{
   const size_t instances_number = instances.get_instances_number();

   data.set(instances_number, new_variables_number);

   variables.set(new_variables_number);
}


// void set_instance(const size_t&, const Vector<double>&)


void DataSet::set_instance(const size_t& instance_index, const Vector<double>& instance)
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t instances_number = instances.get_instances_number();

   if(instance_index >= instances_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n"
             << "void set_instance(const size_t&, const Vector<double>&) method.\n"
             << "Index of instance must be less than number of instances.\n";

      throw std::logic_error(buffer.str());
   }

   const size_t size = instance.size();
   const size_t variables_number = variables.get_variables_number();

   if(size != variables_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n"
             << "void set_instance(const size_t&, const Vector<double>&) method.\n"
             << "Size (" << size << ") must be equal to number of variables (" << variables_number << ").\n";

      throw std::logic_error(buffer.str());
   } 

   #endif

   // Set instance

   data.set_row(instance_index, instance);
}


// void add_instance(const Vector<double>&) method


void DataSet::add_instance(const Vector<double>& instance)
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t size = instance.size();
   const size_t variables_number = variables.get_variables_number();

   if(size != variables_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n"
             << "void add_instance(const Vector<double>&) method.\n"
             << "Size of instance must be equal to number of variables.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   const size_t instances_number = instances.get_instances_number();

   data.append_row(instance);

   instances.set(instances_number+1);
}


// void subtract_instance(size_t) method


void DataSet::subtract_instance(const size_t& instance_index)
{
    const size_t instances_number = instances.get_instances_number();

   // Control sentence (if debug)

   #ifndef NDEBUG 

   if(instance_index >= instances_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n"
             << "void subtract_instance(size_t) method.\n"
             << "Index of instance must be less than number of instances.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   data.subtract_row(instance_index);

   instances.set_instances_number(instances_number-1);

}


// void append_variable(const Vector<double>&) method


void DataSet::append_variable(const Vector<double>& variable)
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t size = variable.size();
   const size_t instances_number = instances.get_instances_number();

   if(size != instances_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n"
             << "void append_variable(const Vector<double>&) method.\n"
             << "Size of variable must be equal to number of instances.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   const size_t variables_number = variables.get_variables_number();

   data.append_column(variable);

   Matrix<double> new_data(data);

   const size_t new_variables_number = variables_number + 1;

   set_variables_number(new_variables_number);

   set_data(new_data);
}


// void subtract_variable(size_t) method


void DataSet::subtract_variable(const size_t& variable_index)
{
   const size_t variables_number = variables.get_variables_number();

   // Control sentence (if debug)

   #ifndef NDEBUG 

   if(variable_index >= variables_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n"
             << "void subtract_variable(size_t) method.\n"
             << "Index of variable must be less than number of variables.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   data.subtract_column(variable_index);

   Matrix<double> new_data(data);

   const size_t new_variables_number = variables_number - 1;

   set_variables_number(new_variables_number);

   set_data(new_data);
}


// Vector<size_t> unuse_constant_variables(void) method


Vector<size_t> DataSet::unuse_constant_variables(void)
{
   const size_t variables_number = variables.get_variables_number();

   // Control sentence (if debug)

   #ifndef NDEBUG

   if(variables_number == 0)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n"
             << "Vector<size_t> unuse_constant_variables(void) method.\n"
             << "Number of variables is zero.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   Vector<size_t> constant_variables;

   for(size_t i = 0; i < variables_number; i++)
   {
      if(variables.is_used(i) && data.arrange_column(i).is_constant(1.0e-6))
      {
         variables.set_use(i, Variables::Unused);
         constant_variables.push_back(i);
      }
   }

   return(constant_variables);
}


// Vector<size_t> unuse_repeated_instances(void) method


Vector<size_t> DataSet::unuse_repeated_instances(void)
{
    const size_t instances_number = instances.get_instances_number();

    // Control sentence (if debug)

    #ifndef NDEBUG

    if(instances_number == 0)
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception: DataSet class.\n"
              << "Vector<size_t> unuse_repeated_indices(void) method.\n"
              << "Number of instances is zero.\n";

       throw std::logic_error(buffer.str());
    }

    #endif

    Vector<size_t> repeated_instances;

    Vector<double> instance_i;
    Vector<double> instance_j;    

    int i = 0;

    #pragma omp parallel for private(i, instance_i, instance_j)

    for(i = 0; i < (int)instances_number; i++)
    {
       instance_i = get_instance(i);

       for(size_t j = i+1; j < instances_number; j++)
       {          
          instance_j = get_instance(j);

          if(instances.get_use(j) != Instances::Unused
          && instance_j == instance_i)
          {
              instances.set_use(j, Instances::Unused);
              repeated_instances.push_back(j);
          }
       }        
    }

    return(repeated_instances);
}


// Vector<Histogram> calculate_data_histograms(const size_t&) const method


Vector< Histogram<double> > DataSet::calculate_data_histograms(const size_t& bins_number) const
{
   const Vector< Vector<size_t> > missing_indices = missing_values.arrange_missing_indices();

   return(data.calculate_histograms_missing_values(missing_indices, bins_number));
}


// Vector< Vector<double> > calculate_data_statistics(void) const method


Vector< Statistics<double> > DataSet::calculate_data_statistics(void) const
{
    const Vector< Vector<size_t> > missing_indices = missing_values.arrange_missing_indices();

    return(data.calculate_statistics_missing_values(missing_indices));
}


// Matrix<double> calculate_data_statistics_matrix(void) const method


Matrix<double> DataSet::calculate_data_statistics_matrix(void) const
{
    const Vector< Vector<size_t> > missing_indices = missing_values.arrange_missing_indices();

    const Vector< Statistics<double> > data_statistics = data.calculate_statistics_missing_values(missing_indices);

    const size_t variables_number = variables.get_variables_number();

    Matrix<double> data_statistics_matrix(variables_number, 4);

    for(size_t i = 0; i < variables_number; i++)
    {
        data_statistics_matrix.set_row(i, data_statistics[i].to_vector());
    }

    return(data_statistics_matrix);
}


// Vector< Statistics<double> > calculate_training_instances_statistics(void) const method


Vector< Statistics<double> > DataSet::calculate_training_instances_statistics(void) const
{
   const Vector<size_t> training_indices = instances.arrange_training_indices();

   const Vector< Vector<size_t> > missing_indices = missing_values.arrange_missing_indices();

   return(data.calculate_rows_statistics_missing_values(training_indices, missing_indices));
}


// Vector< Statistics<double> > calculate_generalization_instances_statistics(void) const method


Vector< Statistics<double> > DataSet::calculate_generalization_instances_statistics(void) const
{
    const Vector<size_t> generalization_indices = instances.arrange_generalization_indices();

    const Vector< Vector<size_t> > missing_indices = missing_values.arrange_missing_indices();

   return(data.calculate_rows_statistics_missing_values(generalization_indices, missing_indices));
}


// Vector< Statistics<double> > calculate_testing_instances_statistics(void) const method


Vector< Statistics<double> > DataSet::calculate_testing_instances_statistics(void) const
{
    const Vector<size_t> testing_indices = instances.arrange_testing_indices();

    const Vector< Vector<size_t> > missing_indices = missing_values.arrange_missing_indices();

   return(data.calculate_rows_statistics_missing_values(testing_indices, missing_indices));
}


// Vector< Statistics<double> > calculate_inputs_statistics(void) const method


Vector< Statistics<double> > DataSet::calculate_inputs_statistics(void) const
{
    const Vector<size_t> inputs_indices = variables.arrange_inputs_indices();

    const Vector< Vector<size_t> > missing_indices = missing_values.arrange_missing_indices();

   return(data.calculate_columns_statistics_missing_values(inputs_indices, missing_indices));
}


// Vector< Statistics<double> > calculate_targets_statistics(void) const method


Vector< Statistics<double> > DataSet::calculate_targets_statistics(void) const
{
   const Vector<size_t> targets_indices = variables.arrange_targets_indices();

   const Vector< Vector<size_t> > missing_indices = missing_values.arrange_missing_indices();

   return(data.calculate_columns_statistics_missing_values(targets_indices, missing_indices));
}


// Vector<double> calculate_training_target_data_mean(void) const method


Vector<double> DataSet::calculate_training_target_data_mean(void) const
{
   const Vector<size_t> targets_indices = variables.arrange_targets_indices();

   const Vector<size_t> training_indices = instances.arrange_training_indices();

   const Vector< Vector<size_t> > missing_indices = missing_values.arrange_missing_indices();

   return(data.calculate_mean_missing_values(training_indices, targets_indices, missing_indices));
}


// Vector<double> calculate_generalization_target_data_mean(void) const method


Vector<double> DataSet::calculate_generalization_target_data_mean(void) const
{
    const Vector<size_t> targets_indices = variables.arrange_targets_indices();

   const Vector<size_t> generalization_indices = instances.arrange_generalization_indices();

   const Vector< Vector<size_t> > missing_indices = missing_values.arrange_missing_indices();

   return(data.calculate_mean_missing_values(generalization_indices, targets_indices, missing_indices));
}


// Vector<double> calculate_testing_target_data_mean(void) const method


Vector<double> DataSet::calculate_testing_target_data_mean(void) const
{
   const Vector<size_t> testing_indices = instances.arrange_testing_indices();

   const Vector<size_t> targets_indices = variables.arrange_targets_indices();

   const Vector< Vector<size_t> > missing_indices = missing_values.arrange_missing_indices();

   return(data.calculate_mean_missing_values(testing_indices, targets_indices, missing_indices));
}


// Matrix<double> calculate_linear_correlations(void) const method


Matrix<double> DataSet::calculate_linear_correlations(void) const
{
   const size_t inputs_number = variables.count_inputs_number();
   const size_t targets_number = variables.count_targets_number();

   const Vector<size_t> input_indices = variables.arrange_inputs_indices();
   const Vector<size_t> target_indices = variables.arrange_targets_indices();

   size_t input_index;
   size_t target_index;

   const size_t instances_number = instances.get_instances_number();

   const Vector< Vector<size_t> > missing_indices = missing_values.arrange_missing_indices();

   Vector<double> input_variable(instances_number);
   Vector<double> target_variable(instances_number);

   Matrix<double> linear_correlations(inputs_number, targets_number);

   for(size_t i = 0; i < inputs_number; i++)
   {
       input_index = input_indices[i];

       input_variable = data.arrange_column(input_index);

       for(size_t j = 0; j < targets_number; j++)
       {
           target_index = target_indices[j];

           target_variable = data.arrange_column(target_index);

//           linear_correlations(i,j) = input_variable.calculate_linear_correlation_missing_values(target_variable, missing_indices[target_index]);
           linear_correlations(i,j) = input_variable.calculate_linear_correlation(target_variable);
       }
   }

   return(linear_correlations);
}


// void scale_data_mean_standard_deviation(const Vector< Statistics<double> >&) const method


void DataSet::scale_data_mean_standard_deviation(const Vector< Statistics<double> >& data_statistics)
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   std::ostringstream buffer;

   const size_t columns_number = data.get_columns_number();

   const size_t statistics_size = data_statistics.size();

   if(statistics_size != columns_number)
   {
      buffer << "OpenNN Exception: DataSet class.\n"
             << "void scale_data_mean_standard_deviation(const Vector< Statistics<double> >&) method.\n"
             << "Size of statistics must be equal to number of columns.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   const size_t variables_number = variables.get_variables_number();

   for(size_t i = 0; i < variables_number; i++)
   {
       if(display && data_statistics[i].standard_deviation < 1.0e-99)
       {
          std::cout << "OpenNN Warning: DataSet class.\n"
                    << "void scale_data_mean_standard_deviation(const Vector< Statistics<Type> >&) method.\n"
                    << "Standard deviation of variable " <<  i << " is zero.\n"
                    << "That variable won't be scaled.\n";
        }
    }

   data.scale_mean_standard_deviation(data_statistics);
}


// Vector< Statistics<double> > scale_data_minimum_maximum(void) method


Vector< Statistics<double> > DataSet::scale_data_minimum_maximum(void)
{
    const Vector< Statistics<double> > data_statistics = calculate_data_statistics();

    scale_data_minimum_maximum(data_statistics);

    return(data_statistics);
}


// Vector< Statistics<double> > scale_data_mean_standard_deviation(void) method


Vector< Statistics<double> > DataSet::scale_data_mean_standard_deviation(void)
{
    const Vector< Statistics<double> > data_statistics = calculate_data_statistics();

    scale_data_mean_standard_deviation(data_statistics);

    return(data_statistics);
}


// void scale_data_minimum_maximum(const Vector< Statistics<double> >&) method


void DataSet::scale_data_minimum_maximum(const Vector< Statistics<double> >& data_statistics)
{
    const size_t variables_number = variables.get_variables_number();

   // Control sentence (if debug)

   #ifndef NDEBUG 

   std::ostringstream buffer;

   const size_t statistics_size = data_statistics.size();

   if(statistics_size != variables_number)
   {
      buffer << "OpenNN Exception: DataSet class.\n"
             << "void scale_data_minimum_maximum(const Vector< Statistics<double> >&) method.\n"
             << "Size of data statistics must be equal to number of variables.\n";

      throw std::logic_error(buffer.str());
   }

   #endif

   for(size_t i = 0; i < variables_number; i++)
   {
       if(display && data_statistics[i].maximum-data_statistics[i].minimum < 1.0e-99)
       {
          std::cout << "OpenNN Warning: DataSet class.\n"
                    << "void scale_data_minimum_maximum(const Vector< Statistics<Type> >&) method.\n"
                    << "Range of variable " <<  i << " is zero.\n"
                    << "That variable won't be scaled.\n";
        }
    }


   data.scale_minimum_maximum(data_statistics);
}


// void scale_data(const std::string&, const Vector< Statistics<double> >&) method


void DataSet::scale_data(const std::string& scaling_unscaling_method_string, const Vector< Statistics<double> >& data_statistics)
{
   switch(get_scaling_unscaling_method(scaling_unscaling_method_string))
   {
      case MinimumMaximum:
      {
         scale_data_minimum_maximum(data_statistics);
      }            
      break;

      case MeanStandardDeviation:
      {
         scale_data_mean_standard_deviation(data_statistics);
      }
      break;

      default:
      {
         std::ostringstream buffer;

         buffer << "OpenNN Exception: DataSet class\n"
                << "void scale_data(const std::string&, const Vector< Vector<double> >&) method.\n"
                << "Unknown data scaling and unscaling method.\n";

         throw std::logic_error(buffer.str());
      }
      break;
   }
}


// Vector< Statistics<double> > scale_data(void) method


Vector< Statistics<double> > DataSet::scale_data(const std::string& scaling_unscaling_method)
{
   const Vector< Statistics<double> > statistics = data.calculate_statistics();

   switch(get_scaling_unscaling_method(scaling_unscaling_method))
   {
      case MinimumMaximum:
      {
         scale_data_minimum_maximum(statistics);
      }            
      break;

      case MeanStandardDeviation:
      {
         scale_data_mean_standard_deviation(statistics);
      }
      break;

      default:
      {
         std::ostringstream buffer;

         buffer << "OpenNN Exception: DataSet class\n"
                << "Vector< Statistics<double> > scale_data(const std::string&) method.\n"
                << "Unknown scaling and unscaling method.\n";

         throw std::logic_error(buffer.str());
      }
      break;
   }

   return(statistics);
}


// void scale_inputs_mean_standard_deviation(const Vector< Statistics<double> >&) method


void DataSet::scale_inputs_mean_standard_deviation(const Vector< Statistics<double> >& inputs_statistics)
{
    const Vector<size_t> inputs_indices = variables.arrange_inputs_indices();

    data.scale_columns_mean_standard_deviation(inputs_statistics, inputs_indices);
}


// Vector< Statistics<double> > scale_inputs_mean_standard_deviation(void) method


Vector< Statistics<double> > DataSet::scale_inputs_mean_standard_deviation(void)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    if(data.empty())
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception: DataSet class.\n"
              << "Vector< Statistics<double> > scale_inputs_mean_standard_deviation(void) method.\n"
              << "Data file is not loaded.\n";

       throw std::logic_error(buffer.str());
    }

    #endif

   const Vector< Statistics<double> > inputs_statistics = calculate_inputs_statistics();

   scale_inputs_mean_standard_deviation(inputs_statistics);

   return(inputs_statistics);
}


// void scale_inputs_minimum_maximum(const Vector< Statistics<double> >&) method


void DataSet::scale_inputs_minimum_maximum(const Vector< Statistics<double> >& inputs_statistics)
{
    const Vector<size_t> inputs_indices = variables.arrange_inputs_indices();

    data.scale_columns_minimum_maximum(inputs_statistics, inputs_indices);
}


// Vector< Statistics<double> > scale_inputs_minimum_maximum(void) method


Vector< Statistics<double> > DataSet::scale_inputs_minimum_maximum(void)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    if(data.empty())
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception: DataSet class.\n"
              << "Vector< Statistics<double> > scale_inputs_minimum_maximum(void) method.\n"
              << "Data file is not loaded.\n";

       throw std::logic_error(buffer.str());
    }

    #endif

   const Vector< Statistics<double> > inputs_statistics = calculate_inputs_statistics();

   scale_inputs_minimum_maximum(inputs_statistics);

   return(inputs_statistics);
}


// Vector< Vector<double> > scale_inputs(const std::string&) method


Vector< Statistics<double> > DataSet::scale_inputs(const std::string& scaling_unscaling_method)
{
    switch(get_scaling_unscaling_method(scaling_unscaling_method))
   {
      case MinimumMaximum:
      {
         return(scale_inputs_minimum_maximum());
      }            
      break;

      case MeanStandardDeviation:
      {
         return(scale_inputs_mean_standard_deviation());
      }
      break;

      default:
      {
         std::ostringstream buffer;

         buffer << "OpenNN Exception: DataSet class\n"
                << "Vector< Statistics<double> > scale_inputs(void) method.\n"
                << "Unknown scaling and unscaling method.\n";

         throw std::logic_error(buffer.str());
      }
      break;
   }
}


// void scale_inputs(const std::string&, const Vector< Statistics<double> >&) method


void DataSet::scale_inputs(const std::string& scaling_unscaling_method, const Vector< Statistics<double> >& inputs_statistics)
{
   switch(get_scaling_unscaling_method(scaling_unscaling_method))
   {
      case MinimumMaximum:
      {
         scale_inputs_minimum_maximum(inputs_statistics);
      }
      break;

      case MeanStandardDeviation:
      {
         scale_inputs_mean_standard_deviation(inputs_statistics);
      }
      break;

      default:
      {
         std::ostringstream buffer;

         buffer << "OpenNN Exception: DataSet class\n"
                << "void scale_inputs(const std::string&, const Vector< Statistics<double> >&) method.\n"
                << "Unknown scaling and unscaling method.\n";

         throw std::logic_error(buffer.str());
      }
      break;
   }
}


// void scale_targets_mean_standard_deviation(const Vector< Statistics<double> >&)


void DataSet::scale_targets_mean_standard_deviation(const Vector< Statistics<double> >& targets_statistics)
{
    const Vector<size_t> targets_indices = variables.arrange_targets_indices();

    data.scale_columns_mean_standard_deviation(targets_statistics, targets_indices);
}


// Vector< Statistics<double> > scale_targets_mean_standard_deviation(void) method


Vector< Statistics<double> > DataSet::scale_targets_mean_standard_deviation(void)
{    
    // Control sentence (if debug)

    #ifndef NDEBUG

    if(data.empty())
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception: DataSet class.\n"
              << "Vector< Statistics<double> > scale_targets_mean_standard_deviation(void) method.\n"
              << "Data file is not loaded.\n";

       throw std::logic_error(buffer.str());
    }

    #endif

   const Vector< Statistics<double> > targets_statistics = calculate_targets_statistics();

   scale_targets_mean_standard_deviation(targets_statistics);

   return(targets_statistics);
}


// void scale_targets_minimum_maximum(const Vector< Statistics<double> >&) method


void DataSet::scale_targets_minimum_maximum(const Vector< Statistics<double> >& targets_statistics)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    if(data.empty())
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception: DataSet class.\n"
              << "Vector< Statistics<double> > scale_targets_minimum_maximum(void) method.\n"
              << "Data file is not loaded.\n";

       throw std::logic_error(buffer.str());
    }

    #endif

    const Vector<size_t> targets_indices = variables.arrange_targets_indices();

    data.scale_columns_minimum_maximum(targets_statistics, targets_indices);
}


// Vector< Statistics<double> > scale_targets_minimum_maximum(void) method


Vector< Statistics<double> > DataSet::scale_targets_minimum_maximum(void)
{
   const Vector< Statistics<double> > targets_statistics = calculate_targets_statistics();

   scale_targets_minimum_maximum(targets_statistics);

   return(targets_statistics);
}


// Vector< Statistics<double> > scale_targets(const std::string&) method


Vector< Statistics<double> > DataSet::scale_targets(const std::string& scaling_unscaling_method)
{
    switch(get_scaling_unscaling_method(scaling_unscaling_method))
   {
      case MinimumMaximum:
      {
         return(scale_targets_minimum_maximum());
      }            
      break;

      case MeanStandardDeviation:
      {
         return(scale_targets_mean_standard_deviation());
      }
      break;

      default:
      {
         std::ostringstream buffer;

         buffer << "OpenNN Exception: DataSet class\n"
                << "Vector< Statistics<double> > scale_targets(const std::string&) method.\n"
                << "Unknown scaling and unscaling method.\n";

         throw std::logic_error(buffer.str());
      }
      break;
   }
}


// void scale_targets(const std::string&, const Vector< Statistics<double> >&) method


void DataSet::scale_targets(const std::string& scaling_unscaling_method, const Vector< Statistics<double> >& targets_statistics)
{
   switch(get_scaling_unscaling_method(scaling_unscaling_method))
   {
      case MinimumMaximum:
      {
         scale_targets_minimum_maximum(targets_statistics);
      }
      break;

      case MeanStandardDeviation:
      {
         scale_targets_mean_standard_deviation(targets_statistics);
      }
      break;

      default:
      {
         std::ostringstream buffer;

         buffer << "OpenNN Exception: DataSet class\n"
                << "void scale_targets(const std::string&, const Vector< Statistics<double> >&) method.\n"
                << "Unknown scaling and unscaling method.\n";

         throw std::logic_error(buffer.str());
      }
      break;
   }
}


// void unscale_data_mean_standard_deviation(const Vector< Statistics<double> >&) method


void DataSet::unscale_data_mean_standard_deviation(const Vector< Statistics<double> >& data_statistics)
{
   data.unscale_mean_standard_deviation(data_statistics);
}


// void unscale_data_minimum_maximum(const Vector< Statistics<double> >&) method


void DataSet::unscale_data_minimum_maximum(const Vector< Statistics<double> >& data_statistics)
{
   data.unscale_minimum_maximum(data_statistics);
}


// void unscale_inputs_mean_standard_deviation(const Vector< Statistics<double> >&) method


void DataSet::unscale_inputs_mean_standard_deviation(const Vector< Statistics<double> >& data_statistics)
{
    const Vector<size_t> inputs_indices = variables.arrange_inputs_indices();

    data.unscale_columns_mean_standard_deviation(data_statistics, inputs_indices);
}


// void unscale_inputs_minimum_maximum(const Vector< Statistics<double> >&) method


void DataSet::unscale_inputs_minimum_maximum(const Vector< Statistics<double> >& data_statistics)
{
    const Vector<size_t> inputs_indices = variables.arrange_inputs_indices();

    data.unscale_columns_minimum_maximum(data_statistics, inputs_indices);
}


// void unscale_targets_mean_standard_deviation(const Vector< Statistics<double> >&) method


void DataSet::unscale_targets_mean_standard_deviation(const Vector< Statistics<double> >& data_statistics)
{
    const Vector<size_t> targets_indices = variables.arrange_targets_indices();

    data.unscale_columns_mean_standard_deviation(data_statistics, targets_indices);
}


// void unscale_targets_minimum_maximum(const Vector< Statistics<double> >&) method


void DataSet::unscale_targets_minimum_maximum(const Vector< Statistics<double> >& data_statistics)
{
    const Vector<size_t> targets_indices = variables.arrange_targets_indices();

    data.unscale_columns_minimum_maximum(data_statistics, targets_indices);
}


// void initialize_data(const double& value) method


void DataSet::initialize_data(const double& new_value)
{
   data.initialize(new_value);
}


// void randomize_data_uniform(const double&, const double&) method


void DataSet::randomize_data_uniform(const double& minimum, const double& maximum)
{
   data.randomize_uniform(minimum, maximum);
}


// void randomize_data_normal(const double&, const double&) method


void DataSet::randomize_data_normal(const double& mean, const double& standard_deviation)
{
   data.randomize_normal(mean, standard_deviation);
}


// tinyxml2::XMLDocument* to_XML(void) const method


tinyxml2::XMLDocument* DataSet::to_XML(void) const
{
   tinyxml2::XMLDocument* document = new tinyxml2::XMLDocument;

   std::ostringstream buffer;

   // Data set

   tinyxml2::XMLElement* data_set_element = document->NewElement("DataSet");
   document->InsertFirstChild(data_set_element);

   tinyxml2::XMLElement* element = NULL;
   tinyxml2::XMLText* text = NULL;

   // Data file

   tinyxml2::XMLElement* data_file_element = document->NewElement("DataFile");

   data_set_element->InsertFirstChild(data_file_element);

   // Data file name
   {
      element = document->NewElement("DataFileName");
      data_file_element->LinkEndChild(element);

      text = document->NewText(data_file_name.c_str());
      element->LinkEndChild(text);
   }

   // Header line
   {
      element = document->NewElement("HeaderLine");
      data_file_element->LinkEndChild(element);

      buffer.str("");
      buffer << header_line;

      text = document->NewText(buffer.str().c_str());
      element->LinkEndChild(text);
   }

   // Separator
   {
      element = document->NewElement("Separator");
      data_file_element->LinkEndChild(element);

      text = document->NewText(write_separator().c_str());
      element->LinkEndChild(text);
   }

   // Missing values label
   {
      element = document->NewElement("MissingValuesLabel");
      data_file_element->LinkEndChild(element);

      text = document->NewText(missing_values_label.c_str());
      element->LinkEndChild(text);
   }

   // Variables 
   {
      element = document->NewElement("Variables");
      data_set_element->LinkEndChild(element);

      const tinyxml2::XMLDocument* variables_document = variables.to_XML();

      const tinyxml2::XMLElement* variables_element = variables_document->FirstChildElement("Variables");

      DeepClone(element, variables_element, document, NULL);

      delete variables_document;
   }

   // Instances
   {
       element = document->NewElement("Instances");
       data_set_element->LinkEndChild(element);

       const tinyxml2::XMLDocument* instances_document = instances.to_XML();

       const tinyxml2::XMLElement* instances_element = instances_document->FirstChildElement("Instances");

       DeepClone(element, instances_element, document, NULL);

       delete instances_document;
   }

   // Missing values
   {
       element = document->NewElement("MissingValues");
       data_set_element->LinkEndChild(element);

       const tinyxml2::XMLDocument* missing_values_document = missing_values.to_XML();

       const tinyxml2::XMLElement* missing_values_element = missing_values_document->FirstChildElement("MissingValues");

       DeepClone(element, missing_values_element, document, NULL);

       delete missing_values_document;
   }

   // Display
   {
      element = document->NewElement("Display");
      data_set_element->LinkEndChild(element);

      buffer.str("");
      buffer << display;

      text = document->NewText(buffer.str().c_str());
      element->LinkEndChild(text);
   }  

   return(document);
}


// void from_XML(const tinyxml2::XMLDocument&) method


void DataSet::from_XML(const tinyxml2::XMLDocument& data_set_document)
{

   std::ostringstream buffer;

   // Data set element

   const tinyxml2::XMLElement* data_set_element = data_set_document.FirstChildElement("DataSet");

   if(!data_set_element)
   {
       buffer << "OpenNN Exception: DataSet class.\n"
              << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
              << "Data set element is NULL.\n";

       throw std::logic_error(buffer.str());
   }

    // Data file

    const tinyxml2::XMLElement* data_file_element = data_set_element->FirstChildElement("DataFile");

    if(!data_file_element)
    {
       buffer << "OpenNN Exception: DataSet class.\n"
              << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
              << "Data file element is NULL.\n";

       throw std::logic_error(buffer.str());
    }


       // Data file name
    {
       const tinyxml2::XMLElement* data_file_name_element = data_file_element->FirstChildElement("DataFileName");

       if(!data_file_name_element)
       {
           buffer << "OpenNN Exception: DataSet class.\n"
                  << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
                  << "Data file name element is NULL.\n";

           throw std::logic_error(buffer.str());
       }

       if(data_file_name_element->GetText())
       {
            const std::string new_data_file_name = data_file_name_element->GetText();

            set_data_file_name(new_data_file_name);
       }
    }

      // Header line
      {
         const tinyxml2::XMLElement* header_element = data_file_element->FirstChildElement("HeaderLine");

         if(header_element)
         {
            const std::string new_header_string = header_element->GetText();

            try
            {
               set_header_line(new_header_string != "0");
            }
            catch(const std::logic_error& e)
            {
               std::cout << e.what() << std::endl;
            }
         }
      }

      // Separator
    {
      const tinyxml2::XMLElement* separator_element = data_file_element->FirstChildElement("Separator");

      if(separator_element)
     {
          if(separator_element->GetText())
          {              
            const std::string new_separator = separator_element->GetText();

            set_separator(new_separator);
          }
          else
          {
              set_separator("Space");
          }
      }
      else
      {
          set_separator("Space");
      }
    }

    // Missing values label
    {
         const tinyxml2::XMLElement* missing_values_label_element = data_file_element->FirstChildElement("MissingValuesLabel");

         if(missing_values_label_element)
         {
             if(missing_values_label_element->GetText())
             {
                const std::string new_missing_values_label = missing_values_label_element->GetText();

                set_missing_values_label(new_missing_values_label);
             }
         }
    }

    // Variables
    {
       const tinyxml2::XMLElement* variables_element = data_set_element->FirstChildElement("Variables");

       if(variables_element)
       {
           tinyxml2::XMLDocument variables_document;

           tinyxml2::XMLElement* variables_element_clone = variables_document.NewElement("Variables");
           variables_document.InsertFirstChild(variables_element_clone);

           DeepClone(variables_element_clone, variables_element, &variables_document, NULL);

           variables.from_XML(variables_document);
       }
    }

    // Instances
    {
       const tinyxml2::XMLElement* instances_element = data_set_element->FirstChildElement("Instances");

       if(instances_element)
       {
           tinyxml2::XMLDocument instances_document;

           tinyxml2::XMLElement* instances_element_clone = instances_document.NewElement("Instances");
           instances_document.InsertFirstChild(instances_element_clone);

           DeepClone(instances_element_clone, instances_element, &instances_document, NULL);

           instances.from_XML(instances_document);
       }
    }

    // Missing values
    {
       const tinyxml2::XMLElement* missing_values_element = data_set_element->FirstChildElement("MissingValues");

       if(missing_values_element)
       {
           tinyxml2::XMLDocument missing_values_document;

           tinyxml2::XMLElement* missing_values_element_clone = missing_values_document.NewElement("MissingValues");
           missing_values_document.InsertFirstChild(missing_values_element_clone);

           DeepClone(missing_values_element_clone, missing_values_element, &missing_values_document, NULL);

           missing_values.from_XML(missing_values_document);
       }
    }

   // Display
   {
      const tinyxml2::XMLElement* display_element = data_set_element->FirstChildElement("Display");

      if(display_element)
      {
         const std::string new_display_string = display_element->GetText();

         try
         {
            set_display(new_display_string != "0");
         }
         catch(const std::logic_error& e)
         {
            std::cout << e.what() << std::endl;
         }
      }
   }

}


// std::string to_string(void) const method


std::string DataSet::to_string(void) const
{
   std::ostringstream buffer;

   buffer << "Data set object\n"
          << "Data file name: " << data_file_name << "\n"
          << "Header line: " << header_line << "\n"
          << "Separator: " << separator << "\n"
          << "Missing values label: " << missing_values_label << "\n"
          << "Data:\n" << data << "\n"
          << "Display: " << display << "\n"
          << variables.to_string()
          << instances.to_string()
          << missing_values.to_string();

   return(buffer.str());
}


// void print(void) const method


void DataSet::print(void) const
{
   if(display)
   {
      std::cout << to_string();
   }
}


// void print_summary(void) const method


void DataSet::print_summary(void) const
{
    if(display)
    {
        const size_t variables_number = variables.get_variables_number();
        const size_t instances_number = instances.get_instances_number();
        const size_t missing_values_number = missing_values.get_missing_values_number();

       std::cout << "Data set object summary:\n"
                 << "Number of variables: " << variables_number << "\n"
                 << "Number of instances: " << instances_number << "\n"
                 << "Number of missing values: " << missing_values_number << std::endl;
    }
}


// void save(const std::string&) const method


void DataSet::save(const std::string& file_name) const
{
   tinyxml2::XMLDocument* document = to_XML();

   document->SaveFile(file_name.c_str());

   delete document;
}


// void load(const std::string&) method


void DataSet::load(const std::string& file_name)
{
   tinyxml2::XMLDocument document;

   if(document.LoadFile(file_name.c_str()))
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n"
             << "void load(const std::string&) method.\n"
             << "Cannot load XML file " << file_name << ".\n";

      throw std::logic_error(buffer.str());
   }

   from_XML(document);
}


// void print_data(void) const method


void DataSet::print_data(void) const
{
   if(display)
   {
      std::cout << data << std::endl;
   }
}


// void print_data_preview(void) const method


void DataSet::print_data_preview(void) const
{
   if(display)
   {
       const size_t instances_number = instances.get_instances_number();

       if(instances_number > 0)
       {
          const Vector<double> first_instance = data.arrange_row(0);

          std::cout << "First instance:\n"
                    << first_instance << std::endl;
       }

       if(instances_number > 1)
       {
          const Vector<double> second_instance = data.arrange_row(1);

          std::cout << "Second instance:\n"
                    << second_instance << std::endl;
       }

       if(instances_number > 2)
       {
          const Vector<double> last_instance = data.arrange_row(instances_number-1);

          std::cout << "Instance " << instances_number << ":\n"
                    << last_instance << std::endl;
       }
    }
}


// void save_data(void) const method


void DataSet::save_data(void) const
{
   std::ofstream file(data_file_name.c_str());

   if(!file.is_open())
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n" 
             << "void save_data(void) const method.\n"
             << "Cannot open data file.\n";

      throw std::logic_error(buffer.str());   
   }
  
   if(header_line)
   {
       const Vector<std::string> variables_name = variables.arrange_names();

       file << variables_name << std::endl;
   }

   // Write data

   file << data;

   // Close file

   file.close();
}


// size_t get_column_index(const Vector< Vector<std::string> >&, const size_t) const method


size_t DataSet::get_column_index(const Vector< Vector<std::string> >& nominal_labels, const size_t column_index) const
{
    size_t variable_index = 0;

    for(size_t i = 0; i < column_index; i++)
    {
        if(nominal_labels[i].size() <= 2)
        {
            variable_index++;
        }
        else
        {
            variable_index += nominal_labels[i].size();
        }
    }

    return variable_index;
}


// void check_separator(const std::string&) method


void DataSet::check_separator(const std::string& line) const
{
    if(line.empty())
    {
        return;
    }

    const std::string separator_string = get_separator_string();

    if(line.find(separator_string) == std::string::npos)
    {
        std::ostringstream buffer;

        buffer << "OpenNN Exception: DataSet class.\n"
               << "void check_separator(const std::string&) method.\n"
               << "Separator '" << write_separator() << "' not found in data file " << data_file_name << ".\n";

        throw std::logic_error(buffer.str());
    }
}


// size_t count_data_file_columns_number(void) const method


size_t DataSet::count_data_file_columns_number(void) const
{
    std::ifstream file(data_file_name.c_str());

    std::string line;

    size_t columns_number = 0;

    while(file.good())
    {
        getline(file, line);

        if(separator != Tab)
        {
            std::replace(line.begin(), line.end(), '\t', ' ');
        }

        trim(line);

        if(line.empty())
        {
            continue;
        }

        check_separator(line);

        columns_number = count_tokens(line);
    }

    file.close();

    return columns_number;

}


// void check_header_line(void) method


void DataSet::check_header_line(void)
{
    std::ifstream file(data_file_name.c_str());

    std::string line;
    Vector<std::string> tokens;

    while(file.good())
    {
        getline(file, line);

        if(separator != Tab)
        {
            std::replace(line.begin(), line.end(), '\t', ' ');
        }

        trim(line);

        if(line.empty())
        {
            continue;
        }

        break;
    }

    file.close();

    check_separator(line);

    tokens = get_tokens(line);

    if(header_line && is_not_numeric(tokens))
    {
        return;
    }
    if(header_line && is_numeric(tokens))
    {
        if(display)
        {
            std::cout << "OpenNN Warning: DataSet class.\n"
                      << "void check_header_line(void) method.\n"
                      << "First line of data file interpreted as not header.\n";
        }

        header_line = false;
    }
    else if(header_line && is_mixed(tokens))
    {
        std::ostringstream buffer;

        buffer << "OpenNN Exception: DataSet class.\n"
               << "void check_header_line(void) method.\n"
               << "Header line contains numeric values: \n"
               << line << "\n";

        throw std::logic_error(buffer.str());
    }
    else if(!header_line && is_not_numeric(tokens))
    {
        if(display)
        {
            std::cout << "OpenNN Warning: DataSet class.\n"
                      << "void check_header_line(void) method.\n"
                      << "First line of data file interpreted as header.\n";
        }

        header_line = true;
    }
}


// Vector<std::string> read_header_line(void) const method


Vector<std::string> DataSet::read_header_line(void) const
{
    Vector<std::string> header_line;

    std::string line;

    std::ifstream file(data_file_name.c_str());

    // First line

    while(file.good())
    {
        getline(file, line);

        if(separator != Tab)
        {
            std::replace(line.begin(), line.end(), '\t', ' ');
        }

        trim(line);

        if(line.empty())
        {
            continue;
        }

        check_separator(line);

        header_line = get_tokens(line);

        break;
    }

    file.close();

    return header_line;
}


// void read_instance(const std::string&, const Vector< Vector<std::string> >&, const size_t&) method


void DataSet::read_instance(const std::string& line, const Vector< Vector<std::string> >& nominal_labels, const size_t& instance_index)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    const size_t instances_number = instances.get_instances_number();

    if(instance_index >= instances_number)
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception: DataSet class.\n"
              << "void read_instance(const std::string&, const Vector< Vector<std::string> >&, const size_t&) method.\n"
              << "Index of instance (" << instance_index << ") must be less than number of instances (" << instances_number << ").\n";

       throw std::logic_error(buffer.str());
    }

    #endif

    const Vector<std::string> tokens = get_tokens(line);

    #ifndef NDEBUG

    if(tokens.size() != nominal_labels.size())
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception: DataSet class.\n"
              << "void read_instance(const std::string&, const Vector< Vector<std::string> >&, const size_t&) method.\n"
              << "Size of tokens (" << tokens.size() << ") must be equal to size of names (" << nominal_labels.size() << ").\n";

       throw std::logic_error(buffer.str());
    }

    #endif

    size_t column_index;

    for(size_t j = 0; j < tokens.size(); j++)
    {
        column_index = get_column_index(nominal_labels, j);

        if(nominal_labels[j].size() == 0) // Numeric variable
        {
            if(tokens[j] != missing_values_label) // No missing values
            {
                data(instance_index, column_index) = atof(tokens[j].c_str());
            }
            else // Missing values
            {
                data(instance_index, column_index) = -99.9;

                missing_values.append(instance_index, column_index);
            }
        }

        else if(nominal_labels[j].size() == 2) // Binary variable
        {
            if(tokens[j] != missing_values_label) // No missing values
            {
                if(tokens[j] == "false" || tokens[j] == "False"||  tokens[j] == "FALSE"
                || tokens[j] == "negative"|| tokens[j] == "Negative"|| tokens[j] == "NEGATIVE")
                {
                    data(instance_index, column_index) = 0.0;
                }
                else if(tokens[j] == "true" || tokens[j] == "True"||  tokens[j] == "TRUE"
                || tokens[j] == "positive"|| tokens[j] == "Positive"|| tokens[j] == "POSITIVE")
                {
                    data(instance_index, column_index) = 1.0;
                }
                else if(tokens[j] == nominal_labels[j][0])
                {
                    data(instance_index, column_index) = 0.0;
                }
                else if(tokens[j] == nominal_labels[j][1])
                {
                    data(instance_index, column_index) = 1.0;
                }
                else
                {
                    std::ostringstream buffer;

                    buffer << "OpenNN Exception: DataSet class.\n"
                           << "void read_instance(const std::string&, const Vector< Vector<std::string> >&, const size_t&) method.\n"
                           << "Unknown token binary value.\n";

                    throw std::logic_error(buffer.str());
                }
            }
            else // Missing values
            {
                data(instance_index, column_index) = -99.9;

                missing_values.append(instance_index, column_index);
            }
        }

        else // Nominal variable
        {
            if(tokens[j] != missing_values_label)
            {
                for(size_t k = 0; k < nominal_labels[j].size(); k++)
                {
                    if(tokens[j] == nominal_labels[j][k])
                    {
                        data(instance_index, column_index+k) = 1.0;
                    }
                    else
                    {
                        data(instance_index, column_index+k) = 0.0;
                    }
                }
            }
            else // Missing values
            {
                for(size_t k = 0; k < nominal_labels[j].size(); k++)
                {
                    data(instance_index, column_index+k) = -99.9;

                    missing_values.append(instance_index, column_index+k);
                }
            }
        }
    }       
}


// Vector< Vector<std::string> > set_from_data_file(void) method


Vector< Vector<std::string> > DataSet::set_from_data_file(void)
{
    const size_t columns_number = count_data_file_columns_number();

    Vector< Vector<std::string> > nominal_labels(columns_number);

    std::string line;
    Vector<std::string> tokens;

    bool numeric;

    check_header_line();

    int instances_count;

    if(header_line)
    {
        instances_count = -1;
    }
    else
    {
        instances_count = 0;
    }

    std::ifstream file(data_file_name.c_str());   

    // Rest of lines

    while(file.good())
    {
        getline(file, line);

        if(separator != Tab)
        {
            std::replace(line.begin(), line.end(), '\t', ' ');
        }

        trim(line);

        if(line.empty())
        {
            continue;
        }

        if(header_line && instances_count == -1)
        {
            instances_count = 0;

            continue;
        }

        check_separator(line);

        tokens = get_tokens(line);

        if(tokens.size() != columns_number)
        {
            std::ostringstream buffer;

            buffer << "OpenNN Exception: DataSet class.\n"
                   << "Vector< Vector<std::string> > DataSet::set_from_data_file(void).\n"
                   << "Row " << instances_count << ": Size of tokens (" << tokens.size() << ") is not equal to "
                   << "number of columns (" << columns_number << ").\n";

            throw std::logic_error(buffer.str());
        }

        instances_count++;

        for(size_t j = 0; j < columns_number; j++)
        {
            numeric = is_numeric(tokens[j]);

            if(!numeric
            && tokens[j] != missing_values_label
            && !nominal_labels[j].contains(tokens[j]))
            {
                nominal_labels[j].push_back(tokens[j]);
            }
        }
    }

    file.close();

    size_t variables_count = 0;

    for(size_t i = 0; i < columns_number; i++)
    {
        if(nominal_labels[i].size() == 0 || nominal_labels[i].size() == 2)
        {
            variables_count++;
        }
        else
        {
            variables_count += nominal_labels[i].size();
        }
    }

    // Fix label case

    for(size_t i = 0; i < columns_number; i++)
    {
        if(nominal_labels[i].size() == instances_count)
        {
            std::ostringstream buffer;

            buffer << "OpenNN Exception: DataSet class.\n"
                   << "Vector< Vector<std::string> > DataSet::set_from_data_file(void).\n"
                   << "Column " << i << ": All elements are nominal and different. It contains meaningless data.\n";

            throw std::logic_error(buffer.str());
        }
    }

    // Set instances and variables number

    if(instances_count == 0 || variables_count == 0)
    {
        set();

        return(nominal_labels);
    }

    data.set(instances_count, variables_count);

    if(variables.get_variables_number() != variables_count)
    {
        variables.set(variables_count);

        if(nominal_labels[columns_number-1].size() > 2)
        {
            for(size_t i = variables_count-1; i >= variables_count - nominal_labels[columns_number-1].size(); i--)
            {
                variables.set_use(i, Variables::Target);
            }
        }
    }

    if(instances.get_instances_number() != instances_count)
    {
        instances.set(instances_count);
    }

    missing_values.set(instances.get_instances_number(), variables.get_variables_number());

    return(nominal_labels);
}


// void read_from_data_file(Vector< Vector<std::string> >&) method


void DataSet::read_from_data_file(const Vector< Vector<std::string> >& nominal_labels)
{
    std::ifstream file(data_file_name.c_str());

    file.clear();
    file.seekg(0, std::ios::beg);

    std::string line;

    if(header_line)
    {
        while(file.good())
        {
            getline(file, line);

            if(separator != Tab)
            {
                std::replace(line.begin(), line.end(), '\t', ' ');
            }

            trim(line);

            if(line.empty())
            {
                continue;
            }

            break;
        }                
    }

    size_t i = 0;

//    #pragma omp parallel for private(i, line)

    while(file.good())
    {
        getline(file, line);

        if(separator != Tab)
        {
            std::replace(line.begin(), line.end(), '\t', ' ');
        }

        trim(line);

        if(line.empty())
        {
            continue;
        }

        // #pragma omp task

        read_instance(line, nominal_labels, i);
        i++;
    }

    file.close();
}


// Vector<std::string> arrange_time_series_prediction_names(const Vector<std::string>&) const method


Vector<std::string> DataSet::arrange_time_series_names(const Vector<std::string>&) const
{        
    Vector<std::string> time_series_prediction_names;
/*
    Vector< Vector<std::string> > new_names((1+columns_number)*lags_number);

    for(size_t i = 0; i < 1+lags_number; i++)
    {
        for(size_t j = 0; j < names.size(); j++)
        {
            new_names[i+j] = names[j];

            if(i != lags_number)
            {
                for(size_t k = 0; k < names[j].size();k++)
                {
                    new_names[i+j][k].append("_lag_").append(std::string::from_size_t(lags_number-i).c_str());
                }
            }
        }
    }
*/
    return(time_series_prediction_names);
}


// Vector<std::string> DataSet::arrange_autoassociation_names(const Vector<std::string>& names) const method


Vector<std::string> DataSet::arrange_autoassociation_names(const Vector<std::string>&) const
{
    Vector<std::string> autoassociation_names;

    return(autoassociation_names);
}


// void convert_time_series(void) method


void DataSet::convert_time_series(void)
{
    if(lags_number == 0)
    {
        return;
    }

    data.convert_time_series(lags_number);

    variables.convert_time_series(lags_number);

    instances.convert_time_series(lags_number);

    missing_values.convert_time_series(lags_number);
}


// void convert_autoassociation(void) method


void DataSet::convert_autoassociation(void)
{
    data.convert_autoassociation();

    variables.convert_autoassociation();

    missing_values.convert_autoassociation();
}


// void load_data(void) method


void DataSet::load_data(void)
{
    if(data_file_name.empty())
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception: DataSet class.\n"
              << "void load_data(void) method.\n"
              << "Data file name has not been set.\n";

       throw std::logic_error(buffer.str());
    }

    std::ifstream file(data_file_name.c_str());

    if(!file.is_open())
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception: DataSet class.\n"
              << "void load_data(void) method.\n"
              << "Cannot open data file: " << data_file_name << "\n";

       throw std::logic_error(buffer.str());
    }

    file.close();

    const Vector< Vector<std::string> > nominal_labels = set_from_data_file();

    read_from_data_file(nominal_labels);

    // Variables name

    Vector<std::string> columns_name;

    if(header_line)
    {
        columns_name = read_header_line();
    }
    else
    {
        for(unsigned i = 0; i < nominal_labels.size(); i++)
        {
            std::ostringstream buffer;

            buffer << "variable_" << i;

            columns_name.push_back(buffer.str());
        }
    }

    variables.set_names(columns_name, nominal_labels);

    // Angular variables

    if(!angular_variables.empty())
    {
        convert_angular_variables();
    }

    // Time series

    if(lags_number != 0)
    {
        convert_time_series();
    }

    // Autoassociation

    if(autoassociation)
    {
        convert_autoassociation();
    }
}


// void load_time_series_data(void) method

/*
void DataSet::load_time_series_data(void)
{
    if(lags_number <= 0)
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception: DataSet class.\n"
              << "void load_time_series_data(void) const method.\n"
              << "Number of lags (" << lags_number << ") must be greater than zero.\n";

       throw std::logic_error(buffer.str());
    }


    if(header)
    {
//        Vector<std::string> columns_name;

//        variables.set_names(names);
    }


    const Matrix<double> time_series_data(data_file_name);

    const size_t rows_number = time_series_data.get_rows_number();
    const size_t columns_number = time_series_data.get_columns_number();

    const size_t instances_number = rows_number - lags_number;
    const size_t variables_number = columns_number*(1 + lags_number);

    set(variables_number, instances_number);

    Vector<double> row(rows_number);

    for(size_t i = 0; i < instances_number; i++)
    {
        row = time_series_data.arrange_row(i);

        for(size_t j = 1; j <= lags_number; j++)
        {
            row = row.assemble(time_series_data.arrange_row(i+j));
        }

        data.set_row(i, row);
    }

    // Variables

    Vector<Variables::Use> uses(variables_number);

    std::fill(uses.begin(), uses.begin()+lags_number*variables_number/(lags_number+1)-1, Variables::Use::Input);
    std::fill(uses.begin()+lags_number*variables_number/(lags_number+1), uses.end(), Variables::Use::Target);

    variables.set_uses(uses);

}
*/

// Vector<size_t> calculate_target_class_distribution(void) const method


Vector<size_t> DataSet::calculate_target_class_distribution(void) const
{ 
   // Control sentence (if debug)

   const size_t instances_number = instances.get_instances_number();
   const size_t targets_number = variables.count_targets_number();
   const Vector<size_t> targets_indices = variables.arrange_targets_indices();

   Vector<size_t> class_distribution;

   if(targets_number == 1) // Two classes
   {
      class_distribution.set(2, 0);

      size_t target_index = targets_indices[0];

      for(size_t instance_index = 0; instance_index < instances_number; instance_index++)
      {
          if(instances.get_use(instance_index) != Instances::Unused)
          {
             if(data(instance_index,target_index) < 0.5)
             {
                class_distribution[0]++;
             }
             else
             {
                class_distribution[1]++;
             }
          }
      }
   }
   else // More than two classes
   {
      class_distribution.set(targets_number, 0);
   
      for(size_t i = 0; i < instances_number; i++)
      {
          if(instances.get_use(i) != Instances::Unused)
          {
             for(size_t j = 0; j < targets_number; j++)
             {
                if(data(i,targets_indices[j]) > 0.5)
                {
                   class_distribution[j]++;
                }
             }
          }
      }
   }

   // Check data consistency

   const size_t used_instances_number = instances.count_used_instances_number();

   if(class_distribution.calculate_sum() != used_instances_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: DataSet class.\n" 
             << "Vector<size_t> calculate_target_class_distribution(void) const method.\n"
             << "Sum of class distributions (" << class_distribution << ") is not equal to "
             << "number of used instances (" << used_instances_number << ")." << std::endl;

      throw std::logic_error(buffer.str());   
   }

   return(class_distribution);
}


// Vector<double> calculate_distances(void) const method


Vector<double> DataSet::calculate_distances(void) const
{
    const Matrix<double> data_statistics_matrix = calculate_data_statistics_matrix();

    const Vector<double> means = data_statistics_matrix.arrange_column(2);
    const Vector<double> standard_deviations = data_statistics_matrix.arrange_column(3);

    const size_t instances_number = instances.get_instances_number();
    Vector<double> distances(instances_number);

    const size_t variables_number = variables.get_variables_number();
    Vector<double> instance(variables_number);

    int i = 0;

    #pragma omp parallel for private(i, instance)

    for(i = 0; i < (int)instances_number; i++)
    {
        instance = data.arrange_row(i);

        distances[i] = (instance-means/standard_deviations).calculate_norm();
    }

    return(distances);
}


// void DataSet::balance_data(const double&) method


void DataSet::balance_data(const double&)
{
/*
    const size_t instances_number = instances.count_used_instances_number();

    const Vector<double> distances = calculate_distances();

    // Sorted performance vector

    const Vector<size_t> rank = distances.calculate_greater_rank();

    // Perform linear ranking fitness assignment
    // Cannot do that without loop because of different types of fitness and rank vectors

    Vector<double> fitness(instances_number);

    const double selective_pressure = 1.5;

    for(size_t i = 0; i < instances_number; i++)
    {
       fitness[i] = selective_pressure*rank[i];
    }

    // Set selection vector to false

//    Vector<double> selection(instances_number, false);

    const size_t selection_target = instances_number/2;

    if(selection_target <= 0)
    {
        return;
    }

    // Cumulative fitness vector

    const Vector<double> cumulative_fitness = fitness.calculate_cumulative();

    const double fitness_sum = fitness.calculate_sum();

    // Select individuals until the desired number of selections is obtained

    size_t selection_count = 0;

    double pointer;

    while(selection_count != selection_target)
    {
       // Random number between 0 and total cumulative fitness

       pointer = calculate_random_uniform(0, fitness_sum);

       // Perform selection

       if(pointer < cumulative_fitness[0])
       {
          if(instances.is_used(0))
          {
             instances.set_use(0, "Unused");
             selection_count++;
          }
       }
       else
       {
           for(size_t i = 1; i < instances_number; i++)
           {
              if(pointer < cumulative_fitness[i] && pointer >= cumulative_fitness[i-1])
              {
                 if(instances.is_used(i))
                 {
                    instances.set_use(0, "Unused");
                    selection_count++;
                 }
              }
           }
       }
    }

    // Control sentence (if debug)

    #ifndef NDEBUG

    if(instances.count_used_instances_number() != instances_number/2)
    {
        std::ostringstream buffer;

        buffer << "OpenNN Exception: DataSet class.\n"
               << "void perform_roulette_wheel_selection(void) method.\n"
               << "Selection count (" << instances.count_used_instances_number() << ") is not equal to half instances number (" << instances_number/2 << ").\n";

        throw std::logic_error(buffer.str());
    }

    #endif
*/
}


// void balance_target_class_distribution(void) method


void DataSet::balance_target_class_distribution(void)
{
/*
    const size_t instances_number = instances.count_used_instances_number();

    const size_t targets_number = variables.count_targets_number();

    const Vector<size_t> targets_indices = variables.arrange_targets_indices();

//    const size_t minimum = target_class_distribution.calculate_minimum();

//    const Matrix<double> target_data = arrange_target_data();

    Vector<size_t> target_class_distribution = calculate_target_class_distribution();

    size_t instance_index;

    Vector<double> instance;

    if(targets_number == 1) // Two classes
    {
        const size_t target_index = targets_indices[0];

        while(target_class_distribution[0] != target_class_distribution[1]);
        {
            instance_index = (size_t)calculate_random_uniform(0.0, instances_number);

            instance = get_instance(instance_index);

            if(instances.is_used(instance_index))
            {
                if(instance[target_index] == 0
                && target_class_distribution[0] > target_class_distribution[1])
                {
                    instances.set_use(instance_index, Instances::Unused);
                }
                else if(instance[target_index] == 1
                && target_class_distribution[1] > target_class_distribution[0])
                {
                    instances.set_use(instance_index, Instances::Unused);
                }
            }
        }
    }
*/
}


// bool has_data(void) const method


bool DataSet::has_data(void) const
{
    if(data.empty())
    {
        return(false);
    }
    else
    {
        return(true);
    }
}


// Vector<size_t> filter_data(const Vector<double>&, const Vector<double>&) method


Vector<size_t> DataSet::filter_data(const Vector<double>& minimums, const Vector<double>& maximums)
{
    const size_t variables_number = variables.get_variables_number();

    // Control sentence (if debug)

    #ifndef NDEBUG

    if(minimums.size() != variables_number)
    {
        std::ostringstream buffer;

        buffer << "OpenNN Exception: DataSet class.\n"
               << "Vector<size_t> filter_data(const Vector<double>&, const Vector<double>&) method.\n"
               << "Size of minimums (" << minimums.size() << ") is not equal to number of variables (" << variables_number << ").\n";

        throw std::logic_error(buffer.str());
    }

    if(maximums.size() != variables_number)
    {
        std::ostringstream buffer;

        buffer << "OpenNN Exception: DataSet class.\n"
               << "Vector<size_t> filter_data(const Vector<double>&, const Vector<double>&) method.\n"
               << "Size of maximums (" << maximums.size() << ") is not equal to number of variables (" << variables_number << ").\n";

        throw std::logic_error(buffer.str());
    }

    #endif

    const Vector< Vector<size_t> > missing_indices = missing_values.arrange_missing_indices();

    Vector<size_t> filtered_indices;

    const size_t instances_number = instances.get_instances_number();

    for(size_t i = 0; i < instances_number; i++)
    {
        for(size_t j = 0; j < variables_number; j++)
        {
            if(missing_values.is_missing_value(i, j))
            {
                continue;
            }

            if(data(i,j) < minimums[j] || data(i,j) > maximums[j])
            {
                if(instances.is_used(i))
                {
                    filtered_indices.push_back(i);

                    instances.set_use(i, Instances::Unused);
                }
            }
        }
    }

    return(filtered_indices);
}


// void convert_angular_variable_degrees(const size_t&) method


void DataSet::convert_angular_variable_degrees(const size_t& variable_index)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    const size_t variables_number = variables.get_variables_number();

    if(variable_index >= variables_number)
    {
        std::ostringstream buffer;

        buffer << "OpenNN Exception: DataSet class.\n"
               << "void convert_angular_variable_degrees(const size_t&) method.\n"
               << "Index of variable (" << variable_index << ") must be less than number of variables (" << variables_number << ").\n";

        throw std::logic_error(buffer.str());
    }

    #endif

    Vector<Variables::Item> items = variables.get_items();

    Variables::Item sin_item = items[variable_index];
    prepend("sin_", sin_item.name);

    Variables::Item cos_item = items[variable_index];
    prepend("cos_", cos_item.name);

    items[variable_index] = sin_item;
    items = items.insert_element(variable_index, cos_item);

    variables.set_items(items);

    data.convert_angular_variables_degrees(variable_index);

}


// void convert_angular_variable_radians(const size_t&) method


void DataSet::convert_angular_variable_radians(const size_t& variable_index)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    const size_t variables_number = variables.get_variables_number();

    if(variable_index >= variables_number)
    {
        std::ostringstream buffer;

        buffer << "OpenNN Exception: DataSet class.\n"
               << "void convert_angular_variable_radians(const size_t&) method.\n"
               << "Index of variable (" << variable_index << ") must be less than number of variables (" << variables_number << ").\n";

        throw std::logic_error(buffer.str());
    }

    #endif

    Vector<Variables::Item> items = variables.get_items();

    Variables::Item sin_item = items[variable_index];
    prepend("sin_", sin_item.name);

    Variables::Item cos_item = items[variable_index];
    prepend("cos_", cos_item.name);

    items[variable_index] = sin_item;
    items = items.insert_element(variable_index, cos_item);

    variables.set_items(items);

    data.convert_angular_variables_radians(variable_index);

}


// void convert_angular_variables_degrees(const Vector<size_t>&)


void DataSet::convert_angular_variables_degrees(const Vector<size_t>& indices)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    const size_t variables_number = variables.get_variables_number();

    for(size_t i = 0; i < indices.size(); i++)
    {
        if(indices[i] >= variables_number)
        {
            std::ostringstream buffer;

            buffer << "OpenNN Exception: DataSet class.\n"
                   << "void convert_angular_variables_degrees(const Vector<size_t>&) method.\n"
                   << "Index (" << i << ") must be less than number of variables (" << variables_number << ").\n";

            throw std::logic_error(buffer.str());
        }
    }

    #endif

    size_t size = indices.size();

    unsigned count = 0;

    size_t index;

    for(size_t i = 0; i < size; i++)
    {
        index = indices[i]+count;

        convert_angular_variable_degrees(index);

        count++;
    }
}


// void convert_angular_variables_radians(const Vector<size_t>&)


void DataSet::convert_angular_variables_radians(const Vector<size_t>& indices)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    const size_t variables_number = variables.get_variables_number();

    for(size_t i = 0; i < indices.size(); i++)
    {
        if(indices[i] >= variables_number)
        {
            std::ostringstream buffer;

            buffer << "OpenNN Exception: DataSet class.\n"
                   << "void convert_angular_variables_radians(const Vector<size_t>&) method.\n"
                   << "Index (" << i << ") must be less than number of variables (" << variables_number << ").\n";

            throw std::logic_error(buffer.str());
        }
    }

    #endif

    size_t size = indices.size();

    unsigned count = 0;

    size_t index;

    for(size_t i = 0; i < size; i++)
    {
        index = indices[i]+count;

        convert_angular_variable_radians(index);

        count++;
    }
}


// void convert_angular_variables(void) method


void DataSet::convert_angular_variables(void)
{
    switch(angular_units)
    {
       case DataSet::Radians:
       {
            convert_angular_variables_radians(angular_variables);
       }
       break;

       case DataSet::Degrees:
       {
            convert_angular_variables_degrees(angular_variables);
       }
       break;

       default:
       {
          std::ostringstream buffer;

          buffer << "OpenNN Exception: DataSet class.\n"
                 << "void convert_angular_variables(void) method.\n"
                 << "Unknown angular units.\n";

          throw std::logic_error(buffer.str());
       }
       break;
    }

}


// void scrub_missing_values_unuse(void) method


void DataSet::scrub_missing_values_unuse(void)
{
    const Vector<size_t> missing_instances = missing_values.arrange_missing_instances();

    for(size_t i = 0; i < missing_instances.size(); i++)
    {
        instances.set_use(missing_instances[i], Instances::Unused);
    }
}


// void scrub_missing_values_mean(void) method


void DataSet::scrub_missing_values_mean(void)
{
    const Vector< Vector<size_t> > missing_indices = missing_values.arrange_missing_indices();

    Vector<double> means = data.calculate_mean_missing_values(missing_indices);

    const size_t variables_number = variables.get_variables_number();

    size_t instance_index;

    for(size_t i = 0; i < variables_number; i++)
    {
        for(size_t j = 0; j < missing_indices[i].size(); j++)
        {
            instance_index = missing_indices[i][j];
            data(instance_index, i) = means[i];
        }
    }
}


// void scrub_missing_values(void) method


void DataSet::scrub_missing_values(void)
{
    const MissingValues::ScrubbingMethod scrubbing_method = missing_values.get_scrubbing_method();

    switch(scrubbing_method)
    {
       case MissingValues::Unuse:
       {
            scrub_missing_values_unuse();
       }
       break;

       case MissingValues::Mean:
       {
            scrub_missing_values_mean();
       }
       break;

       default:
       {
          std::ostringstream buffer;

          buffer << "OpenNN Exception: DataSet class\n"
                 << "void scrub_missing_values(void) method.\n"
                 << "Unknown scrubbing method.\n";

          throw std::logic_error(buffer.str());
       }
       break;
    }
}


// size_t count_tokens(std::string& str) const method


size_t DataSet::count_tokens(std::string& str) const
{
//    if(!(this->find(separator) != std::string::npos))
//    {
//        std::ostringstream buffer;
//
//        buffer << "OpenNN Exception:\n"
//               << "std::string class.\n"
//               << "inline size_t count_tokens(const std::string&) const method.\n"
//               << "Separator not found in string: \"" << separator << "\".\n";
//
//        throw std::logic_error(buffer.str());
//    }

    trim(str);

    size_t tokens_count = 0;

    // Skip delimiters at beginning.

    const std::string separator_string = get_separator_string();

    std::string::size_type last_pos = str.find_first_not_of(separator_string, 0);

    // Find first "non-delimiter".

    std::string::size_type pos = str.find_first_of(separator_string, last_pos);

    while (std::string::npos != pos || std::string::npos != last_pos)
    {
        // Found a token, add it to the vector

        tokens_count++;

        // Skip delimiters.  Note the "not_of"

        last_pos = str.find_first_not_of(separator_string, pos);

        // Find next "non-delimiter"

        pos = str.find_first_of(separator_string, last_pos);
    }

    return(tokens_count);
}



Vector<std::string> DataSet::get_tokens(const std::string& str) const
{   
    const std::string new_string = get_trimmed(str);

    Vector<std::string> tokens;

    const std::string separator_string = get_separator_string();

    // Skip delimiters at beginning.

    std::string::size_type lastPos = new_string.find_first_not_of(separator_string, 0);

    // Find first "non-delimiter"

    std::string::size_type pos = new_string.find_first_of(separator_string, lastPos);

    while(std::string::npos != pos || std::string::npos != lastPos)
    {
        // Found a token, add it to the vector

        tokens.push_back(new_string.substr(lastPos, pos - lastPos));

        // Skip delimiters. Note the "not_of"

        lastPos = new_string.find_first_not_of(separator_string, pos);

        // Find next "non-delimiter"

        pos = new_string.find_first_of(separator_string, lastPos);
    }

    for(size_t i = 0; i < tokens.size(); i++)
    {
        trim(tokens[i]);
    }

    return(tokens);
}


// bool is_numeric(const std::string&) const method


bool DataSet::is_numeric(const std::string& str) const
{
    std::istringstream iss(str.data());

    double dTestSink;

    iss >> dTestSink;

    // was any input successfully consumed/converted?

    if(!iss)
    {
        return false;
    }

    // was all the input successfully consumed/converted?

    return(iss.rdbuf()->in_avail() == 0);
}


// void DataSet::trim(std::string&) const method


void DataSet::trim(std::string& str) const
{
    //prefixing spaces

    str.erase(0, str.find_first_not_of(' '));

    //surfixing spaces

    str.erase(str.find_last_not_of(' ') + 1);
}



std::string DataSet::get_trimmed(const std::string& str) const
{
    std::string output(str);

    //prefixing spaces

    output.erase(0, output.find_first_not_of(' '));

    //surfixing spaces

    output.erase(output.find_last_not_of(' ') + 1);

    return(output);
}


// std::string prepend(const std::string&, const std::string&) const method


std::string DataSet::prepend(const std::string& pre, const std::string& str) const
{
    std::ostringstream buffer;

    buffer << pre << str;

    return(buffer.str());
}


// bool is_numeric(const Vector<std::string>&) const


bool DataSet::is_numeric(const Vector<std::string>& v) const
{
    for(size_t i = 0; i < v.size(); i++)
    {
        if(!is_numeric(v[i]))
        {
            return false;
        }
    }

    return true;
}


// bool is_not_numeric(const Vector<std::string>&) const


bool DataSet::is_not_numeric(const Vector<std::string>& v) const
{
    for(size_t i = 0; i < v.size(); i++)
    {
        if(is_numeric(v[i]))
        {
            return false;
        }
    }

    return true;
}


// bool is_mixed(const Vector<std::string>&) const


bool DataSet::is_mixed(const Vector<std::string>& v) const
{
    unsigned count_numeric = 0;
    unsigned count_not_numeric = 0;

    for(size_t i = 0; i < v.size(); i++)
    {
        if(is_numeric(v[i]))
        {
            count_numeric++;
        }
        else
        {
            count_not_numeric++;
        }
    }

    if(count_numeric > 0 && count_not_numeric > 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

}

// OpenNN: Open Neural Networks Library.
// Copyright (c) 2005-2015 Roberto Lopez.
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA