DataSource.cxx

Go to the documentation of this file.

#ifdef HAVE_CONFIG_H
#include "config.h"
#else
#ifdef _MSC_VER
#include "msdevstudio/MSconfig.h"
#define isnan _isnan
#endif
#endif

//To have isnan.
#ifdef __APPLE__
#include <cstdlib>
#define _GLIBCPP_USE_C99 1
#endif

#include "DataSource.h"

#include "DataSourceException.h"

#include "axes/Range.h"
#include "pattern/Observer.h"

#include <algorithm>
#include <functional>

#include <cmath>
#include <cfloat>

#include <cassert>

#ifdef __APPLE__
using std::isnan;
#endif

#ifdef ITERATOR_MEMBER_DEFECT
using namespace std;
#else
using std::distance;
using std::string;
using std::vector;
#endif

DataSource::
DataSource ( const std::string & name )
  : m_ds_name ( name ),
    m_title(),
    m_is_null ( false )
{
}

DataSource::
DataSource ( const char * name )
  : m_ds_name ( name ),
    m_title(),
    m_is_null ( false )
{
}

DataSource::
DataSource ( const DataSource & ds )
  : m_ds_name ( ds.m_ds_name ),
    m_title( ds.m_title ),
    m_labels ( ds.m_labels ),
    m_is_null ( false ),
    m_shape ( ds.m_shape )
{
}

DataSource::
DataSource ( const std::vector < std::string > & labels )
  : m_labels ( labels ),
    m_is_null ( false )
{
}

DataSource::
DataSource ()
  : m_ds_name ( ),
    m_title(), 
    m_is_null ( false )
{
}

DataSource::
DataSource ( bool yes )
  : m_ds_name ( "null" ),
    m_title ( "Not valid DataSource" ),
    m_is_null ( yes )
{
}

DataSource::~DataSource()
{
  Observable::notifyObservers ( &hippodraw::Observer::willDelete );
}

void
DataSource::
copyPrivate ( const DataSource & other )
{
  m_ds_name = other.m_ds_name;
  m_is_null = other.m_is_null;
  m_labels = other.m_labels;
  m_shape = other.m_shape;
  m_title = other.m_title;
}

bool
DataSource::
isNull () const
{
  return m_is_null;
}

void DataSource::setName ( const std::string & name )
{
  m_ds_name = name;
  notifyObservers ();
}

const string & DataSource::getName () const
{
  return m_ds_name;
}

const string & DataSource::title () const
{
  return m_title;
}

void DataSource::setTitle ( const std::string & title )
{
  m_title = title;
  notifyObservers ();
}

void
DataSource::
addLabel ( const std::string & label )
{
  m_labels.push_back ( label );
}

bool
DataSource::
setLabelAt( const std::string & s, unsigned int i )
{
  if ( i >= m_labels.size() ) return false;
  m_labels[i] = s;
  notifyObservers ();

  return true;
}

const vector <string> &
DataSource::
getLabels () const
{
   return m_labels;
}

const string &
DataSource::
getLabelAt ( unsigned int i ) const
{
  if ( isNull() ) return title ();

  if ( m_labels.size () < i ) {
    string what ( "DataSource: argument out of range" );
    throw DataSourceException ( what );
  }

  return m_labels[i];
}

int
DataSource::
indexOf ( const std::string & label ) const
{
  int index = -1;
  vector< string >::const_iterator first 
    = find ( m_labels.begin(), m_labels.end(), label );

  if ( first != m_labels.end() ) {
#ifdef DISTANCE_DEFECT
    index = first - m_labels.begin();
#else
    index = distance ( m_labels.begin(), first );
#endif
  }

  return index;
}

bool
DataSource::
isValidColumn ( unsigned int index ) const
{
  unsigned int size = columns();
  if ( index >= size ) {
    const string what ( "DataSource: Index out of range" );
    throw DataSourceException ( what );
  }

  return true;
}

const vector < double > &
DataSource::
getColumn ( unsigned int index ) const
{
  isValidColumn ( index ); // will throw exception if bad
  unsigned int size = rows ();

  m_array.resize ( size, 0.0 );
  for ( unsigned int i = 0; i < size; i++ ) {
    m_array [ i ] = valueAt ( i, index );
  }

  return m_array;
}

const vector < double > &
DataSource::
getColumn ( const std::string & label ) const
{
  int index = indexOf ( label );
  if ( index < 0 ) {
    const string what ( "DataSource: Attempt to get column whose label"
                        " doesn't exist" );
    throw DataSourceException ( what );
  }

  return getColumn ( index );
}

bool 
DataSource::
isValidLabel ( const std::string & label ) const
{
  vector< string >::const_iterator first 
    = find ( m_labels.begin(), m_labels.end(), label );
  bool yes = first != m_labels.end();

  return yes;
}

void
DataSource::
throwIfInvalidLabel ( const std::string & label ) const
{
  bool yes = isValidLabel ( label );
  if ( yes == false ) {
    string what ( "DataSource: `" );
    what += label;
    what += "' not found in this data source";
    throw DataSourceException ( what );
  }
}

void
DataSource::
throwIfInvalidRowSize ( const std:: vector < double > & row )
{
  unsigned int size = columns ();
  if ( size != row.size () ) {
    const string what ( "DataSource: Attempt to add row whose size"
                        " is not equal to number of columns" );
    throw DataSourceException ( what );
  }
}

void
DataSource::
setLabels ( const std::vector < std::string > & v )
{
  m_labels = v;

  notifyObservers ();
}

void
DataSource::
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 > &
DataSource::
getShape () const
{
  return m_shape;
}

unsigned int
DataSource::getRank () const
{
  return m_shape.size();
}

bool
DataSource::
fillRange ( unsigned int column, Range & range ) const
{
  assert ( column < columns () );
  bool isValid = true;

  unsigned int size = rows ();
  if ( size > 0 ) {
    bool valid = false;
    double min = DBL_MAX;
    double max = DBL_MIN;
    double pos = DBL_MAX;
    for ( unsigned int i = 0; i < size; i++ ) {
      double x = valueAt ( i, column );

      if (  x != HUGE_VAL && 
            x != -HUGE_VAL &&
            isnan ( x ) == false ) {
        min = std::min ( min, x );
        max = std::max ( max, x );
        if ( x > 0.0 ) pos = std::min ( pos, x );
        valid = true;
      }
      else {
        isValid = false;
      }
    }
    if ( valid == true ) {
      range.setRange ( min, max, pos );
    }
  }

  return isValid;
}

bool
DataSource::
isMultiDimensional( const std::string & column ) const
{
  return false;
}

bool
DataSource::
setReleventIndex( const std::string & column,
                  const std::vector< unsigned int >& index )
{
  // Do not call this fucntion unless implemented in base class
  assert( 0 );
  
  return false;
}

unsigned int
DataSource::
indexOfMaxElement ( unsigned int column ) const
{
  assert ( column < columns () );

  unsigned int size = rows ();
  unsigned int index = 0;
  double m = valueAt ( 0, column );

  for ( unsigned int i = 1; i < size; i++ ) {
    double v = valueAt ( i, column );
    if ( v > m ) {
      index = i;
      m = v;
    }
  }

  return index;
}

unsigned int
DataSource::
indexOfMinElement ( unsigned int column ) const
{
  assert ( column < columns () );

  unsigned int size = rows ();
  unsigned int index = 0;
  double m = valueAt ( 0, column );

  for ( unsigned int i = 1; i < size; i++ ) {
    double v = valueAt ( i, column );
    if ( v < m ) {
      index = i;
      m = v;
    }
  }

  return index;
}

double
DataSource::
sum ( unsigned int column ) const
{
  assert ( column < columns () );

  unsigned int size = rows ();
  double sum = 0.0;

  for ( unsigned int i = 0; i < size; i++ ) {
    sum += valueAt ( i, column );
  }

  return sum;
}

---