NumArrayTuple.cxx

Go to the documentation of this file.

#include "NumArrayTuple.h"

#include "axes/Range.h"
#include "datasrcs/DataSourceException.h"

#include "num_util.h"

#include <algorithm>
#include <numeric>

using namespace boost::python;

using std::string;
using std::vector;

NumArrayTuple::NumArrayTuple ()
  : DataSource ()
{
}

NumArrayTuple::~NumArrayTuple()
{
}

void
NumArrayTuple::
copy ( const DataSource & )
{
  assert ( false );
}

void
NumArrayTuple::
notifyObservers ( ) const
{
  Observable::notifyObservers ();
}

unsigned int
NumArrayTuple::
rows() const
{
  unsigned int size = 0;
  if ( m_data.empty () == false ) {
    const numeric::array & array = m_data[0];

    size = num_util::size ( array );
  }

  return size;
}

bool
NumArrayTuple::
empty () const
{
  return rows () == 0;
}

double
NumArrayTuple::
valueAt( unsigned int row, unsigned int column ) const
{
#ifdef HAVE_NUMERIC
  PyGILState_STATE state = PyGILState_Ensure ();
#endif

  assert ( column < m_data.size () );

  const numeric::array & array = m_data[column];

  int size = num_util::size ( array );
  assert ( row < static_cast < unsigned int > ( size ) );

  object result = array[row];

  double value = extract < double > ( result );
#ifdef HAVE_NUMERIC
  PyGILState_Release ( state );
#endif

  return value;
}

const std::vector < double > &
NumArrayTuple::
getRow ( unsigned int row ) const
{
  unsigned int size = m_data.size();
  m_row.resize ( size );
  for ( unsigned int column = 0; column < size; column++ ) {
    m_row [ column ] = valueAt ( row, column );
  }

  return m_row;
}

int
NumArrayTuple::
addColumn ( const std::string & label,
            boost::python::numeric::array array )
{
  // Check if label already exists.
  int index = indexOf ( label );
  if ( index >= 0 ) {
    string what ( "NumArrayTuple Attempt to add a column whose label"
                  " is same as other column." );
    throw DataSourceException ( what );
  }

  unsigned int new_size = num_util::size ( array );
  // Check if column has right size.
  if ( m_data.empty () == false ) {
    unsigned int old_size = rows ();

    if ( old_size != 0 && old_size != new_size ) {
      string what ( "NumArrayTuple Attempt to add a column whose size"
                    " is not equal to other columns." );
      throw DataSourceException ( what );
    }
  }
  m_data.push_back ( array );
  addLabel ( label );

  return m_data.size() - 1;
}

void
NumArrayTuple::
replaceColumn ( unsigned int col, 
                boost::python::numeric::array array )
{
  unsigned int size = columns ();
  if ( col >= size ) {
    const string what ( "NunArrayTuple: column doesn't exist" );
    throw DataSourceException ( what );
  }

  const numeric::array old_array = m_data[col];
  int old_size = num_util::size ( old_array );
  int new_size = num_util::size ( array );

  if ( old_size != 0 && old_size != new_size ) {
    const string what ( "NumArrayTuple: Attempt to replace column with one "
                        "whose size is not equal to other columns." );
    throw DataSourceException ( what );
  }
  m_data[col] = array;

  notifyObservers ();
}

void
NumArrayTuple::
replaceColumn ( const std::string & column,
                boost::python::numeric::array array )
{
  unsigned int index = indexOf ( column );

  replaceColumn ( index, array );
}

numeric::array
NumArrayTuple::
getNumArray( unsigned int index ) const
{
  unsigned int size = columns ();
  if ( index >= size ) {
    const string what ( "NunArrayTuple: column doesn't exist" );
    throw DataSourceException ( what );
  }
  return m_data[index];
}

numeric::array
NumArrayTuple::
getNumArray( const std::string & label ) const
{
   unsigned int index = indexOf ( label );
   return getNumArray( index );
}

void
NumArrayTuple::
setShape ( std::vector < unsigned int > & shape )
{
  unsigned int size = 1;
  for ( unsigned int i = 0; i < shape.size(); i++ ) {
    size *= shape[i];
  }

  m_shape = shape;
}

const vector < unsigned int > &
NumArrayTuple::
getShape () const
{
  return m_shape;
}

unsigned int
NumArrayTuple::getRank () const
{
  return m_shape.size();
}
void
NumArrayTuple::
clear ()
{
  assert ( false );
}

void
NumArrayTuple::
reserve ( unsigned int count )
{
  assert ( false );
}

void
NumArrayTuple::
addRow ( const std::vector < double > & row )
{
  assert ( false );
}

double 
NumArrayTuple::
operator [] (  std::vector < unsigned int > & indices ) const
{
  assert ( false );
  return 0.;
}

---