gridtable.cpp

Go to the documentation of this file.

/*****************************************************************************
    NumeRe: Framework fuer Numerische Rechnungen
    Copyright (C) 2019  Erik Haenel et al.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.
 
    This program 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 General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.
******************************************************************************/
 
#include "gridtable.hpp"
#include "../../kernel/core/utils/stringtools.hpp"
#include "../../kernel/core/datamanagement/tablecolumnimpl.hpp"
 
 
GridNumeReTable::GridNumeReTable()
{
    _table = NumeRe::Table();
}
 
 
GridNumeReTable::GridNumeReTable(int numRows, int numCols)
{
    _table = NumeRe::Table(numRows-2, numCols-1);
}
 
 
GridNumeReTable::GridNumeReTable(NumeRe::Table&& _extTable)
{
    _table = std::move(_extTable);
}
 
 
int GridNumeReTable::getNumHeadlines() const
{
    return _table.getHeadCount();
}
 
 
NumeRe::Table GridNumeReTable::getTableCopy()
{
    NumeRe::Table tableCopy(_table);
    return tableCopy;
}
 
 
NumeRe::Table& GridNumeReTable::getTableRef()
{
    return _table;
}
 
 
int GridNumeReTable::GetNumberRows()
{
    return std::max(_table.getLines(), 1u) + getNumHeadlines() + 1;
}
 
 
int GridNumeReTable::GetNumberCols()
{
    return _table.getCols() + 1;
}
 
 
bool GridNumeReTable::CanGetValueAs(int row, int col, const wxString& sTypeName)
{
    // Headlines
    if (row == 0 && (sTypeName == wxGRID_VALUE_FLOAT || sTypeName == "complex"))
        return false;
    else if (row < getNumHeadlines() && (sTypeName == wxGRID_VALUE_STRING || sTypeName == "plain"))
        return true;
 
    // Regular cells
    if (sTypeName == "complex" && _table.getColumnType(col) == TableColumn::TYPE_VALUE)
        return true;
 
    if (sTypeName == "datetime" && _table.getColumnType(col) == TableColumn::TYPE_DATETIME)
        return true;
 
    if (sTypeName == wxGRID_VALUE_FLOAT
        && _table.getColumnType(col) == TableColumn::TYPE_VALUE
        && (_table.getValue(row-getNumHeadlines(), col).imag() == 0 || mu::isnan(_table.getValue(row-getNumHeadlines(), col))))
        return true;
 
    if (sTypeName == wxGRID_VALUE_BOOL
        && _table.getColumnType(col) == TableColumn::TYPE_LOGICAL
        && _table.getColumn(col)->isValid(row-getNumHeadlines()))
        return true;
 
    if (sTypeName == "plain" && _table.getColumnType(col) == TableColumn::TYPE_STRING)
        return true;
 
    if (sTypeName == wxGRID_VALUE_STRING && _table.getColumnType(col) != TableColumn::TYPE_NONE)
        return true;
 
    return false;
}
 
 
double GridNumeReTable::GetValueAsDouble(int row, int col)
{
    // Return NAN, if this is not a numeric cell
    if (row < getNumHeadlines())
        return NAN;
 
    if (row - getNumHeadlines() >= (int)_table.getLines() || col >= (int)_table.getCols())
        return NAN;
 
    return _table.getValue(row - getNumHeadlines(), col).real();
}
 
 
bool GridNumeReTable::GetValueAsBool(int row, int col)
{
    // Return NAN, if this is not a numeric cell
    if (row < getNumHeadlines())
        return false;
 
    if (row - getNumHeadlines() >= (int)_table.getLines() || col >= (int)_table.getCols())
        return false;
 
    return _table.getValue(row - getNumHeadlines(), col).real() != 0.0;
}
 
 
void* GridNumeReTable::GetValueAsCustom(int row, int col, const wxString& sTypeName)
{
    value = _table.getValue(row - getNumHeadlines(), col);
    return static_cast<void*>(&value);
}
 
 
wxString GridNumeReTable::GetValue(int row, int col)
{
    if (row < getNumHeadlines() && col < (int)_table.getCols())
        return _table.getCleanHeadPart(col, row);
    else if (row - getNumHeadlines() >= (int)_table.getLines() || col >= (int)_table.getCols())
        return "";
    else
        return replaceControlCharacters(_table.getValueAsString(row - getNumHeadlines(), col));
}
 
 
void GridNumeReTable::SetValue(int row, int col, const wxString& value)
{
    int nHeadRows = getNumHeadlines();
 
    // Set the value
    if (row < nHeadRows)
        _table.setHeadPart(col, row, value.ToStdString());
    else
        _table.setValueAsString(row - nHeadRows, col, value.ToStdString());
 
    // If the number of headlines changed, notify the
    // grid to draw the newly added cells
    if (nHeadRows != getNumHeadlines() && GetView())
    {
        if (nHeadRows < getNumHeadlines())
        {
            wxGridTableMessage msg(this, wxGRIDTABLE_NOTIFY_ROWS_INSERTED, nHeadRows, getNumHeadlines() - nHeadRows);
            GetView()->ProcessTableMessage(msg);
        }
        else
        {
            wxGridTableMessage msg(this, wxGRIDTABLE_NOTIFY_ROWS_DELETED, getNumHeadlines(), nHeadRows - getNumHeadlines());
            GetView()->ProcessTableMessage(msg);
        }
    }
}
 
 
void GridNumeReTable::Clear()
{
    _table.Clear();
}
 
 
bool GridNumeReTable::InsertRows(size_t pos, size_t numRows)
{
    _table.insertLines(pos, numRows);
 
    // Notify the grid that the number of elements have
    // changed and that the grid has to be redrawn
    if (GetView())
    {
        wxGridTableMessage msg(this, wxGRIDTABLE_NOTIFY_ROWS_INSERTED, pos, numRows);
        GetView()->ProcessTableMessage(msg);
    }
 
    return true;
}
 
 
bool GridNumeReTable::AppendRows(size_t numRows)
{
    _table.appendLines(numRows);
 
    // Notify the grid that the number of elements have
    // changed and that the grid has to be redrawn
    if (GetView())
    {
        wxGridTableMessage msg(this, wxGRIDTABLE_NOTIFY_ROWS_APPENDED, numRows);
        GetView()->ProcessTableMessage(msg);
    }
 
    return true;
}
 
 
bool GridNumeReTable::DeleteRows(size_t pos, size_t numRows)
{
    _table.deleteLines(pos, numRows);
 
    // Notify the grid that the number of elements have
    // changed and that the grid has to be redrawn
    if (GetView())
    {
        wxGridTableMessage msg(this, wxGRIDTABLE_NOTIFY_ROWS_DELETED, pos, numRows);
        GetView()->ProcessTableMessage(msg);
    }
 
    return true;
}
 
 
bool GridNumeReTable::InsertCols(size_t pos, size_t numRows)
{
    _table.insertCols(pos, numRows);
 
    // Notify the grid that the number of elements have
    // changed and that the grid has to be redrawn
    if (GetView())
    {
        wxGridTableMessage msg(this, wxGRIDTABLE_NOTIFY_COLS_INSERTED, pos, numRows);
        GetView()->ProcessTableMessage(msg);
    }
 
    return true;
}
 
 
bool GridNumeReTable::AppendCols(size_t numRows)
{
    _table.appendCols(numRows);
 
    // Notify the grid that the number of elements have
    // changed and that the grid has to be redrawn
    if (GetView())
    {
        wxGridTableMessage msg(this, wxGRIDTABLE_NOTIFY_COLS_APPENDED, numRows);
        GetView()->ProcessTableMessage(msg);
    }
 
    return true;
}
 
 
bool GridNumeReTable::DeleteCols(size_t pos, size_t numRows)
{
    _table.deleteCols(pos, numRows);
 
    // Notify the grid that the number of elements have
    // changed and that the grid has to be redrawn
    if (GetView())
    {
        wxGridTableMessage msg(this, wxGRIDTABLE_NOTIFY_COLS_DELETED, pos, numRows);
        GetView()->ProcessTableMessage(msg);
    }
 
    return true;
}
 
 
wxString GridNumeReTable::GetRowLabelValue(int row)
{
    if (row < getNumHeadlines())
        return "#";
    else
        return toString(row - (getNumHeadlines()-1));
}
 
 
wxString GridNumeReTable::GetColLabelValue(int col)
{
    return toString(col+1);
}
 
 
double GridNumeReTable::min(const wxGridCellCoordsContainer& coords) const
{
    double dMin = NAN;
    const int nHeadLines = getNumHeadlines();
    const wxGridCellsExtent& cellExtent = coords.getExtent();
 
    for (int i = cellExtent.m_topleft.GetRow(); i <= cellExtent.m_bottomright.GetRow(); i++)
    {
        for (int j = cellExtent.m_topleft.GetCol(); j <= cellExtent.m_bottomright.GetCol(); j++)
        {
            if (!coords.contains(i, j))
                continue;
 
            double val = _table.getValue(i - nHeadLines, j).real();
 
            if (isnan(dMin) || val < dMin)
                dMin = val;
        }
    }
 
    return dMin;
}
 
 
double GridNumeReTable::max(const wxGridCellCoordsContainer& coords) const
{
    double dMax = NAN;
    const int nHeadLines = getNumHeadlines();
    const wxGridCellsExtent& cellExtent = coords.getExtent();
 
    for (int i = cellExtent.m_topleft.GetRow(); i <= cellExtent.m_bottomright.GetRow(); i++)
    {
        for (int j = cellExtent.m_topleft.GetCol(); j <= cellExtent.m_bottomright.GetCol(); j++)
        {
            if (!coords.contains(i, j))
                continue;
 
            double val = _table.getValue(i - nHeadLines, j).real();
 
            if (isnan(dMax) || val > dMax)
                dMax = val;
        }
    }
 
    return dMax;
}
 
 
mu::value_type GridNumeReTable::avg(const wxGridCellCoordsContainer& coords) const
{
    mu::value_type dSum = 0;
    size_t nCount = 0;
    const int nHeadLines = getNumHeadlines();
    const wxGridCellsExtent& cellExtent = coords.getExtent();
 
    for (int i = cellExtent.m_topleft.GetRow(); i <= cellExtent.m_bottomright.GetRow(); i++)
    {
        for (int j = cellExtent.m_topleft.GetCol(); j <= cellExtent.m_bottomright.GetCol(); j++)
        {
            if (!coords.contains(i, j))
                continue;
 
            mu::value_type val = _table.getValue(i - nHeadLines, j);
 
            if (!mu::isnan(val))
            {
                nCount++;
                dSum += val;
            }
        }
    }
 
    if (nCount)
        return dSum / (double)nCount;
 
    return 0.0;
}
 
 
mu::value_type GridNumeReTable::sum(const wxGridCellCoordsContainer& coords) const
{
    mu::value_type dSum = 0;
    const int nHeadLines = getNumHeadlines();
    const wxGridCellsExtent& cellExtent = coords.getExtent();
 
    for (int i = cellExtent.m_topleft.GetRow(); i <= cellExtent.m_bottomright.GetRow(); i++)
    {
        for (int j = cellExtent.m_topleft.GetCol(); j <= cellExtent.m_bottomright.GetCol(); j++)
        {
            if (!coords.contains(i, j))
                continue;
 
            mu::value_type val = _table.getValue(i - nHeadLines, j);
 
            if (!mu::isnan(val))
                dSum += val;
        }
    }
 
    return dSum;
}
 
 
std::vector<int> GridNumeReTable::getColumnTypes() const
{
    std::vector<int> vTypes;
 
    for (size_t i = 0; i < _table.getCols(); i++)
        vTypes.push_back(_table.getColumnType(i));
 
    return vTypes;
}
 
 
std::vector<std::string> GridNumeReTable::getCategories(int col) const
{
    if (_table.getColumnType(col) == TableColumn::TYPE_CATEGORICAL)
        return static_cast<CategoricalColumn*>(_table.getColumn(col))->getCategories();
 
    return std::vector<std::string>();
}