Table.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: The Bio++ Development Group
//
// SPDX-License-Identifier: CECILL-2.1

#ifndef BPP_NUMERIC_TABLE_H
#define BPP_NUMERIC_TABLE_H


#include "../Clonable.h"
#include "TableExceptions.h"
#include "VectorTools.h"

// From the STL:
#include <string>
#include <vector>
#include <map>
#include <memory>


namespace bpp
{
template<class T>
class Table :
  public Clonable
{
protected:
  size_t nRow_, nCol_;
  std::vector< std::vector<T>> data_;
  std::vector<std::string> rowNames_;
  std::vector<std::string> colNames_;

public:
  Table(size_t nRow, size_t nCol) :
    nRow_(nRow),
    nCol_(nCol),
    data_(nCol),
    rowNames_(),
    colNames_()
  {
    for (size_t i = 0; i < nCol; ++i)
    {
      data_[i].resize(nRow);
    }
  }

  Table(const std::vector<std::string>& colNames) :
    nRow_(0),
    nCol_(colNames.size()),
    data_(colNames.size()),
    rowNames_(),
    colNames_()
  {
    setColumnNames(colNames); // May throw an exception.
  }


  Table(const Table& table) :
    nRow_(table.nRow_),
    nCol_(table.nCol_),
    data_(table.data_),
    rowNames_(table.rowNames_),
    colNames_(table.colNames_)
  {}

  Table(const std::vector<std::vector<T>>& vt) :
    nRow_(vt.size() == 0 ? 0 : vt[0].size()),
    nCol_(vt.size()),
    data_(vt),
    rowNames_(),
    colNames_()
  {}

  Table& operator=(const Table& table)
  {
    nRow_ = table.nRow_;
    nCol_ = table.nCol_;
    data_ = table.data_;
    rowNames_ = table.rowNames_;
    colNames_ = table.colNames_;
    return *this;
  }

  Table& operator=(const std::vector<std::vector<T>>& vt)
  {
    nCol_ = vt.size();
    if (vt.size() == 0)
    {
      nRow_ = 0;
      data_.clear();
    }
    else
    {
      nRow_ = vt[0].size();
      data_ = vt;
    }

    rowNames_.clear();
    colNames_.clear();
    return *this;
  }

  Table* clone() const { return new Table(*this); }

  virtual ~Table() {}

public:
  const std::vector< std::vector<T>>& getData() const
  {
    return data_;
  }


  T& operator()(size_t rowIndex, size_t colIndex)
  {
    if (colIndex >= nCol_)
      throw IndexOutOfBoundsException("Table::operator(size_t, size_t).", colIndex, 0, nCol_ - 1);
    if (rowIndex >= data_[colIndex].size())
      throw IndexOutOfBoundsException("Table::operator(size_t, size_t).", rowIndex, 0, data_[colIndex].size() - 1);
    return data_[colIndex][rowIndex];
  }

  const T& operator()(size_t rowIndex, size_t colIndex) const
  {
    if (colIndex >= nCol_)
      throw IndexOutOfBoundsException("Table::operator(size_t, size_t).", colIndex, 0, nCol_ - 1);
    if (rowIndex >= data_[colIndex].size())
      throw IndexOutOfBoundsException("Table::operator(size_t, size_t).", rowIndex, 0, data_[colIndex].size() - 1);
    return data_[colIndex][rowIndex];
  }

  T& operator()(const std::string& rowName, const std::string& colName)
  {
    if (rowNames_.size() == 0)
      throw NoTableRowNamesException("Table::operator(const string &, const string &).");
    if (colNames_.size() == 0)
      throw NoTableColumnNamesException("Table::operator(const string &, const string &).");
    try
    {
      size_t rowIndex = VectorTools::which(rowNames_, rowName);
      size_t colIndex = VectorTools::which(colNames_, colName);
      return (*this)(rowIndex, colIndex);
    }
    catch (ElementNotFoundException<std::string>& ex)
    {
      throw TableNameNotFoundException("Table::operator(const string &, const string &).", *ex.getElement());
    }
  }

  const T& operator()(const std::string& rowName, const std::string& colName) const
  {
    if (rowNames_.size() == 0)
      throw NoTableRowNamesException("Table::operator(const string &, const string &).");
    if (colNames_.size() == 0)
      throw NoTableColumnNamesException("Table::operator(const string &, const string &).");
    try
    {
      size_t rowIndex = VectorTools::which(rowNames_, rowName);
      size_t colIndex = VectorTools::which(colNames_, colName);
      return (*this)(rowIndex, colIndex);
    }
    catch (ElementNotFoundException<std::string>& ex)
    {
      throw TableNameNotFoundException("Table::operator(const string &, const string &).", *ex.getElement());
    }
  }


  T& operator()(const std::string& rowName, size_t colIndex)
  {
    if (rowNames_.size() == 0)
      throw NoTableRowNamesException("Table::operator(const string &, size_t).");
    if (colIndex >= nCol_)
      throw IndexOutOfBoundsException("Table::operator(const string &, size_t).", colIndex, 0, nCol_ - 1);
    try
    {
      size_t rowIndex = VectorTools::which(rowNames_, rowName);
      return (*this)(rowIndex, colIndex);
    }
    catch (ElementNotFoundException<std::string>& ex)
    {
      throw TableNameNotFoundException("Table::operator(const string &, size_t).", *ex.getElement());
    }
  }


  const T& operator()(const std::string& rowName, size_t colIndex) const
  {
    if (rowNames_.size() == 0)
      throw NoTableRowNamesException("Table::operator(const string &, size_t).");
    if (colIndex >= nCol_)
      throw IndexOutOfBoundsException("Table::operator(const string &, size_t).", colIndex, 0, nCol_ - 1);
    try
    {
      size_t rowIndex = VectorTools::which(rowNames_, rowName);
      return (*this)(rowIndex, colIndex);
    }
    catch (ElementNotFoundException<std::string>& ex)
    {
      throw TableNameNotFoundException("Table::operator(const string &, size_t).", *ex.getElement());
    }
  }


  T& operator()(size_t rowIndex, const std::string& colName)
  {
    if (colNames_.size() == 0)
      throw NoTableColumnNamesException("Table::operator(size_t, const string &).");
    try
    {
      size_t colIndex = VectorTools::which(colNames_, colName);
      if (rowIndex >= data_[colIndex].size())
        throw IndexOutOfBoundsException("Table::operator(size_t, const string &).", rowIndex, 0, data_[colIndex].size() - 1);
      return (*this)(rowIndex, colIndex);
    }
    catch (ElementNotFoundException<std::string>& ex)
    {
      throw TableNameNotFoundException("Table::operator(const string &, const string &).", *ex.getElement());
    }
  }


  const T& operator()(size_t rowIndex, const std::string& colName) const
  {
    if (colNames_.size() == 0)
      throw NoTableColumnNamesException("Table::operator(size_t, const string &).");
    try
    {
      size_t colIndex = VectorTools::which(colNames_, colName);
      if (rowIndex >= data_[colIndex].size())
        throw IndexOutOfBoundsException("Table::operator(size_t, const string &).", rowIndex, 0, data_[colIndex].size() - 1);
      return (*this)(rowIndex, colIndex);
    }
    catch (ElementNotFoundException<std::string>& ex)
    {
      throw TableNameNotFoundException("Table::operator(const string &, const string &).", *ex.getElement());
    }
  }

  size_t getNumberOfColumns() const { return nCol_; }

  void setColumnNames(const std::vector<std::string>& colNames)
  {
    if (!VectorTools::isUnique(colNames))
      throw DuplicatedTableColumnNameException("Table::setColumnNames(...). Column names must be unique.");
    if (colNames.size() != nCol_)
      throw DimensionException("Table::setColumnNames.", colNames.size(), nCol_);
    else

      colNames_ = colNames;
  }

  const std::vector<std::string>& getColumnNames() const
  {
    if (colNames_.size() == 0)
      throw NoTableColumnNamesException("Table::getColumnNames().");
    return colNames_;
  }

  std::vector<std::string>& getColumnNames()
  {
    if (colNames_.size() == 0)
      throw NoTableColumnNamesException("Table::getColumnNames().");
    return colNames_;
  }

  std::string getColumnName(size_t index) const
  {
    if (colNames_.size() == 0)
      throw NoTableColumnNamesException("Table::getColumnName(size_t).");
    if (index >= nCol_)
      throw IndexOutOfBoundsException("Table::getColumnName(size_t).", index, 0, nCol_ - 1);
    return colNames_[index];
  }


  bool hasColumnNames() const { return colNames_.size() != 0; }

  std::vector<T>& getColumn(size_t index)
  {
    if (index >= nCol_)
      throw IndexOutOfBoundsException("Table::getColumn(size_t).", index, 0, nCol_ - 1);
    return data_[index];
  }

  const std::vector<T>& getColumn(size_t index) const
  {
    if (index >= nCol_)
      throw IndexOutOfBoundsException("Table::getColumn(size_t).", index, 0, nCol_ - 1);
    return data_[index];
  }


  std::vector<T>& getColumn(const std::string& colName)
  {
    if (colNames_.size() == 0)
      throw NoTableColumnNamesException("Table::getColumn(const string &).");
    try
    {
      size_t colIndex = VectorTools::which(colNames_, colName);
      return data_[colIndex];
    }
    catch (ElementNotFoundException<std::string>& ex)
    {
      throw TableColumnNameNotFoundException("Table::getColumn(const string &).", colName);
    }
  }

  const std::vector<T>& getColumn(const std::string& colName) const
  {
    if (colNames_.size() == 0)
      throw NoTableColumnNamesException("Table::getColumn(const string &).");
    try
    {
      size_t colIndex = VectorTools::which(colNames_, colName);
      return data_[colIndex];
    }
    catch (ElementNotFoundException<std::string>& ex)
    {
      throw TableColumnNameNotFoundException("Table::getColumn(const string &).", colName);
    }
  }


  bool hasColumn(const std::string& colName) const
  {
    if (colNames_.size() == 0)
      return false;
    for (size_t i = 0; i < colNames_.size(); i++)
    {
      if ((colNames_)[i] == colName)
        return true;
    }
    return false;
  }


  void deleteColumn(size_t index)
  {
    if (index >= nCol_)
      throw IndexOutOfBoundsException("Table::deleteColumn(size_t).", index, 0, nCol_ - 1);
    data_.erase(data_.begin() + (long)index);
    if (colNames_.size() != 0)
      colNames_.erase(colNames_.begin() + (long)(index));
    nCol_--;
  }

  void deleteColumns(size_t index, size_t len)
  {
    if (index >= nCol_)
      throw IndexOutOfBoundsException("Table::deleteColumns(size_t, size_t).", index, 0, nCol_ - 1);
    if (index + len >= nCol_)
      throw IndexOutOfBoundsException("Table::deleteColumns(size_t, size_t).", index + len, 0, nCol_ - 1);

    data_.erase(data_.begin() + (long)index, data_.begin() + (long)(index + len));
    if (colNames_.size() != 0)
      colNames_.erase(colNames_.begin() + (long)(index), colNames_.begin() + (long)(index + len));

    nCol_ -= len;
  }

  void deleteColumn(const std::string& colName)
  {
    if ((colNames_.size() == 0))
      throw NoTableColumnNamesException("Table::deleteColumn(const string &).");
    try
    {
      size_t colIndex = VectorTools::which(colNames_, colName);
      data_.erase(data_.begin() + (size_t)(colIndex));
      colNames_.erase(colNames_.begin() + (size_t)(colIndex));
      nCol_--;
    }
    catch (ElementNotFoundException<std::string>& ex)
    {
      throw TableColumnNameNotFoundException("Table::deleteColumn(const string &).", colName);
    }
  }


  void addColumn(const std::vector<T>& newColumn, int pos = -1)
  {
    if (pos > (int)nCol_)
      throw DimensionException("Table::addColumn.", (size_t)pos, nCol_);
    if (pos == -1)
      pos = (int)nCol_;

    if (colNames_.size())
      throw TableColumnNamesException("Table::addColumn. Table has column names.");
    if (newColumn.size() != nRow_)
      throw DimensionException("Table::addColumn.", newColumn.size(), nRow_);

    data_.insert(data_.begin() + pos, newColumn);
    nCol_++;
  }

  void addColumn(const std::string& colName, const std::vector<T>& newColumn, int pos = -1)
  {
    if (pos > (int)nCol_)
      throw DimensionException("Table::addColumn.", pos, nCol_);
    if (pos == -1)
      pos = nCol_;

    if ((colNames_.size() == 0) && (nCol_ != 0))
      throw NoTableColumnNamesException("Table::addColumn. Table has column names.");

    if (newColumn.size() != nRow_)
      throw DimensionException("Table::addColumn.", newColumn.size(), nRow_);
    if (nCol_ > 0 && find(colNames_.begin(), colNames_.end(), colName) != colNames_.end())
      throw DuplicatedTableColumnNameException("Table::addColumn(const string &, const std::vector<string> &). Column names must be unique.");

    colNames_.insert(colNames_.begin() + pos, colName);
    data_.insert(data_.begin() + pos, newColumn);
    nCol_++;
  }

  void addColumn(std::string& st, const std::string& sep = "\t", int pos = -1, int rowCol = -1)
  {
    if (pos > (int)nCol_)
      throw DimensionException("Table::addColumn.", (size_t)pos, nCol_);
    if (pos == -1)
      pos = (int)nCol_;

    StringTokenizer stok(st, sep, false, true);
    std::vector<std::string> row(stok.getTokens().begin(), stok.getTokens().end());

    if (row.size() != nRow_ + (rowCol >= 0) ? 1 : 0)
      throw BadIntegerException("Table::addColumn. Bad number of rows: ", (int)row.size());

    std::vector<T> newColumn;

    for (size_t i = 0; i < row.size(); i++)
    {
      if ((int)i == rowCol)
      {
        std::string colName = row[i];
        if (find(colNames_.begin(), colNames_.end(), colName) != colNames_.end())
          throw DuplicatedTableColumnNameException("Table::addColumn(const std::vector<string> &). Column names must be unique.");

        colNames_.insert(colNames_.begin() + (long)pos, colName);
      }
      else
      {
        std::stringstream ss(row[i]);
        T t;
        ss >> t;
        newColumn.push_back(t);
      }
    }
    data_.insert(data_.begin() + pos, newColumn);

    nCol_++;
  }


  void setColumn(const std::vector<T>& newColumn, size_t pos)
  {
    if (pos >= nCol_)
      throw DimensionException("Table::setColumn.", pos, nCol_);

    if (newColumn.size() != nRow_)
      throw DimensionException("Table::setColumn.", newColumn.size(), nRow_);

    data_[pos] = newColumn;
  }

  void setColumn(const std::string& colName, const std::vector<T>& newColumn, size_t pos)
  {
    if (pos >= nCol_)
      throw DimensionException("Table::setColumn.", pos, nCol_);

    if (colNames_.size() == 0)
      throw NoTableColumnNamesException("Table::setColumn. Table has column names.");

    if (newColumn.size() != nRow_)
      throw DimensionException("Table::setColumn.", newColumn.size(), nRow_);

    if (find(colNames_.begin(), colNames_.end(), colName) != colNames_.end() &&
        find(colNames_.begin(), colNames_.end(), colName) != colNames_.begin() + pos)
      throw DuplicatedTableColumnNameException("Table::setColumn(const string &, const std::vector<T> &, size_t). Column names must be unique.");

    colNames_[pos] = colName;
    data_[pos] = newColumn;
  }

  size_t getNumberOfRows() const { return nRow_; }

  void setRowNames(const std::vector<std::string>& rowNames)
  {
    if (!VectorTools::isUnique(rowNames))
    {
      throw DuplicatedTableRowNameException("Table::setRowNames(...). Row names must be unique.");
    }
    if (rowNames.size() != nRow_)
      throw DimensionException("Table::setRowNames.", rowNames.size(), nRow_);
    else
    {
      rowNames_ = rowNames;
    }
  }


  std::vector<std::string> getRowNames()
  {
    if (rowNames_.size() == 0)
      throw NoTableRowNamesException("Table::getRowNames().");
    return rowNames_;
  }

  const std::vector<std::string>& getRowNames() const
  {
    if (rowNames_.size() == 0)
      throw NoTableRowNamesException("Table::getRowNames().");
    return rowNames_;
  }


  bool hasRow(const std::string& rowName) const
  {
    if (rowNames_.size() == 0)
      return false;
    for (size_t i = 0; i < rowNames_.size(); i++)
    {
      if ((rowNames_)[i] == rowName)
        return true;
    }
    return false;
  }


  std::string getRowName(size_t index) const
  {
    if (rowNames_.size() == 0)
      throw NoTableRowNamesException("Table::getRowName(size_t).");
    if (index >= nRow_)
      throw IndexOutOfBoundsException("Table::getRowName(size_t).", index, 0, nRow_ - 1);
    return (rowNames_)[index];
  }


  bool hasRowNames() const { return rowNames_.size() != 0; }

  std::vector<T> getRow(size_t index) const
  {
    if (index >= nRow_)
      throw IndexOutOfBoundsException("Table::getRow(size_t).", index, 0, nRow_ - 1);
    std::vector<T> row;
    for (size_t i = 0; i < nCol_; i++)
    {
      row.push_back(data_[i][index]);
    }
    return row;
  }


  std::vector<T> getRow(const std::string& rowName) const
  {
    if ((rowNames_.size() == 0))
      throw NoTableRowNamesException("Table::getRow(const string &).");
    try
    {
      size_t rowIndex = VectorTools::which(rowNames_, rowName);
      std::vector<T> row;
      for (size_t i = 0; i < nCol_; i++)
      {
        row.push_back(data_[i][rowIndex]);
      }
      return row;
    }
    catch (ElementNotFoundException<std::string>& ex)
    {
      throw TableRowNameNotFoundException("Table::getRow(const string &).", rowName);
    }
  }


  void deleteRow(size_t index)
  {
    for (size_t j = 0; j < nCol_; j++)
    {
      std::vector<T>* column = &data_[j];
      if (index >= column->size())
        throw IndexOutOfBoundsException("Table::deleteRow(size_t).", index, 0, column->size() - 1);
      column->erase(column->begin() + index);
    }
    if (rowNames_.size() != 0)
      rowNames_.erase(rowNames_.begin() + index);
    nRow_--;
  }

  void deleteRows(size_t index, size_t len)
  {
    for (size_t j = 0; j < nCol_; j++)
    {
      std::vector<T>* column = &data_[j];
      if (index >= column->size())
        throw IndexOutOfBoundsException("Table::deleteRow(size_t).", index, 0, column->size() - 1);
      column->erase(column->begin() + (long)index, column->begin() + long(index + len));
    }
    if (rowNames_.size() != 0)
      rowNames_.erase(rowNames_.begin() + long(index), rowNames_.begin() + long(index + len));
    nRow_--;
  }


  void deleteRow(const std::string& rowName)
  {
    if ((rowNames_.size() == 0))
      throw NoTableRowNamesException("Table::deleteRow(const string &).");
    try
    {
      size_t rowIndex = VectorTools::which(rowNames_, rowName);
      for (size_t j = 0; j < nCol_; j++)
      {
        std::vector<T>* column = &data_[j];
        column->erase(column->begin() + rowIndex);
      }
      rowNames_.erase(rowNames_.begin() + rowIndex);
      nRow_--;
    }
    catch (ElementNotFoundException<std::string>& ex)
    {
      throw TableRowNameNotFoundException("Table::deleteRow(const string &).", rowName);
    }
  }


  void addRow(const std::vector<T>& newRow, int pos = -1)
  {
    if (pos > (int)nRow_)
      throw DimensionException("Table::addRow.", pos, nRow_);

    if (pos == -1)
      pos = nRow_;

    if (rowNames_.size() != 0)
      throw TableRowNamesException("Table::addRow. Table has row names.");
    if (newRow.size() != nCol_)
      throw DimensionException("Table::addRow.", newRow.size(), nCol_);
    for (size_t j = 0; j < nCol_; j++)
    {
      data_[j].insert(data_[j].begin() + (size_t)pos, newRow[j]);
    }
    nRow_++;
  }

  void addRow(const std::string& rowName, const std::vector<T>& newRow, int pos = -1)
  {
    if (pos > (int)nRow_)
      throw DimensionException("Table::addRow.", pos, nRow_);
    if (pos == -1)
      pos = nRow_;

    if ((rowNames_.size() == 0) && (nRow_ != 0))
      throw NoTableRowNamesException("Table::addRow. Table has row names.");

    if (newRow.size() != nCol_)
      throw DimensionException("Table::addRow.", newRow.size(), nCol_);
    if (nRow_ > 0 && find(rowNames_.begin(), rowNames_.end(), rowName) != rowNames_.end())
      throw DuplicatedTableRowNameException("Table::addRow(const string &, const std::vector<string> &). Row names must be unique.");
    rowNames_.insert(rowNames_.begin() + (size_t)pos, rowName);
    for (size_t j = 0; j < nCol_; j++)
    {
      data_[j].insert(data_[j].begin() + (size_t)pos, newRow[j]);
    }
    nRow_++;
  }

  void addRow(std::string& st, const std::string& sep = "\t", int pos = -1, int rowCol = -1)
  {
    if (pos > (int)nRow_)
      throw DimensionException("Table::addRow.", (size_t)pos, nRow_);
    if (pos == -1)
      pos = (int)nRow_;

    StringTokenizer stok(st, sep, false, true);
    std::vector<std::string> row(stok.getTokens().begin(), stok.getTokens().end());

    if (row.size() != nCol_ + (rowCol >= 0) ? 1 : 0)
      throw BadIntegerException("Table::addRow. Bad number of columns: ", (int)row.size());

    size_t id = 0;

    for (size_t i = 0; i < row.size(); i++)
    {
      if ((int)i == rowCol)
      {
        std::string rowName = row[i];
        if (find(rowNames_.begin(), rowNames_.end(), rowName) != rowNames_.end())
          throw DuplicatedTableRowNameException("Table::addRow(const std::vector<string> &). Row names must be unique.");

        rowNames_.insert(rowNames_.begin() + (long)pos, rowName);
      }
      else
      {
        std::stringstream ss(row[i]);
        T t;
        ss >> t;
        data_[id].insert(data_[id].begin() + (long)pos, t);
        id++;
      }
    }
    nRow_++;
  }


public:
  static std::unique_ptr<Table<T>> read(std::istream& in, bool byRow, const std::string& sep = "\t", bool header = true, int names = -1)
  {
    std::string firstLine  = FileTools::getNextLine(in);
    StringTokenizer st1(firstLine, sep, false, true);
    std::vector<std::string> row1(st1.getTokens().begin(), st1.getTokens().end());
    size_t nCol = row1.size();
    std::unique_ptr< Table<T>> dt;

    if (header)
    {
      // Use first line as header.
      if (byRow)
      {
        dt = std::make_unique<Table<T>>(0, nCol);
        dt->setColumnNames(row1);
      }
      else
      {
        dt = std::make_unique<Table<T>>(nCol, 0);
        dt->setRowNames(row1);
      }
    }
    else
    {
      if (byRow)
      {
        dt = std::make_unique<Table<T>>(0, nCol - (names >= 0 ? 1 : 0));
        dt->addRow(firstLine, sep, names);
      }
      else
      {
        dt = std::make_unique<Table<T>>(nCol - (names >= 0 ? 1 : 0), 0);
        dt->addColumn(firstLine, sep, names);
      }
    }

    // Now read each line:
    std::string line = FileTools::getNextLine(in);

    while (!TextTools::isEmpty(line))
    {
      if (byRow)
        dt->addRow(line, sep, names);
      else
        dt->addColumn(line, sep, names);

      line = FileTools::getNextLine(in);
    }
    return dt;
  }


  static void write(const Table& data, std::ostream& out, bool byRow, const std::string& sep = "\t", bool alignHeaders = false)
  {
    size_t n = (byRow ? data.getNumberOfColumns() : data.getNumberOfRows());
    if (n == 0)
      return;
    size_t m = (byRow ? data.getNumberOfRows() : data.getNumberOfColumns());

    bool frontNames = ((byRow && data.hasRowNames()) || (!byRow && data.hasColumnNames()));

    if ((byRow && data.hasColumnNames()) || (!byRow && data.hasRowNames()))
    { // Write header
      std::vector<std::string> names = (byRow ? data.getColumnNames() : data.getRowNames());

      if (alignHeaders && frontNames)
        out << sep;
      out << names[0];
      for (size_t i = 1; i < n; ++i)
      {
        out << sep << names[i];
      }
      out << std::endl;
    }

    // now write each row (or column):

    for (size_t i = 0; i < m; ++i)
    {
      if (frontNames)
      {
        out << (byRow ? data.getRowName(i) : data.getColumnName(i)) << sep;
      }

      out << (byRow ? data(i, 0) : data(0, i));
      for (size_t j = 1; j < n; ++j)
      {
        out << sep << (byRow ? data(i, j) : data(j, i));
      }
      out << std::endl;
    }
  }

  static void write(const Table& data, bpp::OutputStream& out, bool byRow, const std::string& sep = "\t", bool alignHeaders = false)
  {
    size_t n = (byRow ? data.getNumberOfColumns() : data.getNumberOfRows());
    if (n == 0)
      return;
    size_t m = (byRow ? data.getNumberOfRows() : data.getNumberOfColumns());

    bool frontNames = ((byRow && data.hasRowNames()) || (!byRow && data.hasColumnNames()));

    if ((byRow && data.hasColumnNames()) || (!byRow && data.hasRowNames()))
    { // Write header
      std::vector<std::string> names = (byRow ? data.getColumnNames() : data.getRowNames());

      if (alignHeaders && frontNames)
        out << sep;
      out << names[0];
      for (size_t i = 1; i < n; ++i)
      {
        out << sep << names[i];
      }
      out.endLine();
    }

    // now write each row (or column):

    for (size_t i = 0; i < m; ++i)
    {
      if (frontNames)
        out << (byRow ? data.getRowName(i) : data.getColumnName(i)) << sep;

      out << (byRow ? data(i, 0) : data(0, i));
      for (size_t j = 1; j < n; ++j)
      {
        out << sep << (byRow ? data(i, j) : data(j, i));
      }
      out.endLine();
    }
  }
};
} // end of namespace bpp.
#endif // BPP_NUMERIC_TABLE_H