variables.cpp

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

// OpenNN includes

#include "variables.h"

#include<limits>
#include<climits>


namespace OpenNN
{

// DEFAULT CONSTRUCTOR


Variables::Variables(void)
{
   set();  
}


// VARIABLES NUMBER CONSTRUCTOR


Variables::Variables(const size_t& new_variables_number)
{
   set(new_variables_number);
}


// INPUT AND TARGET VARIABLES NUMBERS CONSTRUCTOR


Variables::Variables(const size_t& new_inputs_number, const size_t& new_targets_number)
{
   set(new_inputs_number, new_targets_number);
}


// XML CONSTRUCTOR


Variables::Variables(const tinyxml2::XMLDocument& variables_document)
{
   set(variables_document);
}


// COPY CONSTRUCTOR


Variables::Variables(const Variables& other_variables)
{
   // Items

   items = other_variables.items;

   // Utilities

   display = other_variables.display;
}


// DESTRUCTOR


Variables::~Variables(void)
{
}


// ASSIGNMENT OPERATOR


Variables& Variables::operator=(const Variables& other_variables)
{
   if(this != &other_variables) 
   {
      // Items

      items = other_variables.items;

      // Utilities

      display = other_variables.display;
   }

   return(*this);
}


// EQUAL TO OPERATOR

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


bool Variables::operator == (const Variables& other_variables) const
{
   if(/*items == other_variables.items
   &&*/ display == other_variables.display)
   {
      return(true);
   }
   else
   {
      return(false);
   }
}


// METHODS

// const Vector<Item>& get_items(void) const method


const Vector<Variables::Item>& Variables::get_items(void) const
{
    return(items);
}


// const Item& get_item(const size_t&) const method


const Variables::Item& Variables::get_item(const size_t& i) const
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    const size_t variables_number = get_variables_number();

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

       buffer << "OpenNN Exception: Variables class.\n"
              << "const Item& get_item(const size_t&) method.\n"
              << "Index of variable must be less than number of variables.\n";

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

    #endif

    return(items[i]);
}


// bool empty(void) const method


bool Variables::empty(void) const
{
    if(items.empty())
    {
        return(true);
    }
    else
    {
        return(false);
    }
}


// size_t count_used_variables_number(void) const method


size_t Variables::count_used_variables_number(void) const
{
    const size_t variables_number = get_variables_number();

    const size_t unused_variables_number = count_unused_variables_number();

    return(variables_number - unused_variables_number);
}


// size_t count_unused_variables_number(void) const method


size_t Variables::count_unused_variables_number(void) const
{
   const size_t variables_number = get_variables_number();

   size_t count = 0;

   for(size_t i = 0; i < variables_number; i++)
   {
      if(items[i].use == Unused)
      {
         count++;
      }
   }

   return(count);
}


// size_t count_inputs_number(void) const method


size_t Variables::count_inputs_number(void) const
{
   const size_t variables_number = get_variables_number();

   size_t count = 0;

   for(size_t i = 0; i < variables_number; i++)
   {
      if(items[i].use == Input)
      {
         count++;
      }
   }

   return(count);
}


// size_t count_targets_number(void) const method


size_t Variables::count_targets_number(void) const
{
   const size_t variables_number = get_variables_number();

   size_t count = 0;

   for(size_t i = 0; i < variables_number; i++)
   {
      if(items[i].use == Target)
      {
         count++;
      }
   }

   return(count);
}


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


Vector<size_t> Variables::count_uses(void) const
{
    Vector<size_t> count(3, 0);

    const size_t variables_number = get_variables_number();

    for(size_t i = 0; i < variables_number; i++)
    {
        if(items[i].use == Input)
        {
           count[0]++;
        }
        else if(items[i].use == Target)
        {
           count[1]++;
        }
        else
        {
           count[2]++;
        }
    }

    return(count);
}


// Vector<Use> arrange_uses(void) const method


Vector<Variables::Use> Variables::arrange_uses(void) const
{
    const size_t variables_number = get_variables_number();

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

    for(size_t i = 0; i < variables_number; i++)
    {
        uses[i] = items[i].use;
    }

   return(uses);
}


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


Vector<std::string> Variables::write_uses(void) const
{
   const size_t variables_number = get_variables_number();

   Vector<std::string> uses_string(variables_number);

   for(size_t i = 0; i < variables_number; i++)
   {
      if(items[i].use == Unused)
      {   
         uses_string[i] = "Unused";
      }
      else if(items[i].use == Input)
      {   
         uses_string[i] = "Input";
      }
      else if(items[i].use == Target)
      {   
         uses_string[i] = "Target";
      }
      else
      {
         std::ostringstream buffer;

         buffer << "OpenNN Exception Variables class.\n"
                << "Vector<std::string> write_uses(void) const method.\n"
                << "Unknown use.\n";
 
         throw std::logic_error(buffer.str());
      }
   }

   return(uses_string);
}


// const Use& get_use(const size_t&) const method


const Variables::Use& Variables::get_use(const size_t& i) const
{
    return(items[i].use);
}


// std::string write_use(const size_t&) const method


std::string Variables::write_use(const size_t& i) const
{
    if(items[i].use == Unused)
    {
       return("Unused");
    }
    else if(items[i].use == Input)
    {
       return("Input");
    }
    else if(items[i].use == Target)
    {
       return("Target");
    }
    else
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception Variables class.\n"
              << "std::string write_use(const size_t&) const method.\n"
              << "Unknown use.\n";

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


// bool is_used(const size_t&) const method


bool Variables::is_used(const size_t& index) const
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    const size_t variables_number = get_variables_number();

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

       buffer << "OpenNN Exception: Variables class.\n"
              << "bool is_used(const size_t&) const method.\n"
              << "Index of variable must be less than number of variables.\n";

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

    #endif

    if(items[index].use == Variables::Unused)
    {
        return(false);
    }
    else
    {
        return(true);
    }
}



// Matrix<std::string> arrange_information(void) const method


Matrix<std::string> Variables::arrange_information(void) const
{
    const size_t variables_number = get_variables_number();

    Matrix<std::string> information(variables_number, 4);

    for(size_t i = 0; i < variables_number; i++)
    {
        information(i,0) = items[i].name;
        information(i,1) = items[i].units;
        information(i,2) = items[i].description;
        information(i,3) = write_use(i);
    }

    return(information);
}


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


Vector<size_t> Variables::arrange_inputs_indices(void) const
{
   const size_t variables_number = get_variables_number();
   const size_t inputs_number = count_inputs_number();

   Vector<size_t> inputs_indices(inputs_number);

   size_t index = 0;

   for(size_t i = 0; i < variables_number; i++)
   {
      if(items[i].use == Input)
      {
         inputs_indices[index] = i;
         index++;
      }
   }

   return(inputs_indices);
}


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


Vector<size_t> Variables::arrange_targets_indices(void) const
{
   const size_t variables_number = get_variables_number();
   const size_t targets_number = count_targets_number();

   Vector<size_t> targets_indices(targets_number);

   size_t index = 0;

   for(size_t i = 0; i < variables_number; i++)
   {
      if(items[i].use == Target)
      {
         targets_indices[index] = i;
         index++;
      }
   }

   return(targets_indices);
}


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


Vector<std::string> Variables::arrange_names(void) const
{
   const size_t variables_number = get_variables_number();

   Vector<std::string> names(variables_number);

   for(size_t i = 0; i < variables_number; i++)
   {
       names[i] = items[i].name;
   }

   return(names);
}


// std::string& get_name(size_t) method


const std::string& Variables::get_name(const size_t& i) const
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t variables_number = get_variables_number();

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

      buffer << "OpenNN Exception: Variables class.\n"
             << "std::string& get_name(size_t) method.\n"
             << "Index of variable must be less than number of variables.\n";

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

   #endif

   return(items[i].name);
}


// bool has_names(void) const method


bool Variables::has_names(void) const
{
    const size_t variables_number = get_variables_number();

    for(size_t i = 0; i < variables_number; i++)
    {
        if(items[i].name.empty())
        {
            return(false);
        }
    }

    return(true);
}



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


Vector<std::string> Variables::arrange_inputs_name(void) const
{
   const size_t inputs_number = count_inputs_number();

   const Vector<size_t> inputs_indices = arrange_inputs_indices();

   Vector<std::string> inputs_name(inputs_number);

   size_t index;

   for(size_t i = 0; i < inputs_number; i++)
   {        
      index = inputs_indices[i];

      inputs_name[i] = items[index].name;
   }

   return(inputs_name);
}


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


Vector<std::string> Variables::arrange_targets_name(void) const
{
   const size_t targets_number = count_targets_number();

   const Vector<size_t> targets_indices = arrange_targets_indices();

   Vector<std::string> targets_name(targets_number);

   size_t index;

   for(size_t i = 0; i < targets_number; i++)
   {        
      index = targets_indices[i];

      targets_name[i] = items[index].name;
   } 

   return(targets_name);
}


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


Vector<std::string> Variables::arrange_units(void) const
{
    const size_t variables_number = get_variables_number();

    Vector<std::string> units(variables_number);

    for(size_t i = 0; i < variables_number; i++)
    {
        units[i] = items[i].units;
    }

   return(units);
}


// const std::string& get_units(const size_t&) const method


const std::string& Variables::get_unit(const size_t& i) const
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t variables_number = get_variables_number();

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

      buffer << "OpenNN Exception: Variables class.\n"
             << "const std::string& get_units(const size_t&) const method.\n"
             << "Index of variable must be less than number of variables.\n";

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

   #endif

   return(items[i].units);
}


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


Vector<std::string> Variables::arrange_inputs_units(void) const
{
   const Vector<size_t> inputs_indices = arrange_inputs_indices();

   const size_t inputs_number = count_inputs_number();

   Vector<std::string> inputs_units(inputs_number);

   size_t index;

   for(size_t i = 0; i < inputs_number; i++)
   {
      index = inputs_indices[i];

      inputs_units[i] = items[index].units;
   }

   return(inputs_units);
}


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


Vector<std::string> Variables::arrange_targets_units(void) const
{
   const Vector<size_t> targets_indices = arrange_targets_indices();

   const size_t targets_number = count_targets_number();

   Vector<std::string> targets_units(targets_number);

   size_t index;

   for(size_t i = 0; i < targets_number; i++)
   {
      index = targets_indices[i];

      targets_units[i] = items[index].units;
   }

   return(targets_units);
}


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


Vector<std::string> Variables::arrange_descriptions(void) const
{
    const size_t variables_number = get_variables_number();

    Vector<std::string> descriptions(variables_number);

    for(size_t i = 0; i < variables_number; i++)
    {
        descriptions[i] = items[i].description;
    }

   return(descriptions);
}


// const std::string& get_description(const size_t&) const method


const std::string& Variables::get_description(const size_t& i) const
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t variables_number = get_variables_number();

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

      buffer << "OpenNN Exception: Variables class.\n"
             << "const std::string& get_description(const size_t&) const method.\n"
             << "Index of variable must be less than number of variables.\n";

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

   #endif

   return(items[i].description);
}


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


Vector<std::string> Variables::arrange_inputs_description(void) const
{
   const size_t inputs_number = count_inputs_number();

   const Vector<size_t> inputs_indices = arrange_inputs_indices();

   Vector<std::string> inputs_description(inputs_number);

   size_t index;

   for(size_t i = 0; i < inputs_number; i++)
   {
      index = inputs_indices[i];

      inputs_description[i] = items[index].description;
   }

   return(inputs_description);
}


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


Vector<std::string> Variables::arrange_targets_description(void) const
{
   const Vector<size_t> targets_indices = arrange_targets_indices();

   const size_t targets_number = count_targets_number();

   Vector<std::string> target_descriptions(targets_number);

   size_t index;

   for(size_t i = 0; i < targets_number; i++)
   {
      index = targets_indices[i];

      target_descriptions[i] = items[index].description;
   }

   return(target_descriptions);
}


// Matrix<std::string> arrange_inputs_information(void) const method


Matrix<std::string> Variables::arrange_inputs_information(void) const
{
    const size_t inputs_number = count_inputs_number();

    const Vector<size_t> inputs_indices = arrange_inputs_indices();

    size_t input_index;

    Matrix<std::string> inputs_information(inputs_number, 3);

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

        inputs_information(i,0) = items[input_index].name;
        inputs_information(i,1) = items[input_index].units;
        inputs_information(i,2) = items[input_index].description;
    }

    return(inputs_information);
}


// Matrix<std::string> arrange_targets_information(void) const method


Matrix<std::string> Variables::arrange_targets_information(void) const
{
    const size_t targets_number = count_targets_number();

    const Vector<size_t> targets_indices = arrange_targets_indices();

    size_t target_index;

    Matrix<std::string> targets_information(targets_number, 3);

    for(size_t i = 0; i < targets_number; i++)
    {
        target_index = targets_indices[i];

        targets_information(i,0) = items[target_index].name;
        targets_information(i,1) = items[target_index].units;
        targets_information(i,2) = items[target_index].description;
    }

    return(targets_information);
}


// const bool& get_display(void) const method


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


// void set(void) method


void Variables::set(void)
{
   set_variables_number(0); 

   set_default();
}


// void set(const size_t&) method


void Variables::set(const size_t& new_variables_number)
{
   set_variables_number(new_variables_number);

   set_default();
}


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


void Variables::set(const size_t& inputs_number, const size_t& targets_number)
{
   const size_t variables_number = inputs_number + targets_number;

   set_variables_number(variables_number);

   for(size_t i = 0; i < inputs_number; i++)
   {
      items[i].use = Input;
   }

   for(size_t i = inputs_number; i < variables_number; i++)
   {
      items[i].use = Target;
   }

   set_default();
}


// void set(const tinyxml2::XMLElement*) method


void Variables::set(const tinyxml2::XMLDocument& variables_document)
{
    set_default();

   from_XML(variables_document);
}


// void set_default(void) method


void Variables::set_default(void)
{
   display = true;
}


// void set_items(const Vector<Item>&) method


void Variables::set_items(const Vector<Item>& new_items)
{
    items = new_items;
}


// void set_uses(const Vector<Use>&) method 


void Variables::set_uses(const Vector<Variables::Use>& new_uses)
{
    const size_t variables_number = get_variables_number();

    for(size_t i = 0; i < variables_number; i++)
    {
        items[i].use = new_uses[i];
    }
}


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


void Variables::set_uses(const Vector<std::string>& new_uses)
{
   const size_t new_variables_number = new_uses.size();

   for(size_t i = 0; i < new_variables_number; i++)
   {   
      if(new_uses[i] == "Input")
      {   
         items[i].use = Input;
      }
      else if(new_uses[i] == "Target")
      {   
         items[i].use = Target;
      }
      else if(new_uses[i] == "Unused")
       {
          items[i].use = Unused;
       }
      else
      {
         std::ostringstream buffer;

         buffer << "OpenNN Exception Variables class.\n"
                << "void set_uses(const Vector<std::string>&) method.\n"
                << "Unknown use: " << new_uses[i] <<  "\n";
 
         throw std::logic_error(buffer.str());
      }
   }   
}


// void set_use(const size_t&, const Use&) method


void Variables::set_use(const size_t& i, const Use& new_use)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    const size_t variables_number = get_variables_number();

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

        buffer << "OpenNN Exception Variables class.\n"
               << "void set_use(const size_t&, const Use&) method.\n"
               << "Index of variable must be less than number of variables.\n";

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

    #endif

    items[i].use = new_use;
}


// void set_use(const size_t&, const std::string&) method


void Variables::set_use(const size_t& i, const std::string& new_use)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    const size_t variables_number = get_variables_number();

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

        buffer << "OpenNN Exception Variables class.\n"
               << "void set_use(const size_t&, const std::string&) method.\n"
               << "Index of variable must be less than number of variables.\n";

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

    #endif

    if(new_use == "Unused")
    {
       items[i].use = Unused;
    }
    else if(new_use == "Input")
    {
       items[i].use = Input;
    }
    else if(new_use == "Target")
    {
       items[i].use = Target;
    }
    else
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception Variables class.\n"
              << "void set_use(const std::string&) method.\n"
              << "Unknown use.\n";

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


// void set_input(void) method


void Variables::set_input(void)
{
    const size_t variables_number = get_variables_number();

    for(size_t i = 0; i < variables_number; i++)
    {
        items[i].use = Input;
    }
}


// void set_target(void) method


void Variables::set_target(void)
{
    const size_t variables_number = get_variables_number();

    for(size_t i = 0; i < variables_number; i++)
    {
        items[i].use = Target;
    }
}


// void set_default_uses(void) method


void Variables::set_default_uses(void)
{
   const size_t variables_number = get_variables_number();

   if(variables_number == 0)
   {
      return;
   }
   else if(variables_number == 1)
   {
      items[0].use = Unused;
   }
   else
   {
       set_input();

       items[variables_number-1].use = Target;
   }
}


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


void Variables::set_names(const Vector<std::string>& new_names)
{
    const size_t variables_number = get_variables_number();

   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t size = new_names.size();

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

      buffer << "OpenNN Exception: Variables class.\n"
             << "void set_names(const Vector<std::string>&) method.\n"
             << "Size must be equal to number of variables.\n";

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

   for(size_t i = 0; i < variables_number; i++)
   {
       items[i].name = new_names[i];
   }
}


// void set_name(const size_t&, const std::string&) method


void Variables::set_name(const size_t& i, const std::string& new_name)
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t variables_number = get_variables_number();

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

      buffer << "OpenNN Exception: Variables class.\n"
             << "void set_name(const size_t&, const std::string&) method.\n"
             << "Index of variable must be less than number of variables.\n";

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

   #endif

   // Set name of single variable

   items[i].name = new_name;
}


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


void Variables::set_units(const Vector<std::string>& new_units)
{
    const size_t variables_number = get_variables_number();

   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t size = new_units.size();

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

      buffer << "OpenNN Exception: Variables class.\n"
             << "void set_units(const Vector<std::string>&) method.\n"
             << "Size must be equal to number of variables.\n";

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

   for(size_t i = 0; i < variables_number; i++)
   {
       items[i].units = new_units[i];
   }
}


// void set_units(const size_t&, const std::string&) method


void Variables::set_units(const size_t& i, const std::string& new_units)
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

    const size_t variables_number = get_variables_number();

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

      buffer << "OpenNN Exception: Variables class.\n"
             << "void set_units(const size_t&, const std::string&) method.\n"
             << "Index of variable must be less than number of variables.\n";

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

   #endif

   // Set units of single variable

   items[i].units = new_units;
}


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


void Variables::set_descriptions(const Vector<std::string>& new_descriptions)
{
    const size_t variables_number = get_variables_number();

   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t size = new_descriptions.size();

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

      buffer << "OpenNN Exception: Variables class.\n"
             << "void set_descriptions(const Vector<std::string>&) method.\n"
             << "Size must be equal to number of variables.\n";

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

   for(size_t i = 0; i < variables_number; i++)
   {
       items[i].description = new_descriptions[i];
   }
}


// void set_description(const size_t&, const std::string&) method


void Variables::set_description(const size_t& i, const std::string& new_description)
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

    const size_t variables_number = get_variables_number();

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

      buffer << "OpenNN Exception: Variables class.\n"
             << "void set_description(const size_t&, const std::string&) method.\n"
             << "Index of variable must be less than number of variables.\n";

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

   #endif

   // Set description of single variable

   items[i].description = new_description;
}


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


void Variables::set_names(const Vector<std::string>& columns_name, const Vector< Vector<std::string> >& nominal_labels)
{
    #ifndef NDEBUG

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

       buffer << "OpenNN Exception: Variables class.\n"
              << "void set_names(const Vector<std::string>& , const Vector< Vector<std::string> >&) method.\n"
              << "Size of columns name (" << columns_name.size() << ") must be equal to size of nominal labels " << nominal_labels.size() << ".\n";

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

    #endif

    Vector<std::string> names;

    for(size_t i = 0; i < nominal_labels.size(); i++)
    {
        if(nominal_labels[i].size() == 0)
        {
            names.push_back(columns_name[i]);
        }
        else if(nominal_labels[i].size() == 2)
        {
             if(nominal_labels[i].contains("true") || nominal_labels[i].contains("True") || nominal_labels[i].contains("TRUE"))
             {
                 names.push_back(columns_name[i] + "_true");
             }
             else if(nominal_labels[i].contains("positive") || nominal_labels[i].contains("Positive") || nominal_labels[i].contains("POSITIVE"))
             {
                 names.push_back(columns_name[i] + "positive");
             }
             else
             {
                 names.push_back(columns_name[i]);
             }
        }
        else
        {
            for(size_t j = 0; j < nominal_labels[i].size(); j++)
            {
                names.push_back(nominal_labels[i][j]);
            }
        }
    }

    set_names(names);


/*
   // Control sentence (if debug)


    size_t index = 0;

   for(size_t i = 0; i < new_names.size(); i++)
   {
       if(new_names[i].size() == 1)
       {
           items[index].name = new_names[i][0];
           index++;
       }
       else if(new_names[i].size() == 2)
       {
            if(new_names[i].contains("true") || new_names[i].contains("True") || new_names[i].contains("TRUE"))
            {
                items[index].name = "True";
                index++;
            }
            else if(new_names[i].contains("positive") || new_names[i].contains("Positive") || new_names[i].contains("POSITIVE"))
            {
                items[index].name = "Positive";
                index++;
            }
            else
            {
                items[index].name = new_names[i][0];
                index++;
            }
       }
       else
       {
           for(size_t j = 0; j < new_names[i].size(); j++)
           {
               items[index].name = new_names[i][j];
               index++;
           }
       }
    }
*/
}


// void set_display(const bool&) method


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


// void convert_time_series(const size_t&) method


void Variables::convert_time_series(const size_t& lags_number)
{
    const size_t variables_number = get_variables_number();

    const size_t new_variables_number = variables_number*(1+lags_number);

    Vector<Item> new_items(new_variables_number);

    size_t index = 0;

    for(size_t i = 0; i < 1+lags_number; i++)
    {
        for(size_t j = 0; j < variables_number; j++)
        {
            new_items[index].name = items[j].name;
            new_items[index].units = items[j].units;
            new_items[index].description = items[j].description;

            if(i != lags_number)
            {
                new_items[index].name.append("_lag_").append(unsigned_to_string(lags_number-i));
                new_items[index].use = Variables::Input;
            }
            else
            {
                new_items[index].use = Variables::Target;
            }

            index++;
        }
    }

    set_items(new_items);
}


// void convert_autoassociation(void) method


void Variables::convert_autoassociation(void)
{
    const size_t variables_number = get_variables_number();

    set_input();

    Vector<Item> autoassociation_items(variables_number);

    for(size_t i = 0; i < variables_number; i++)
    {
        autoassociation_items[i].name = prepend("autoassociation_", items[i].name);
        autoassociation_items[i].units = items[i].units;
        autoassociation_items[i].description = items[i].description;
        autoassociation_items[i].use = Variables::Target;
    }

    set_items(items.assemble(autoassociation_items));
}



// void set_variables_number(const size_t&) method


void Variables::set_variables_number(const size_t& new_variables_number)
{
   items.set(new_variables_number);
   set_default_uses();
}


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


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

   const size_t variables_number = get_variables_number();
   const size_t inputs_number = count_inputs_number();
   const size_t targets_number = count_targets_number();

   buffer << "Variables object\n"
          << "Variables number: " << variables_number << "\n"
          << "Inputs number: " << inputs_number << "\n"
          << "Target number: " << targets_number << "\n";

   buffer << "Items:\n";

   const Vector<std::string> uses_string = write_uses();

   for(size_t i = 0; i < variables_number; i++)
   {
      buffer << "Variable " << i+1 << ":\n"
             << "Name: " << items[i].name << "\n"
             << "Units: " << items[i].units << "\n"
             << "Description: " << items[i].description << "\n"
             << "Use: " << write_use(i) << "\n";
   }

   buffer << "Display: " << display << "\n";

   return(buffer.str());
}


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


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

   std::ostringstream buffer;

   // Variables

   tinyxml2::XMLElement* variables_element = document->NewElement("Variables");

   document->InsertFirstChild(variables_element);


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

   const size_t variables_number = get_variables_number();

   // Variables number
   {
      element = document->NewElement("VariablesNumber");
      variables_element->LinkEndChild(element);

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

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

   for(size_t i = 0; i < variables_number; i++)
   {
       element = document->NewElement("Item");
       element->SetAttribute("Index", (unsigned)i+1);
       variables_element->LinkEndChild(element);

       // Name

       tinyxml2::XMLElement* name_element = document->NewElement("Name");
       element->LinkEndChild(name_element);

       tinyxml2::XMLText* name_text = document->NewText(items[i].name.c_str());
       name_element->LinkEndChild(name_text);

       // Units

       tinyxml2::XMLElement* units_element = document->NewElement("Units");
       element->LinkEndChild(units_element);

       tinyxml2::XMLText* units_text = document->NewText(items[i].units.c_str());
       units_element->LinkEndChild(units_text);

       // Description

       tinyxml2::XMLElement* description_element = document->NewElement("Description");
       element->LinkEndChild(description_element);

       tinyxml2::XMLText* descriptionText = document->NewText(items[i].description.c_str());
       description_element->LinkEndChild(descriptionText);

       // Use

       tinyxml2::XMLElement* use_element = document->NewElement("Use");
       element->LinkEndChild(use_element);

       tinyxml2::XMLText* use_text = document->NewText(write_use(i).c_str());
       use_element->LinkEndChild(use_text);
   }

   // Display
   {
      element = document->NewElement("Display");
      variables_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 Variables::from_XML(const tinyxml2::XMLDocument& document)
{
   std::ostringstream buffer;

   unsigned index = 0;

   // Variables

   const tinyxml2::XMLElement* variables_element = document.FirstChildElement("Variables");

   if(!variables_element)
   {
      buffer << "OpenNN Exception: Variables class.\n"
             << "void from_XML(const tinyxml2::XMLElement*) method.\n"
             << "Pointer to variables element is NULL.\n";

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

   // Variables number

   const tinyxml2::XMLElement* variables_number_element = variables_element->FirstChildElement("VariablesNumber");

   if(!variables_number_element)
   {
      buffer << "OpenNN Exception: Variables class.\n"
             << "void from_XML(const tinyxml2::XMLElement*) method.\n"
             << "Pointer to variables number is NULL.\n";

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

   const size_t variables_number = atoi(variables_number_element->GetText());

   set_variables_number(variables_number);   

   // Items

   const tinyxml2::XMLElement* start_element = variables_number_element;

   for(size_t i = 0; i < variables_number; i++)
   {      
      const tinyxml2::XMLElement* item_element = start_element->NextSiblingElement("Item");
      start_element = item_element;

      if(!item_element)
      {
          buffer << "OpenNN Exception: Variables class.\n"
                 << "void from_XML(const tinyxml2::XMLElement*) method.\n"
                 << "Item " << i+1 << " is NULL.\n";

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

     item_element->QueryUnsignedAttribute("Index", &index);

     if(index != i+1)
     {
         buffer << "OpenNN Exception: Variables class.\n"
                << "void from_XML(const tinyxml2::XMLElement*) method.\n"
                << "Index " << index << " is not correct.\n";

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

     // Name

     const tinyxml2::XMLElement* name_element = item_element->FirstChildElement("Name");

     if(!name_element)
     {
        buffer << "OpenNN Exception: Variables class.\n"
               << "void from_XML(const tinyxml2::XMLElement*) method.\n"
               << "Pointer to name element is NULL.\n";

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

     if(name_element->GetText())
     {
        items[index-1].name = name_element->GetText();
     }

     // Units

     const tinyxml2::XMLElement* units_element = item_element->FirstChildElement("Units");

     if(!units_element)
     {
        buffer << "OpenNN Exception: Variables class.\n"
               << "void from_XML(const tinyxml2::XMLElement*) method.\n"
               << "Pointer to units element is NULL.\n";

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

     if(units_element->GetText())
     {
        items[index-1].units = units_element->GetText();
     }

     // Description

     const tinyxml2::XMLElement* description_element = item_element->FirstChildElement("Description");

     if(!description_element)
     {
        buffer << "OpenNN Exception: Variables class.\n"
               << "void from_XML(const tinyxml2::XMLElement*) method.\n"
               << "Pointer to description element is NULL.\n";

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

     if(description_element->GetText())
     {
        items[index-1].description = description_element->GetText();
     }

     // Use

     const tinyxml2::XMLElement* use_element = item_element->FirstChildElement("Use");

     if(!use_element)
     {
        buffer << "OpenNN Exception: Variables class.\n"
               << "void from_XML(const tinyxml2::XMLElement*) method.\n"
               << "Pointer to use element is NULL.\n";

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

     if(use_element->GetText())
     {
        set_use(index-1, use_element->GetText());
     }
   }
}


// std::string Variables::unsigned_to_string(const size_t&) method


std::string Variables::unsigned_to_string(const size_t& number)
{
    std::ostringstream buffer;

    buffer << number;

    return(buffer.str());
}


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


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

    buffer << pre << str;

    return(buffer.str());
}


}


// 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