inputs.cpp

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

// OpenNN includes

#include "inputs.h"

namespace OpenNN
{

// DEFAULT CONSTRUCTOR


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


// INPUTS NUMBER CONSTRUCTOR


Inputs::Inputs(const size_t& new_inputs_number)
{
   set(new_inputs_number);
}


// XML CONSTRUCTOR


Inputs::Inputs(const tinyxml2::XMLDocument& document)
{
   from_XML(document);
}


// COPY CONSTRUCTOR


Inputs::Inputs(const Inputs& other_inputs)
{
   set(other_inputs);
}


// DESTRUCTOR


Inputs::~Inputs(void)
{
}


// ASSIGNMENT OPERATOR


Inputs& Inputs::operator = (const Inputs& other_inputs)
{
   if(this != &other_inputs)
   {
      items = other_inputs.items;
 
      display = other_inputs.display;
   }

   return(*this);
}


// METHODS


// EQUAL TO OPERATOR

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


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


// bool is_empty(void) const method


bool Inputs::is_empty(void) const
{
   const size_t inputs_number = get_inputs_number();

   if(inputs_number == 0)
   {
      return(true);   
   }
   else
   {
      return(false);
   }
}


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


Vector<std::string> Inputs::arrange_names(void) const
{
    const size_t inputs_number = get_inputs_number();

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

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

   return(names);
}


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


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

   #ifndef NDEBUG 

   const size_t inputs_number = get_inputs_number();

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

      buffer << "OpenNN Exception: Inputs class.\n"
             << "const std::string get_name(const size_t&) const method.\n"
             << "Input variable index must be less than number of inputs.\n";

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

   #endif

   return(items[i].name);
}


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


Vector<std::string> Inputs::arrange_units(void) const
{
    const size_t inputs_number = get_inputs_number();

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

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

   return(units);
}


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


const std::string& Inputs::get_unit(const size_t& index) const
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t inputs_number = get_inputs_number();

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

      buffer << "OpenNN Exception: Inputs class.\n"
             << "const std::string get_unit(const size_t&) const method.\n"
             << "Index of input variable must be less than number of inputs.\n";

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

   #endif

   return(items[index].units);
}


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


Vector<std::string> Inputs::arrange_descriptions(void) const
{
    const size_t inputs_number = get_inputs_number();

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

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

   return(descriptions);
}


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


const std::string& Inputs::get_description(const size_t& index) const
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t inputs_number = get_inputs_number();

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

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

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

   #endif

   return(items[index].description);
}


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


Matrix<std::string> Inputs::arrange_information(void) const
{
    const size_t inputs_number = get_inputs_number();

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

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

    return(information);
}


// const bool& get_display(void) const method


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


// void set(void) method


void Inputs::set(void)
{
   set_inputs_number(0);

   set_default();
}


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


void Inputs::set(const size_t& new_inputs_number)
{
   set_inputs_number(new_inputs_number);

   set_default();
}


// void set(const Inputs&) method


void Inputs::set(const Inputs& other_inputs)
{
   items = other_inputs.items;
   display = other_inputs.display;
}


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


void Inputs::set(const Vector< Vector<std::string> >& new_inputs_information)
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t new_inputs_information_size = new_inputs_information.size();

   if(new_inputs_information_size != 3)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Exception: Inputs class.\n"
             << "void set(const Vector< Vector<std::string> >&) method.\n"
             << "Size of inputs information must be three.\n";

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

   #endif
   
   set_names(new_inputs_information[0]);
   set_units(new_inputs_information[1]);
   set_descriptions(new_inputs_information[2]);
}


// void set_inputs_number(const size_t&) method


void Inputs::set_inputs_number(const size_t& new_inputs_number)
{
   items.set(new_inputs_number);
}


// void set_default(void) method


void Inputs::set_default(void)
{
    std::ostringstream buffer;

   const size_t inputs_number = get_inputs_number();

   for(size_t i = 0; i < inputs_number; i++)
   {
       buffer.str("");
       buffer << "input_" << i+1;

       items[i].name = buffer.str();
       items[i].units = "";
       items[i].description = "";
   }

   set_display(true);
}


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


void Inputs::set_names(const Vector<std::string>& new_names)
{
    const size_t inputs_number = get_inputs_number();

   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t size = new_names.size();

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

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

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

   #endif

   // Set name of input variables 

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


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


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

   #ifndef NDEBUG 

    const size_t inputs_number = get_inputs_number();

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

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

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

   #endif

   // Set name of single input variable

   items[i].name = new_name;
}


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


void Inputs::set_units(const Vector<std::string>& new_units)
{
    const size_t inputs_number = get_inputs_number();

   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t size = new_units.size();

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

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

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

   #endif

   // Set units of input variables

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


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


void Inputs::set_unit(const size_t& index, const std::string& new_unit)
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t inputs_number = get_inputs_number();

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

      buffer << "OpenNN Exception: Inputs class.\n"
             << "void set_unit(const size_t&, const std::string&) method.\n"
             << "Index of input must be less than number of inputs.\n";

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

   #endif

   // Set units of single input variable

   items[index].units = new_unit;
}


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


void Inputs::set_descriptions(const Vector<std::string>& new_descriptions)
{
    const size_t inputs_number = get_inputs_number();

   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t size = new_descriptions.size();

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

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

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

   #endif

   // Set description of input variables

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


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


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

   #ifndef NDEBUG 

    const size_t inputs_number = get_inputs_number();

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

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

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

   #endif

   // Set description of single input variable

   items[index].description = new_description;
}


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


void Inputs::set_information(const Matrix<std::string>& new_information)
{
   // Control sentence (if debug)

   #ifndef NDEBUG 

   const size_t columns_number = new_information.get_columns_number();

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

      buffer << "OpenNN Exception: Inputs class.\n"
             << "void set_information(const Matrix<std::string>&) method.\n"
             << "Number of columns in matrix must be 3.\n";

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

   #endif

   const size_t inputs_number = get_inputs_number();

   // Set all information

   for(size_t i = 0; i < inputs_number; i++)
   {
       items[i].name = new_information(i,0);
       items[i].units = new_information(i,1);
       items[i].description = new_information(i,2);
   }
}

// void set_display(const bool&) method


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


// void grow_input(void) method


void Inputs::grow_input(void)
{
    const Item item;

    items.push_back(item);
}


// void prune_input(const size_t&) method


void Inputs::prune_input(const size_t& index)
{
    // Control sentence (if debug)

    #ifndef NDEBUG

    const size_t inputs_number = get_inputs_number();

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

       buffer << "OpenNN Exception: Inputs class.\n"
              << "void prune_input(const size_t&) method.\n"
              << "Index of input is equal or greater than number of inputs.\n";

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

    #endif

   items.erase(items.begin()+index);
}


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


Vector<std::string> Inputs::write_default_names(void) const
{
   const size_t inputs_number = get_inputs_number();

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

   std::ostringstream buffer;
  
   for(size_t i = 0; i < inputs_number; i++)
   {
      buffer.str("");
      buffer << "input_" << i+1;

      default_names[i] = buffer.str();
   }

   return(default_names);
}


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


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

   const size_t inputs_number = get_inputs_number();

   buffer << "Inputs\n";


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

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

   return(buffer.str());
}


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


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

   const size_t inputs_number = get_inputs_number();

   std::ostringstream buffer;

   // Inputs

   tinyxml2::XMLElement* inputsElement = document->NewElement("Inputs");
   document->InsertFirstChild(inputsElement);

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

   // Inputs number
   {
      element = document->NewElement("InputsNumber");
      inputsElement->LinkEndChild(element);

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

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

   for(size_t i = 0; i < inputs_number; i++)
   {
       element = document->NewElement("Item");
       element->SetAttribute("Index", (unsigned)i+1);
       inputsElement->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);
   }

   // Display
   {
      tinyxml2::XMLElement* display_element = document->NewElement("Display");
      inputsElement->LinkEndChild(display_element);

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

      tinyxml2::XMLText* display_text = document->NewText(buffer.str().c_str());
      display_element->LinkEndChild(display_text);
   }

   return(document);
}


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


void Inputs::from_XML(const tinyxml2::XMLDocument& document)
{
    std::ostringstream buffer;

    const tinyxml2::XMLElement* inputsElement = document.FirstChildElement("Inputs");

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

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

    // Inputs number

   const tinyxml2::XMLElement* inputs_number_element = inputsElement->FirstChildElement("InputsNumber");

   if(!inputs_number_element)
   {
       buffer << "OpenNN Exception: Inputs class.\n"
              << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
              << "Inputs number element is NULL.\n";

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

   const size_t inputs_number = atoi(inputs_number_element->GetText());

   set(inputs_number);

   unsigned index = 0; // size_t does not work

   const tinyxml2::XMLElement* start_element = inputs_number_element;

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

      if(!item_element)
      {
          buffer << "OpenNN Exception: Inputs 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: Inputs 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: Inputs 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: Inputs 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: Inputs 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();
     }
   }
}

}

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