missing_values.cpp

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

// OpenNN includes

#include "missing_values.h"

namespace OpenNN
{

// DEFAULT CONSTRUCTOR


MissingValues::MissingValues(void)
{
    set();

    set_default();
}


// INSTANCES AND VARIABLES NUMBER CONSTRUCTOR


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

    set_default();
}


// XML CONSTRUCTOR


MissingValues::MissingValues(const tinyxml2::XMLDocument& missing_values_document)
{   
    set(missing_values_document);
}


// COPY CONSTRUCTOR


MissingValues::MissingValues(const MissingValues& other_missing_values)
{
    instances_number = other_missing_values.instances_number;
    variables_number = other_missing_values.variables_number;

    scrubbing_method = other_missing_values.scrubbing_method;

    items = other_missing_values.items;

    display = other_missing_values.display;
}


// DESTRUCTOR


MissingValues::~MissingValues(void)
{
}


// ASSIGNMENT OPERATOR


MissingValues& MissingValues::operator=(const MissingValues& other_missing_values)
{
    if(this != &other_missing_values)
    {
        instances_number = other_missing_values.instances_number;
        variables_number = other_missing_values.variables_number;

        items = other_missing_values.items;

        display = other_missing_values.display;
    }

    return(*this);
}


// EQUAL TO OPERATOR

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


bool MissingValues::operator == (const MissingValues& other_missing_values) const
{
    if(items == other_missing_values.items
            && display == other_missing_values.display)
    {
        return(true);
    }
    else
    {
        return(false);
    }
}


// METHODS

// size_t get_instances_number(void) const method


size_t MissingValues::get_instances_number(void) const
{
    return(instances_number);
}


// size_t get_variables_number(void) const method


size_t MissingValues::get_variables_number(void) const
{
    return(variables_number);
}


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


Vector<size_t> MissingValues::get_missing_values_numbers(void) const
{
    Vector<size_t> missing_values_numbers(variables_number, 0);

    const size_t missing_values_number = get_missing_values_number();

    size_t variable_index;

    for(size_t i = 0; i < missing_values_number; i++)
    {
        variable_index = items[i].variable_index;

        missing_values_numbers[variable_index]++;
    }

    return(missing_values_numbers);
}


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


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


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


const MissingValues::Item& MissingValues::get_item(const size_t& index) const
{
    // Control sentence (if debug)

#ifndef NDEBUG

    const size_t missing_values_number = get_missing_values_number();

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

        buffer << "OpenNN Exception: MissingValues class.\n"
               << "const Item& get_item(const size_t&) const method.\n"
               << "Index (" << index << ") must be less than number of missing values (" << missing_values_number << ").\n";

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

#endif

    return(items[index]);
}


// ScrubbingMethod get_scrubbing_method(void) const


MissingValues::ScrubbingMethod MissingValues::get_scrubbing_method(void) const
{
    return(scrubbing_method);
}


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


std::string MissingValues::write_scrubbing_method(void) const
{
    if(scrubbing_method == Unuse)
    {
        return("Unuse");
    }
    else if(scrubbing_method == Mean)
    {
        return("Mean");
    }
    if(scrubbing_method == NoScrubbing)
    {
        return("NoScrubbing");
    }
    else
    {
        std::ostringstream buffer;

        buffer << "OpenNN Exception: MissingValues class.\n"
               << "std::string write_scrubbing_method(void) const method.\n"
               << "Unknown scrubbing method.\n";

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


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


std::string MissingValues::write_scrubbing_method_text(void) const
{
    if(scrubbing_method == Unuse)
    {
        return("unuse");
    }
    else if(scrubbing_method == Mean)
    {
        return("mean");
    }
    else if(scrubbing_method == NoScrubbing)
    {
        return("no scrubbing");
    }
    else
    {
        std::ostringstream buffer;

        buffer << "OpenNN Exception: MissingValues class.\n"
               << "std::string write_scrubbing_method_text(void) const method.\n"
               << "Unknown scrubbing method.\n";

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


// const bool& get_display(void) const method


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


// void set(void) method


void MissingValues::set(void)
{
    instances_number = 0;
    variables_number = 0;

    set_missing_values_number(0);

    set_default();
}


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


void MissingValues::set(const size_t& new_instances_number, const size_t& new_variables_number)
{   
    instances_number = new_instances_number;
    variables_number = new_variables_number;

    set_missing_values_number(0);

    set_default();
}


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


void MissingValues::set(const tinyxml2::XMLDocument& document)
{
    set();

    from_XML(document);
}


// void set_instances_number(const size_t&) method


void MissingValues::set_instances_number(const size_t& new_instances_number)
{
    set_missing_values_number(0);

    instances_number = new_instances_number;
}


// void set_variables_number(const size_t&) method


void MissingValues::set_variables_number(const size_t& new_variables_number)
{
    set_missing_values_number(0);

    variables_number = new_variables_number;
}


// void set_default(void) method


void MissingValues::set_default(void)
{
    scrubbing_method = Unuse;

    display = true;
}


// void set_display(const bool&) method


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


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


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


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


void MissingValues::set_item(const size_t& index, const size_t& instance_index, const size_t& variable_index)
{
    // Control sentence (if debug)

#ifndef NDEBUG

    const size_t missing_values_number = get_missing_values_number();

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

        buffer << "OpenNN Exception: MissingValues class.\n"
               << "void set_item(const size_t&, const size_t&, const size_t&) method.\n"
               << "Index (" << index << ") must be less than number of missing values (" << missing_values_number << ").\n";

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

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

        buffer << "OpenNN Exception: MissingValues class.\n"
               << "void set_item(const size_t&, const size_t&, const size_t&) method.\n"
               << "Index of instance (" << instance_index << ") must be less than number of instances (" << instances_number << ").\n";

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

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

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

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

#endif

    items[index].instance_index = instance_index;
    items[index].variable_index = variable_index;
}


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


void MissingValues::append(const size_t& instance_index, const size_t& variable_index)
{
#ifndef NDEBUG

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

        buffer << "OpenNN Exception: MissingValues class.\n"
               << "void append(const size_t&, const size_t&) method.\n"
               << "Index of instance (" << instance_index << ") must be less than number of instances (" << instances_number << ").\n";

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

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

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

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

#endif

    Item item(instance_index, variable_index);

    items.push_back(item);
}


// void set_missing_values_number(const size_t&) method


void MissingValues::set_missing_values_number(const size_t& new_missing_values_number)
{
    items.set(new_missing_values_number);
}


// void set_scrubbing_method(const ScrubbingMethod&) method


void MissingValues::set_scrubbing_method(const ScrubbingMethod& new_scrubbing_method)
{
    scrubbing_method = new_scrubbing_method;
}


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


void MissingValues::set_scrubbing_method(const std::string& new_scrubbing_method)
{
    if(new_scrubbing_method == "Unuse")
    {
        scrubbing_method = Unuse;
    }
    else if(new_scrubbing_method == "Mean")
    {
        scrubbing_method = Mean;
    }
    else
    {
        std::ostringstream buffer;

        buffer << "OpenNN Exception: MissingValues class.\n"
               << "void new_scrubbing_method(const std::string&) method.\n"
               << "Unknown scrubbing method: " << new_scrubbing_method << ".\n";

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

// bool has_missing_values(void) const method


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


// bool has_missing_values(const size_t&) const method


bool MissingValues::has_missing_values(const size_t& instance_index) const
{
    if(items.empty())
    {
        return(false);
    }

    const size_t missing_values_number = get_missing_values_number();

    for(size_t i = 0; i < missing_values_number; i++)
    {
        if(items[i].instance_index == instance_index)
        {
            return(true);
        }
    }

    return(false);
}


// bool has_missing_values(const size_t&, const Vector<size_t>&) const method


bool MissingValues::has_missing_values(const size_t& instance_index, const Vector<size_t>& variables_indices) const
{
    const size_t missing_values_number = get_missing_values_number();

    const size_t variables_number = variables_indices.size();

    for(size_t i = 0; i < missing_values_number; i++)
    {
        if(items[i].instance_index == instance_index)
        {
            for(size_t j = 0; j < variables_number; j++)
            {
                if(items[i].variable_index == variables_indices[j])
                {
                    return(true);
                }
            }
        }
    }

    return(false);
}


// bool is_missing_value(const size_t&, const size_t&) const method


bool MissingValues::is_missing_value(const size_t& instance_index, const size_t& variable_index) const
{
    if(items.empty())
    {
        return(false);
    }

    const size_t missing_values_number = get_missing_values_number();

    for(size_t i = 0; i < missing_values_number; i++)
    {
        if(items[i].instance_index == instance_index && items[i].variable_index == variable_index)
        {
            return(true);
        }
    }

    return(false);
}


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


Vector<size_t> MissingValues::arrange_missing_instances(void) const
{
    const size_t missing_values_number = get_missing_values_number();

    Vector<size_t> missing_instances;

    for(size_t i = 0; i < missing_values_number; i++)
    {
        if(!missing_instances.contains(items[i].instance_index))
        {
            missing_instances.push_back(items[i].instance_index);
        }
    }

    return(missing_instances);
}


// size_t count_missing_instances(void) const method


size_t MissingValues::count_missing_instances(void) const
{
    return(arrange_missing_instances().size());
}


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


Vector<size_t> MissingValues::arrange_missing_variables(void) const
{
    const size_t missing_values_number = get_missing_values_number();

    Vector<size_t> missing_variables;

    for(size_t i = 0; i < missing_values_number; i++)
    {
        if(!missing_variables.contains(items[i].variable_index))
        {
            missing_variables.push_back(items[i].variable_index);
        }
    }

    return(missing_variables);
}


// void convert_time_series(const size_t&) method


void MissingValues::convert_time_series(const size_t& lags_number)
{
    if(lags_number == 0)
    {
        return;
    }
/*
    const size_t missing_values_number = get_missing_values_number();

    //    const size_t new_missing_values_number = missing_values_number*(1+lags_number);

    Vector<Item> new_items;

//    size_t instance_index;
//    size_t variable_index;

    Item new_item;

    for(size_t i = 0; i < missing_values_number; i++)
    {
        instance_index = items[i].instance_index;
        variable_index = items[i].variable_index;

        for(size_t j = 0; j < 1+lags_number; j++)
        {
            new_item.instance_index = items[i].instance_index+j;

            new_item.variable_index = items[i].variable_index*(1+j);

            new_items.push_back(new_item);
        }
    }

    set_items(new_items);
*/
}


// void convert_autoassociation(void) method


void MissingValues::convert_autoassociation(void)
{
    const size_t missing_values_number = get_missing_values_number();

    Vector<Item> autoassociation_items(missing_values_number);

}


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


Vector< Vector<size_t> > MissingValues::arrange_missing_indices(void) const
{
    Vector< Vector<size_t> > missing_indices(variables_number);

    const size_t missing_values_number = get_missing_values_number();

    size_t variable_index;
    size_t instance_index;

    for(size_t i = 0; i < missing_values_number; i++)
    {
        variable_index = items[i].variable_index;
        instance_index = items[i].instance_index;

        missing_indices[variable_index].push_back(instance_index);
    }

    return(missing_indices);
}


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


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

    std::ostringstream buffer;

    // MissingValues

    tinyxml2::XMLElement* missing_values_element = document->NewElement("MissingValues");

    document->InsertFirstChild(missing_values_element);

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

    const size_t missing_values_number = get_missing_values_number();

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

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

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

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

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

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

    // Scrubbing method
    {
        element = document->NewElement("ScrubbingMethod");
        missing_values_element->LinkEndChild(element);

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

    // Missing values number
    {
        element = document->NewElement("MissingValuesNumber");
        missing_values_element->LinkEndChild(element);

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

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

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

        // Instance index

        tinyxml2::XMLElement* instance_index_element = document->NewElement("InstanceIndex");
        element->LinkEndChild(instance_index_element);

        buffer.str("");
        buffer << items[i].instance_index;

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

        // Variable index

        tinyxml2::XMLElement* variable_index_element = document->NewElement("VariableIndex");
        element->LinkEndChild(variable_index_element);

        buffer.str("");
        buffer << items[i].variable_index;

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

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

    // Missing values element

    const tinyxml2::XMLElement* missing_values_element = document.FirstChildElement("MissingValues");

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

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

    // Instances number

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

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

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

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

    // Variables number

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

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

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

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

    // Scrubbing method

    const tinyxml2::XMLElement* scrubbing_method_element = missing_values_element->FirstChildElement("ScrubbingMethod");

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

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

    const std::string scrubbing_method_string = scrubbing_method_element->GetText();

    set_scrubbing_method(scrubbing_method_string);

    // Missing values number

    const tinyxml2::XMLElement* missing_values_number_element = missing_values_element->FirstChildElement("MissingValuesNumber");

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

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

    const size_t missing_values_number = atoi(missing_values_number_element->GetText());

    set_missing_values_number(missing_values_number);

    if(missing_values_number <= 0)
    {
        return;
    }

    // Items

    unsigned index = 0;

    const tinyxml2::XMLElement* start_element = missing_values_number_element;

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

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

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

        // Instance index

        const tinyxml2::XMLElement* instance_index_element = item_element->FirstChildElement("InstanceIndex");

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

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

        const size_t instance_index = atoi(instance_index_element->GetText());

        items[i].instance_index = instance_index;

        // Variable index

        const tinyxml2::XMLElement* variable_index_element = item_element->FirstChildElement("VariableIndex");

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

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

        const size_t variable_index = atoi(variable_index_element->GetText());

        items[i].variable_index = variable_index;
    }
}


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


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

    const size_t missing_values_number = get_missing_values_number();

    buffer << "Missing values object\n"
           << "Instances number: " << instances_number << "\n"
           << "Variables number: " << variables_number << "\n"
           << "Missing values number: " << missing_values_number << "\n";

    for(size_t i = 0; i < missing_values_number; i++)
    {
        buffer << "Missing value " << i+1 << ":\n"
               << "Instance index: " << items[i].instance_index << "\n"
               << "Variable index: " << items[i].variable_index << "\n";
    }

    buffer << "Scrubbing method: " << write_scrubbing_method() << "\n";

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

    return(buffer.str());
}


// void print(void) const method


void MissingValues::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