DianaArray.hpp

/* -----------------------------------------------------------------------------
 *  Diana process modelling, simulation and analysis software
 *  Copyright (c) 2005, Michael Krasnyk
 *  All rights reserved.
 *
 *  This file is a part of Diana process modelling, simulation and analysis software
 *
 *  Diana 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 (see accompanying file LICENSE)
 * -----------------------------------------------------------------------------
 *  $Id: DianaArray.hpp 8160 2009-03-16 18:36:30Z miha $
 * -----------------------------------------------------------------------------
 *  Description:
 */

#ifndef DIANA_ARRAY_HPP
#define DIANA_ARRAY_HPP

#include "CapeTypes.hpp"
#include "CapeException.hpp"
#include <cstdarg>
#include <sstream>

namespace Diana{


  template<typename _T>
  class array {
  public:
    typedef _T                                tvalue;     
    typedef Common::Types::CapeArrayLong      tindices;   
    typedef std::vector<tvalue>               tvalues;    
    typedef size_t                            size_type;  

  public:
    inline array() {};
    
    array(const tindices& _dims) : dims(_dims) {
      int nelems;
      if(dims.size()>0) {
        nelems=1;
        for(tindices::size_type i=0;i<dims.size();i++) {
          if(dims[i]<0) throw std::string("array::array: incorrect dimensions");
          nelems*=dims[i];
        }
      }else if (dims.size()==0) {
        nelems=1;
        dims.push_back(1);
      }
      values.resize(nelems);
    }

    array(int nelems, tvalue* vals) : dims(1) {
      if(nelems<0) {
        throw std::string("array::array: incorrect dimension");
      }
      dims[0]=nelems;
      values.resize(nelems);
      for(int i=0;i<nelems;i++) values[i]=vals[i];
    }

    array(std::vector<tvalue> vals) : dims(1) {
      dims[0]=vals.size();
      values=vals;
    }

    array(int nrows, int ncols) : dims(2) {
      if((nrows<0)||(ncols<0)) {
        throw std::string("array::array: incorrect dimensions");
      }
      int nelems=nrows*ncols;
      dims[0]=nrows;
      dims[1]=ncols;
      values.resize(nelems, 0.0);
    }


    array(const array& ar) {
      dims=ar.dimensions();
      values=ar.get_values();
    }


    array& operator=(const array& ar) {
      if(this!=&ar) {
        dims=ar.dimensions();
        values=ar.get_values();
      }
      return *this;
    }


    virtual ~array() {};

    inline int              rank() const { return dims.size(); }

    inline size_type        size() const { return values.size(); }

    inline const tindices&  dimensions() const { return dims; }

    inline Common::Types::CapeBoolean      empty() const { return values.empty(); }

    inline tvalue&          at(size_type __n) { check_range(__n, "at"); return (*this)[__n]; };

    inline const tvalue&    at(size_type __n)  const { check_range(__n, "at"); return (*this)[__n]; };

    inline tvalue&          operator[] (size_type __n) { return values[__n]; };

    inline const tvalue&    operator[] (size_type __n) const { return values[__n]; };

    inline tvalue           front() const { return values.front(); };
    inline tvalue           back() const { return values.back(); };
    int                     find(const tindices& idx) const {
      if(idx.size()!=dims.size()) throw std::string("array::find: incorrect indices");
      if(dims.size()<=0) return -1; 
      int pos=idx[0];
      for(tindices::size_type i=1;i<dims.size();i++) {
        if((idx[i]<0)||(idx[i]>=dims[i])) return -1;
        pos=pos*dims[i]+idx[i];
      }
      return pos;
    }
    
    void set_value(const tindices& idx, tvalue value) {
      const int pos=find(idx);
      if((pos<0)||(static_cast<tindices::size_type>(pos)>values.size()))
        throw std::string("array::set_value: incorrect indices");
      values[pos]=value;
    }


    void set_value(tvalue value) {
      for(tindices::size_type i=0;i<values.size();i++) {
        values[i]=value;
      }
    }

    void set_values(const tvalues& _values) {
      if(values.size()!=_values.size()) throw std::string("array::set_values: incorrect values array");
      values=_values;
    }

    void add_value(const tindices& idx, tvalue value) {
      const int pos=find(idx);
      if((pos<0)||(static_cast<tindices::size_type>(pos)>values.size()))
        throw std::string("array::add_value: incorrect indices");
      values[pos]+=value;
    }

    tvalue get_value(const tindices& idx) const {
      const int pos=find(idx);
      if((pos<0)||(static_cast<tindices::size_type>(pos)>values.size())) return 0.0;
      return values[pos];
    }

    tvalue get_value(...) const {
      va_list lst;
      va_start(lst, this);
      tindices idx(rank());
      for(int i=0;i<rank();i++) {
        idx[i]=va_arg(lst, int);
      }
      va_end(lst);
      return get_value(idx);
    }
    
    const tvalues& get_values() const {
      return values;
    }

  private:
    void check_range(size_type __n, const char* func_name=NULL) const {
      if(__n>=values.size()) {
        std::ostringstream ostr;
        if(func_name!=NULL) ostr<<"Diana::array::"<<func_name; else ostr<<"array";
        ostr<<": argument "<<__n<<" not in range [0,"<<values.size()<<"]";
        throw ostr.str();
      }
    }


  private:
    tvalues                 values;  
    tindices                dims;    
  };

  typedef array<Common::Types::CapeDouble> DianaArray;

  std::ostream& print(std::ostream& ostr, const DianaArray& ar, int nentries=-1);

  std::ostream& print_matlab(std::ostream& ostr, const DianaArray& ar);
  
  std::ostream& operator<<(std::ostream& os, const DianaArray& ar);
};

#endif // DIANA_ARRAY_HPP