mathematical_model.cpp

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

// OpenNN includes

#include "mathematical_model.h"

namespace OpenNN
{

// DEFAULT CONSTRUCTOR


MathematicalModel::MathematicalModel(void)
{                                            
   set_default();
}


// XML CONSTRUCTOR


MathematicalModel::MathematicalModel(const tinyxml2::XMLDocument& mathematical_model_document)
{                
   set_default();

   from_XML(mathematical_model_document);   
}


// FILE CONSTRUCTOR


MathematicalModel::MathematicalModel(const std::string& file_name)
{                
   set_default();

   load(file_name);
}


// COPY CONSTRUCTOR


MathematicalModel::MathematicalModel(const MathematicalModel& other_mathematical_model)
{                
   set(other_mathematical_model);   
}


// DESTRUCTOR
 

MathematicalModel::~MathematicalModel(void)
{ 
}


// ASSIGNMENT OPERATOR


MathematicalModel& MathematicalModel::operator = (const MathematicalModel& other_mathematical_model)
{
   if(this != &other_mathematical_model) 
   {
      independent_variables_number = other_mathematical_model.independent_variables_number;
      dependent_variables_number = other_mathematical_model.dependent_variables_number;

      display = other_mathematical_model.display;
   }

   return(*this);
}


// EQUAL TO OPERATOR


bool MathematicalModel::operator == (const MathematicalModel& other_mathematical_model) const
{
   if(independent_variables_number == other_mathematical_model.independent_variables_number
   && dependent_variables_number == other_mathematical_model.dependent_variables_number
   && display == other_mathematical_model.display)
   {
      return(true);
   }
   else
   {
      return(false);
   }
}


// METHODS

// const size_t& get_independent_variables_number(void) const method


const size_t& MathematicalModel::get_independent_variables_number(void) const
{
   return(independent_variables_number);
}


// size_t get_dependent_variables_number(void) const method


const size_t& MathematicalModel::get_dependent_variables_number(void) const
{
   return(dependent_variables_number);
}


// size_t count_variables_number(void) const method


size_t MathematicalModel::count_variables_number(void) const
{
   return(independent_variables_number + dependent_variables_number);
}


// const bool get_display(void) method


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


// void set(const MathematicalModel&) method


void MathematicalModel::set(const MathematicalModel& other_mathematical_model)
{
   independent_variables_number = other_mathematical_model.independent_variables_number;
   dependent_variables_number = other_mathematical_model.dependent_variables_number;

   display = other_mathematical_model.display;
}


// void set_independent_variables_number(const size_t&) method


void MathematicalModel::set_independent_variables_number(const size_t& new_independent_variables_number)
{
   independent_variables_number = new_independent_variables_number;
}


// void set_dependent_variables_number(const size_t&) method


void MathematicalModel::set_dependent_variables_number(const size_t& new_dependent_variables_number)
{
   dependent_variables_number = new_dependent_variables_number;
}


// void set_default(void) method


void MathematicalModel::set_default(void)
{
   dependent_variables_number = 0;
   independent_variables_number = 0;

   display = true;
}


// void set_display(const bool&) const method


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


// Matrix<double> calculate_solutions(const NeuralNetwork&) const method


Matrix<double> MathematicalModel::calculate_solutions(const NeuralNetwork&) const
{
   std::ostringstream buffer;

   buffer << "OpenNN Exception: MathematicalModel class.\n"
          << "Matrix<double> calculate_solutions(const NeuralNetwork&) const method.\n"
          << "This method has not been derived.\n";
 
   throw std::logic_error(buffer.str());
}


// Vector<double> calculate_final_solutions(const NeuralNetwork&) const method


Vector<double> MathematicalModel::calculate_final_solutions(const NeuralNetwork&) const
{
   std::ostringstream buffer;

   buffer << "OpenNN Exception: MathematicalModel class.\n"
          << "Vector<double> calculate_final_solutions(const NeuralNetwork&) const method.\n"
          << "This method has not been derived.\n";
 
   throw std::logic_error(buffer.str());
}


// Matrix<double> calculate_dependent_variables(const NeuralNetwork&, const Matrix<double>&) const method


Matrix<double> MathematicalModel::calculate_dependent_variables(const NeuralNetwork&, const Matrix<double>&) const
{
   std::ostringstream buffer;

   buffer << "OpenNN Exception: MathematicalModel class.\n"
          << "Matrix<double> calculate_dependent_variables(const NeuralNetwork&, const Matrix<double>&) const method.\n"
          << "This method has not been derived.\n";
 
   throw std::logic_error(buffer.str());
}


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


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

   buffer << "Mathematical model\n"
          << "Independent variables number: " << independent_variables_number << "\n" 
          << "Dependent variables number: " << dependent_variables_number << "\n"
          << "Display: " << display << "\n";

   return(buffer.str());
}


// void print(void) const method


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



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


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

   std::ostringstream buffer;

   tinyxml2::XMLElement* mathematical_model_element = document->NewElement("MathematicalModel");

   document->InsertFirstChild(mathematical_model_element);

   // Independent variables number 
   {
      tinyxml2::XMLElement* independent_variables_number_element = document->NewElement("IndependentVariablesNumber");
      mathematical_model_element->LinkEndChild(independent_variables_number_element);

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

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

   // Dependent variables number 
   {
      tinyxml2::XMLElement* dependent_variables_number_element = document->NewElement("DependentVariablesNumber");
      mathematical_model_element->LinkEndChild(dependent_variables_number_element);

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

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

   // Display 
   {
      tinyxml2::XMLElement* display_element = document->NewElement("Display");
      mathematical_model_element->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 MathematicalModel::from_XML(const tinyxml2::XMLDocument& document)
{
   const tinyxml2::XMLElement* root_element = document.FirstChildElement("MathematicalModel");

   std::ostringstream buffer;

   if(!root_element)
   {
       buffer << "OpenNN Exception: MathematicalModel class.\n"
              << "void from_XML(const tinyxml2::XMLDocument&) method.\n"
              << "Unkown root element.\n";

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

  // Independent variables number
  {
     const tinyxml2::XMLElement* element = root_element->FirstChildElement("IndependentVariablesNumber");

     if(element)
     {
        const char* text = element->GetText();

        if(text)
        {
           try
           {
              set_independent_variables_number(atoi(text));
           }
           catch(const std::logic_error& e)
           {
              std::cout << e.what() << std::endl;
           }
        }
     }
  }

  // Dependent variables number
  {
     const tinyxml2::XMLElement* element = root_element->FirstChildElement("DependentVariablesNumber");

     if(element)
     {
        const char* text = element->GetText();

        if(text)
        {
           try
           {
              set_dependent_variables_number(atoi(text));
           }
           catch(const std::logic_error& e)
           {
              std::cout << e.what() << std::endl;
           }
        }
     }
  }

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

     if(element)
     {
        const char* text = element->GetText();

        if(text)
        {
           try
           {
              const std::string string(text);

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


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


void MathematicalModel::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 MathematicalModel::load(const std::string& file_name)
{
   std::ostringstream buffer;

   tinyxml2::XMLDocument document;

   if(document.LoadFile(file_name.c_str()))
   {
      buffer << "OpenNN Exception: MathematicalModel 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 save_data(const NeuralNetwork&, const std::string&) const method


void MathematicalModel::save_data(const NeuralNetwork&, const std::string&) const
{
   std::ostringstream buffer;

   buffer << "OpenNN Exception: MathematicalModel class.\n"
          << "void save_data(const NeuralNetwork&, const std::string&) const method.\n"
          << "This method has not been derived.\n";
 
   throw std::logic_error(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