instances.cpp

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

// OpenNN includes

#include "instances.h"

namespace OpenNN
{


// DEFAULT CONSTRUCTOR


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


// INSTANCES NUMBER CONSTRUCTOR


Instances::Instances(const size_t& new_instances_number)
{
    set(new_instances_number);
}


// XML CONSTRUCTOR


Instances::Instances(const tinyxml2::XMLDocument& instances_document)
{   
   set(instances_document);
}


// COPY CONSTRUCTOR


Instances::Instances(const Instances& other_instances)
{
   items = other_instances.items;

   display = other_instances.display;
}


// DESTRUCTOR


Instances::~Instances(void)
{
}


// ASSIGNMENT OPERATOR


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

   return(*this);
}


// EQUAL TO OPERATOR

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


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


// METHODS

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


Instances::SplittingMethod Instances::get_splitting_method(const std::string& splitting_method)
{
    if(splitting_method == "Sequential")
    {
        return(Sequential);
    }
    else if(splitting_method == "Random")
    {
        return(Random);
    }
    else
    {
        std::ostringstream buffer;

        buffer << "OpenNN Exception: Instances class.\n"
               << "static SplittingMethod get_splitting_method(const std::string&).\n"
               << "Unknown splitting method: " << splitting_method << ".\n";

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


// bool empty(void) const method


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


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


Vector<Instances::Use> Instances::arrange_uses(void) const
{
   const size_t instances_number = get_instances_number();

   Vector<Use> uses(instances_number);

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

   return(uses);
}


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


Vector<std::string> Instances::write_uses(void) const
{
   const size_t instances_number = get_instances_number();

   const Vector<Use> uses = arrange_uses();

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

   for(size_t i = 0; i < instances_number; i++)
   {
      if(uses[i] == Training)
      {   
         uses_string[i] = "Training";            
      }
      else if(uses[i] == Generalization)
      {   
         uses_string[i] = "Generalization";    
      }
      else if(uses[i] == Testing)
      {   
         uses_string[i] = "Testing";    
      }
      else if(uses[i] == Unused)
      {
         uses_string[i] = "Unused";
      }
      else
      {
         std::ostringstream buffer;

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

   return(uses_string);
}


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


Vector<std::string> Instances::write_abbreviated_uses(void) const
{
   const size_t instances_number = get_instances_number();

   const Vector<Use> uses = arrange_uses();

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

   for(size_t i = 0; i < instances_number; i++)
   {
      if(uses[i] == Training)
      {
         uses_string[i] = "Train.";
      }
      else if(uses[i] == Generalization)
      {
         uses_string[i] = "Gen.";
      }
      else if(uses[i] == Testing)
      {
         uses_string[i] = "Test.";
      }
      else if(uses[i] == Unused)
      {
         uses_string[i] = "Unused";
      }
      else
      {
         std::ostringstream buffer;

         buffer << "OpenNN Exception Instances class.\n"
                << "Vector<std::string> write_abbreviated_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 Instances::Use& Instances::get_use(const size_t& i) const
{
    return(items[i].use);
}


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


std::string Instances::write_use(const size_t& i) const
{
    if(items[i].use == Training)
    {
       return("Training");
    }
    else if(items[i].use == Generalization)
    {
       return("Generalization");
    }
    else if(items[i].use == Testing)
    {
       return("Testing");
    }
    else if(items[i].use == Unused)
    {
       return("Unused");
    }
    else
    {
       std::ostringstream buffer;

       buffer << "OpenNN Exception Instances 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& i) const method


bool Instances::is_used(const size_t& i) const
{
    if(items[i].use == Unused)
    {
        return(false);
    }
    else
    {
        return(true);
    }
}


// size_t count_unused_instances_number(void) const method


size_t Instances::count_unused_instances_number(void) const
{
    const size_t instances_number = get_instances_number();

    size_t unused_instances_number = 0;

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

    return(unused_instances_number);
}


// size_t count_used_instances_number(void) const method


size_t Instances::count_used_instances_number(void) const
{
    const size_t instances_number = get_instances_number();
    const size_t unused_instances_number = count_unused_instances_number();

    return(instances_number - unused_instances_number);
}


// size_t count_training_instances_number(void) const method


size_t Instances::count_training_instances_number(void) const
{
    const size_t instances_number = get_instances_number();

    size_t training_instances_number = 0;

    for(size_t i = 0; i < instances_number; i++)
    {
       if(items[i].use == Training)
       {
          training_instances_number++;
       }
    }

    return(training_instances_number);
}


// size_t count_generalization_instances_number(void) const method


size_t Instances::count_generalization_instances_number(void) const
{
    const size_t instances_number = get_instances_number();

    size_t generalization_instances_number = 0;

    for(size_t i = 0; i < instances_number; i++)
    {
       if(items[i].use == Generalization)
       {
          generalization_instances_number++;
       }
    }

    return(generalization_instances_number);
}


// size_t count_testing_instances_number(void) const method


size_t Instances::count_testing_instances_number(void) const
{
    const size_t instances_number = get_instances_number();

    size_t testing_instances_number = 0;

    for(size_t i = 0; i < instances_number; i++)
    {
       if(items[i].use == Testing)
       {
          testing_instances_number++;
       }
    }

    return(testing_instances_number);
}


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


Vector<size_t> Instances::count_uses(void) const
{
    Vector<size_t> count(4, 0);

    const size_t instances_number = get_instances_number();

    for(size_t i = 0; i < instances_number; i++)
    {
        if(items[i].use == Training)
        {
           count[0]++;
        }
        else if(items[i].use == Generalization)
        {
           count[1]++;
        }
        else if(items[i].use == Testing)
        {
           count[2]++;
        }
        else
        {
           count[3]++;
        }
    }

    return(count);
}


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


Vector<size_t> Instances::arrange_training_indices(void) const
{
   const size_t instances_number = get_instances_number();

   const size_t training_instances_number = count_training_instances_number();

   Vector<size_t> training_indices(training_instances_number);

   size_t count = 0;

   for(size_t i = 0; i < instances_number; i++)
   {
      if(items[i].use == Training)
      {
         training_indices[count] = (size_t)i;
         count++;
      }
   }

   return(training_indices);
}


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


Vector<size_t> Instances::arrange_generalization_indices(void) const
{
   const size_t instances_number = get_instances_number();

   const size_t generalization_instances_number = count_generalization_instances_number();

   Vector<size_t> generalization_indices(generalization_instances_number);

   size_t count = 0;

   for(size_t i = 0; i < instances_number; i++)
   {
      if(items[i].use == Generalization)
      {
         generalization_indices[count] = i;
         count++;
      }
   }

   return(generalization_indices);
}


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


Vector<size_t> Instances::arrange_testing_indices(void) const
{
   const size_t instances_number = get_instances_number();

   const size_t testing_instances_number = count_testing_instances_number();

   Vector<size_t> testing_indices(testing_instances_number);

   size_t count = 0;

   for(size_t i = 0; i < instances_number; i++)
   {
      if(items[i].use == Testing)
      {
         testing_indices[count] = i;
         count++;
      }
   }

   return(testing_indices);
}


// const bool& get_display(void) const method


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


// void set(void) method


void Instances::set(void)
{
   set_instances_number(0);

   set_default();
}


// void set(const size_t&) method


void Instances::set(const size_t& new_instances_number)
{
   set_instances_number(new_instances_number);

   set_default();
}


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


void Instances::set(const tinyxml2::XMLDocument& instances_document)
{
    set_default();

   from_XML(instances_document);
}


// void set_default(void) method


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


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


void Instances::set_uses(const Vector<Instances::Use>& new_uses)
{
    const size_t instances_number = get_instances_number();

   // Control sentence (if debug)

   #ifndef NDEBUG   

   const size_t new_uses_size = new_uses.size();

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

      buffer << "OpenNN Exception: Instances class.\n"
             << "void set_uses(const Vector<Use>&) method.\n"
             << "Size of uses (" << new_uses_size << ") must be equal to number of instances (" << instances_number << ").\n";

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

   #endif

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


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


void Instances::set_uses(const Vector<std::string>& new_uses)
{
    const size_t instances_number = get_instances_number();

    std::ostringstream buffer;

   // Control sentence (if debug)

   #ifndef NDEBUG   

   const size_t new_uses_size = new_uses.size();

   if(new_uses_size != instances_number)
   {
      buffer << "OpenNN Exception: Instances class.\n"
             << "void set_uses(const Vector<std::string>&) method.\n"
             << "Size of uses (" << new_uses_size << ") must be equal to number of instances (" << instances_number << ").\n";

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

   #endif

   for(size_t i = 0; i < instances_number; i++)
   {   
      if(new_uses[i] == "Unused")
      {   
         items[i].use = Unused;
      }
      else if(new_uses[i] == "Training")
      {   
         items[i].use = Training;
      }
      else if(new_uses[i] == "Generalization")
      {   
         items[i].use = Generalization;
      }
      else if(new_uses[i] == "Testing")
      {   
         items[i].use = Testing;
      }
      else
      {
         buffer << "OpenNN Exception Instances class.\n"
                << "void set_uses(const Vector<std::string>&) method.\n"
                << "Unknown use.\n";
 
         throw std::logic_error(buffer.str());
      }
   }   
}


// void set_use(const Use&) method


void Instances::set_use(const size_t& i, const Use& new_use)
{
    items[i].use = new_use;
}


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


void Instances::set_use(const size_t& i, const std::string& new_use)
{
    if(new_use == "Training")
    {
       items[i].use = Training;
    }
    else if(new_use == "Generalization")
    {
       items[i].use = Generalization;
    }
    else if(new_use == "Testing")
    {
       items[i].use = Testing;
    }
    else if(new_use == "Unused")
    {
       items[i].use = Unused;
    }
    else
    {
       std::ostringstream buffer;

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

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


// void set_training(void) method


void Instances::set_training(void)
{
   const size_t instances_number = get_instances_number();

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


// void set_generalization(void) method


void Instances::set_generalization(void)
{
    const size_t instances_number = get_instances_number();

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


// void set_testing(void) method


void Instances::set_testing(void)
{
    const size_t instances_number = get_instances_number();

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


// void set_display(const bool&) method


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


// void set_instances_number(const size_t&) method


void Instances::set_instances_number(const size_t& new_instances_number)
{
   items.set(new_instances_number);

   split_instances();
}


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


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

   std::ostringstream buffer;

   // Instances     

   tinyxml2::XMLElement* instances_element = document->NewElement("Instances");

   document->InsertFirstChild(instances_element);

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

   const size_t instances_number = get_instances_number();

   // Instances number
   {
      element = document->NewElement("InstancesNumber");
      instances_element->LinkEndChild(element);

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

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

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

       // 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");
      instances_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 Instances::from_XML(const tinyxml2::XMLDocument& instances_document)
{
    std::ostringstream buffer;

    // Instances  element

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

   if(!instances_element)
   {
      buffer << "OpenNN Exception: Instances class.\n"
             << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
             << "Pointer to instances information element is NULL.\n";

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

   // Instances number

   const tinyxml2::XMLElement* instances_number_element = instances_element->FirstChildElement("InstancesNumber");

   if(!instances_number_element)
   {
      buffer << "OpenNN Exception: Instances class.\n"
             << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
             << "Pointer to instances number is NULL.\n";

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

   const size_t instances_number = atoi(instances_number_element->GetText());

   set_instances_number(instances_number);

   if(instances_number <= 0)
   {
       return;
   }


   // Items

   unsigned index = 0;

   const tinyxml2::XMLElement* start_element = instances_number_element;

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

      if(!item_element)
      {
          buffer << "OpenNN Exception: Instances 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: Instances class.\n"
                << "void from_XML(const tinyxml2::XMLElement*) method.\n"
                << "Index " << index << " is not correct.\n";

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

     // Use

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

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


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


void Instances::split_random_indices
(const double& training_instances_ratio, const double& generalization_instances_ratio, const double& testing_instances_ratio)
{
   const size_t used_instances_number = count_used_instances_number();

   if(used_instances_number == 0)
   {
       return;
   }

   const double total_ratio = training_instances_ratio + generalization_instances_ratio + testing_instances_ratio;

   // Get number of instances for training, generalization and testing

   const size_t generalization_instances_number = (size_t)(generalization_instances_ratio*used_instances_number/total_ratio);
   const size_t testing_instances_number = (size_t)(testing_instances_ratio*used_instances_number/total_ratio);
   const size_t training_instances_number = used_instances_number - generalization_instances_number - testing_instances_number;

   const size_t sum_instances_number = training_instances_number + generalization_instances_number + testing_instances_number;

   if(sum_instances_number != used_instances_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Warning: Instances class.\n" 
                << "void split_random_indices(const double&, const double&, const double&) method.\n"
                << "Sum of numbers of training, generalization and testing instances is not equal to number of used instances.\n";

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

   const size_t instances_number = get_instances_number();

   Vector<size_t> indices(0, 1, instances_number-1);
   std::random_shuffle(indices.begin(), indices.end());

   size_t i = 0;
   size_t index;

   // Training

   size_t count_training = 0;

   while(count_training != training_instances_number)
   {
      index = indices[i];

      if(items[index].use != Unused)
      {
        items[index].use = Training;
        count_training++;
      }

      i++;
   }

   // Generalization 

   size_t count_generalization = 0;

   while(count_generalization != generalization_instances_number)
   {
      index = indices[i];

      if(items[index].use != Unused)
      {
        items[index].use = Generalization;
        count_generalization++;
      }

      i++;
   }

   // Testing 

   size_t count_testing = 0;

   while(count_testing != testing_instances_number)
   {
      index = indices[i];

      if(items[index].use != Unused)
      {
            items[index].use = Testing;
            count_testing++;
      }

      i++;
   }
}


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


void Instances::split_sequential_indices(const double& training_instances_ratio, const double& generalization_instances_ratio, const double& testing_instances_ratio)
{
   const size_t used_instances_number = count_used_instances_number();

   if(used_instances_number == 0)
   {
       return;
   }

   const double total_ratio = training_instances_ratio + generalization_instances_ratio + testing_instances_ratio;

   // Get number of instances for training, generalization and testing

   const size_t generalization_instances_number = (size_t)(generalization_instances_ratio*used_instances_number/total_ratio);
   const size_t testing_instances_number = (size_t)(testing_instances_ratio*used_instances_number/total_ratio);
   const size_t training_instances_number = used_instances_number - generalization_instances_number - testing_instances_number;

   const size_t sum_instances_number = training_instances_number + generalization_instances_number + testing_instances_number;

   if(sum_instances_number != used_instances_number)
   {
      std::ostringstream buffer;

      buffer << "OpenNN Warning: Instances class.\n" 
             << "void split_random_indices(const double&, const double&, const double&) method.\n"
             << "Sum of numbers of training, generalization and testing instances is not equal to number of used instances.\n";
   
      throw std::logic_error(buffer.str());
   }

   size_t i = 0;

   // Training

   size_t count_training = 0;

   while(count_training != training_instances_number)
   {
      if(items[i].use != Unused)
      {
        items[i].use = Training;
        count_training++;
      }

      i++;
   }

   // Generalization

   size_t count_generalization = 0;

   while(count_generalization != generalization_instances_number)
   {
      if(items[i].use != Unused)
      {
        items[i].use = Generalization;
        count_generalization++;
      }

      i++;
   }

   // Testing

   size_t count_testing = 0;

   while(count_testing != testing_instances_number)
   {
      if(items[i].use != Unused)
      {
            items[i].use = Testing;
            count_testing++;
      }

      i++;
   }
}


// void split_instances(const SplittingMethod& splitting_method = Random, const double& training_ratio = 0.6, const double& generalization_ratio = 0.2, const double& testing_ratio = 0.2) method


void Instances::split_instances(const SplittingMethod& splitting_method, const double& training_ratio, const double& generalization_ratio, const double& testing_ratio)
{

#ifndef NDEBUG

    std::ostringstream buffer;

    if(training_ratio < 0)
    {
        buffer << "OpenNN Exception: Instances class.\n"
               << "void split_instances(const SplittingMethod&, const double&, const double&, const double&) method.\n"
               << "Training ratio is lower than zero.\n";

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

    if(generalization_ratio < 0)
    {
        buffer << "OpenNN Exception: Instances class.\n"
               << "void split_instances(const SplittingMethod&, const double&, const double&, const double&) method.\n"
               << "Generalization ratio is lower than zero.\n";

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

    if(testing_ratio < 0)
    {
        buffer << "OpenNN Exception: Instances class.\n"
               << "void split_instances(const SplittingMethod&, const double&, const double&, const double&) method.\n"
               << "Testing ratio is lower than zero.\n";

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

    if(training_ratio == 0.0 && generalization_ratio == 0.0 && testing_ratio == 0.0)
    {
        buffer << "OpenNN Exception: Instances class.\n"
               << "void split_instances(const SplittingMethod&, const double&, const double&, const double&) method.\n"
               << "All training, generalization and testing ratios are zero.\n";

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

#endif

    switch(splitting_method)
    {
        case Instances::Sequential:
        {
             split_sequential_indices(training_ratio, generalization_ratio, testing_ratio);
        }
        break;

        case Instances::Random:
        {
             split_random_indices(training_ratio, generalization_ratio, testing_ratio);
        }
        break;

        default:
        {
           std::ostringstream buffer;

           buffer << "Neural Engine Exception: Instances class.\n"
                  << "void split_instances(const double&, const double&, const double&) method.\n"
                  << "Unknown splitting method.\n";

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

}


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


Vector<double> Instances::calculate_uses_percentage(void) const
{
    const size_t instances_number = get_instances_number();

    Vector<double> uses_percentage(instances_number);

    const Vector<size_t> uses_count = count_uses();

    for(size_t i = 0; i < 4; i++)
    {
        uses_percentage[i] = 100.0*uses_count[i]/(double)instances_number;
    }

    return(uses_percentage);
}


// void convert_time_series(const size_t&) method


void Instances::convert_time_series(const size_t& lags_number)
{
    const size_t instances_number = get_instances_number();

    if (instances_number < lags_number)
    {
        std::ostringstream buffer;

        buffer << "OpenNN Exception: Instances class.\n"
               << "void convert_time_series(const size_t&).\n"
               << "Number of instances (" << instances_number << ") must be equal or greater than number of lags (" << lags_number << ").\n";

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

    const size_t new_instances_number = instances_number - lags_number;

    set(new_instances_number);
}


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


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

   buffer << "Instances object\n"
          << "Instances number: " << get_instances_number() << "\n"
          << "Training instances number: " << count_training_instances_number() << "\n"
          << "Generalization instances number: " << count_generalization_instances_number() << "\n"
          << "Testing instances number: " << count_testing_instances_number() << "\n"
          << "Uses: " << write_uses() << "\n"
          << "Display: " << display << "\n";

   return(buffer.str());
}


// void print(void) const method


void Instances::print(void) const
{
    std::cout << to_string();
}

}


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