src/jarray.h

Go to the documentation of this file.

/* -*- mode: c++; indent-tabs-mode:nil -*- */
#ifndef JARRAY_H
#define JARRAY_H

#include <vector>
#include <string>
#include <complex>
#include <istream>
#include <ostream>
#include <cassert>
#include "sha1.h"

class jengine;

class jarray {
public:
  // C types, corresponding to J types
  // TODO: these are only for 32 bit linux, need ifdefs to cover 
  //       additional platforms
  typedef char B; 
  typedef char C; 
  typedef short S; 
#if _UNIX64
  typedef long long          I;  
#else
  typedef long               I;  
#endif
  typedef double D; 
  typedef struct {
    D re,      
      im;      
  }  Z;

  friend class jengine;

public:
  enum errorType {
    ERR_CONV=10,   
    ERR_SHAPE=11  
  };

  enum elementType {
    T_B01  =1,           
    T_LIT  =2,           
    T_INT  =4,           
    T_FL   =8,           
    T_CMPX =16           
  };
  // numeric constants, corresponding to J 7.01 types.
  // Not all of J types are supported, but the supported ones have
  // the full set of automatic widening conversions.
  //const static I T_B01  =1;           /**< B  boolean                      */
  //const static I T_LIT  =2;           /**< C  literal (character)          */
  //const static I T_INT  =4;           /**< I  integer                      */
  //const static I T_FL   =8;           /**< D  double (IEEE floating point) */
  //const static I T_CMPX =16;          /**< Z  complex                      */
  //const static I T_BOX  =32;          /**< A  boxed                        */
  //const static I T_XNUM =64;          /**< X  extended precision integer   */
  //const static I T_RAT  =128;         /**< Q  rational number              */
  //const static I T_SB01 =1024;        /**< P  sparse boolean               */
  //const static I T_SLIT =2048;        /**< P  sparse literal (character)   */
  //const static I T_SINT =4096;        /**< P  sparse integer               */
  //const static I T_SFL  =8192;        /**< P  sparse floating point        */
  //const static I T_SCMPX=16384;       /**< P  sparse complex               */
  //const static I T_SBOX =32768;       /**< P  sparse boxed                 */
  //const static I T_SBT  =65536;       /**< SB symbol                       */
  //const static I T_C2T  =131072;      /**< C2 unicode (2-byte characters)  */

protected:
  typedef struct {
    I offset,   
      flag,     
      maxbytes, 
      type,     
      refcnt,   
      n,        
      rank,     
      shape[1]; 
  } header;
  header *hdr; 
  jengine *je; 
  typedef struct {I*a;S j;C mflag,unused;} MS;

  bool allocate(jengine *je_, elementType type, const I rank, const I* shape);
  
  // conversions: T=bool
  inline static int fromB01(bool& v, const B d) {v=(d!=0); return 0;};
  inline static int fromLIT(bool& v, const C d) {return ERR_CONV;};
  inline static int fromINT(bool& v, const I d) {return ERR_CONV;};
  inline static int fromFL(bool& v, const D d) {return ERR_CONV;};
  inline static int fromCMPX(bool& v, const Z d) {return ERR_CONV;};
  inline static int toB01(const bool v, B& d) {d=v; return 0;};
  inline static int toLIT(const bool v, C& d) {return ERR_CONV;};
  inline static int toINT(const bool v, I& d) {d=v; return 0;};
  inline static int toFL(const bool v,  D& d) {d=v; return 0;};
  inline static int toCMPX(const bool v, Z& d) {d.re=v; d.im=0; return 0;};
  
  // conversions: T=char
  // it may be more convenient to obtain literal array as a string
  // via get(string&) method.
  inline static int fromB01(char& v, const B d) {return ERR_CONV;};
  inline static int fromLIT(char& v, const C d) {v=d; return 0;};
  inline static int fromINT(char& v, const I d) {return ERR_CONV;};
  inline static int fromFL(char& v, const D d) {return ERR_CONV;};
  inline static int fromCMPX(char& v, const Z d) {return ERR_CONV;};
  inline static int toB01(const char v, B& d) {return ERR_CONV;};
  inline static int toLIT(const char v, C& d) {d=v; return 0;};
  inline static int toINT(const char v, I& d) {d=v; return 0;};
  inline static int toFL(const char v,  D& d) {d=v; return 0;};
  inline static int toCMPX(const char v, Z& d) {d.re=v; d.im=0; return 0;};

  // conversions: T=int
  inline static int fromB01(int& v, const B d) {v=d; return 0;};
  inline static int fromLIT(int& v, const C d) {v=d; return 0;};
  inline static int fromINT(int& v, const I d) {v=d; return 0;};
  inline static int fromFL(int& v, const D d) {return ERR_CONV;};
  inline static int fromCMPX(int& v, const Z d) {return ERR_CONV;};
  inline static int toB01(const int v, B& d) {return ERR_CONV;};
  inline static int toLIT(const int v, C& d) {return ERR_CONV;};
  inline static int toINT(const int v, I& d) {d=v; return 0;};
  inline static int toFL(const int v,  D& d) {d=v; return 0;};
  inline static int toCMPX(const int v, Z& d) {d.re=v; d.im=0; return 0;};

  // conversions: T=long
  inline static int fromB01(long& v, const B d) {v=d; return 0;};
  inline static int fromLIT(long& v, const C d) {v=d; return 0;};
  inline static int fromINT(long& v, const I d) {v=d; return 0;};
  inline static int fromFL(long& v, const D d) {return ERR_CONV;};
  inline static int fromCMPX(long& v, const Z d) {return ERR_CONV;};
  inline static int toB01(const long v, B& d) {return ERR_CONV;};
  inline static int toLIT(const long v, C& d) {return ERR_CONV;};
  inline static int toINT(const long v, I& d) {d=v; return 0;};
  inline static int toFL(const long v,  D& d) {d=v; return 0;};
  inline static int toCMPX(const long v, Z& d) {d.re=v; d.im=0; return 0;};

  // conversions: T=long long
  inline static int fromB01(long long& v, const B d) {v=d; return 0;};
  inline static int fromLIT(long long& v, const C d) {v=d; return 0;};
  inline static int fromINT(long long& v, const I d) {v=d; return 0;};
  inline static int fromFL(long long& v, const D d) {return ERR_CONV;};
  inline static int fromCMPX(long long& v, const Z d) {return ERR_CONV;};
  inline static int toB01(const long long v, B& d) {return ERR_CONV;};
  inline static int toLIT(const long long v, C& d) {return ERR_CONV;};
  inline static int toINT(const long long v, I& d) {d=v; return 0;};
  inline static int toFL(const long long v,  D& d) {d=v; return 0;};
  inline static int toCMPX(const long long v, Z& d) {d.re=v; d.im=0; return 0;};

  // conversions: T=double
  inline static int fromB01(double& v, const B d) {v=d; return 0;};
  inline static int fromLIT(double& v, const C d) {v=d; return 0;};
  inline static int fromINT(double& v, const I d) {v=d; return 0;};
  inline static int fromFL(double& v, const D d)  {v=d; return 0;};
  inline static int fromCMPX(double& v, const Z d) {return ERR_CONV;};
  inline static int toB01(const double v, B& d) {return ERR_CONV;};
  inline static int toLIT(const double v, C& d) {return ERR_CONV;};
  inline static int toINT(const double v, I& d) {d=v; return 0;};
  inline static int toFL(const double v,  D& d) {d=v; return 0;};
  inline static int toCMPX(const double v, Z& d) {d.re=v; d.im=0; return 0;};

  // conversions: T=complex<double>
  inline static int fromB01(std::complex<double>& v, const B d) {
    return ERR_CONV;};
  inline static int fromLIT(std::complex<double>& v, const C d) {
    v=d; return 0;};
  inline static int fromINT(std::complex<double>& v, const I d) {
    v=d; return 0;};
  inline static int fromFL(std::complex<double>& v, const D d)  {
    v=d; return 0;};
  inline static int fromCMPX(std::complex<double>& v, const Z d) {
    std::complex<double> c(d.re, d.im); v=c; return 0;};
  inline static int toB01(const std::complex<double> v, B& d) {
    return ERR_CONV;};
  inline static int toLIT(const std::complex<double> v, C& d) {
    return ERR_CONV;};
  inline static int toINT(const std::complex<double> v, I& d) {
    return ERR_CONV;};
  inline static int toFL(const std::complex<double> v,  D& d) {
    return ERR_CONV;};
  inline static int toCMPX(const std::complex<double> v, Z& d) {
    d.re=v.real(); d.im=v.imag(); return 0;};
  void grab() const;
  
  void release();

  // returns pointer to the header and (if parameter is "true", which is
  // default) marks the array as owned by J preventing its memory from 
  // being freed as it goes out of scope.
  inline I getHeader(bool give_up_ownership=true) const {
    if (give_up_ownership) hdr->flag|=OWNED_BY_J;
    return (I)hdr;
  };

private:
  // flag, marking the array as J owned, preventing its memory from
  // being freed when the array goes out of scope.
  const static int OWNED_BY_J=131072;
  // marks the array as being allocated on heap without J assistance
  const static int OWNED_BY_JPLUS=262144;

public:
  I getRefcount() const {return hdr->refcnt;};

  template<class T> inline int get(T& v, const int i) const {
    switch(hdr->type) {
    case T_B01: return fromB01(v,((B*)(((B*)hdr)+hdr->offset))[i]);
    case T_LIT: return fromLIT(v,((C*)(((B*)hdr)+hdr->offset))[i]);
    case T_INT: return fromINT(v,((I*)(((B*)hdr)+hdr->offset))[i]);
    case T_FL: return fromFL(v,((D*)(((B*)hdr)+hdr->offset))[i]);
    case T_CMPX: return fromCMPX(v,((Z*)(((B*)hdr)+hdr->offset))[i]);
    default: return ERR_CONV;
    };
  };

  template<class T> inline int set(const int i, const T v) {
    switch(hdr->type) {
    case T_B01: return toB01(v,((B*)(((B*)hdr)+hdr->offset))[i]);
    case T_LIT: return toLIT(v,((C*)(((B*)hdr)+hdr->offset))[i]);
    case T_INT: return toINT(v,((I*)(((B*)hdr)+hdr->offset))[i]);
    case T_FL: return toFL(v,((D*)(((B*)hdr)+hdr->offset))[i]);
    case T_CMPX: return toCMPX(v,((Z*)(((B*)hdr)+hdr->offset))[i]);
    default: return ERR_CONV;
    };
  };

  template<class T> int get(std::vector<T>& v) const {
    std::vector<T> r;
    r.reserve(hdr->n);
    int e;
    switch(hdr->type) {
    case T_B01: for(int i=0;i<hdr->n;i++)
        if (e=fromB01(v[i],((B*)(((B*)hdr)+hdr->offset))[i])) return e;
      break;
    case T_LIT: for(int i=0;i<hdr->n;i++)
        if (e=fromLIT(v[i],((C*)(((B*)hdr)+hdr->offset))[i])) return e;
      break;
    case T_INT: for(int i=0;i<hdr->n;i++)
        if (e=fromINT(v[i],((I*)(((B*)hdr)+hdr->offset))[i])) return e;
      break;
    case T_FL: for(int i=0;i<hdr->n;i++)
        if (e=fromFL(v[i],((D*)(((B*)hdr)+hdr->offset))[i])) return e;
      break;
    case T_CMPX: for(int i=0;i<hdr->n;i++)
        if (e=fromCMPX(v[i],((Z*)(((B*)hdr)+hdr->offset))[i])) return e;
      break;
    default: return ERR_CONV;
    };
    r.swap(v);
    return 0;
  };

  template<class T> int get(T& v);

  jarray();

  jarray(jengine *je_, std::istream& in);

  static jarray::I esize(elementType type);

  jarray::I esize() const;

  void addhash(SHA1 &sha);

  bool write(std::ostream& out);

  inline bool isValid() const {
    return hdr!=NULL;
  };

  inline const I type() const {
    return hdr->type;
  };

  inline const I rank() const {
    return hdr->rank;
  };

  inline I* shape() const {
    return &hdr->shape[0];
  };

  int extent(int dimension) const {
    assert((dimension>=0)&&(dimension<rank()));
    return shape()[dimension];
  };

  inline void shape(std::vector<I> &shape) const {
    std::vector<I> r(&hdr->shape[0],&hdr->shape[rank()]);
    r.swap(shape);
  };

  inline const int size() const {
    int n=1;
    for (int i=0;i<rank();i++) n*=hdr->shape[i];
    return n;
  };  

  inline I* data() const {
    return (I*)(((B*)hdr)+hdr->offset);
  };

  jengine* getEngine() const {
    return je;
  };

  jarray(jengine *je_, void *hdr_);

  jarray(jengine *je_, elementType type, I rank, I* shape);

  jarray(jengine *je_, elementType type, const std::vector<I>& shape);

  jarray(jengine *je_,const std::string &str);

  jarray(const jarray &other);

  jarray& assign(const jarray& other);
  
  inline jarray& operator=(const jarray& other) {
    return assign(other);
  };

  bool operator== ( const jarray& rhs ) const;

  ~jarray();
};

std::ostream& operator<< (std::ostream& stream, const jarray& array);

template<class T> class jarray_of_type: public jarray {
private:
  static elementType jtype(I dummy) {return T_INT;};
  static elementType jtype(D dummy) {return T_FL;};
  static elementType jtype(Z dummy) {return T_CMPX;};
  static elementType jtype(std::complex<D> dummy) {return T_CMPX;};
  
public:
  jarray_of_type(const jarray &ja):jarray() {
    T dummy;
    elementType type=jtype(dummy);
    if (type!=ja.type()) { // make an independent copy and convert type
      allocate(ja.getEngine(), type, ja.rank(), ja.shape());
      int n=ja.size();
      for (int i=0;i<n;i++) {
        T v;
        ja.get(v,i);
        set(i,v);
      };
    } else assign(ja); // type is the same, direct access
  };

  T& operator[](const I i) {
    // assert((i>=0)&&(i<size());
    return ((T*)data())[i];
  };

  const T& operator[](const I i) const {
    // assert((i>=0)&&(i<size());
    return ((T*)data())[i];
  };

  jarray_of_type(jengine *je_) {
    T dummy; I shape[]={}; allocate(je_, jtype(dummy), 0, shape);
  };

  jarray_of_type(jengine *je_, const I l0) {
    T dummy; I shape[]={l0}; allocate(je_, jtype(dummy), 1, shape);
  };
  T& operator()(const I i0) {
    assert(rank()==1); return ((T*)data())[i0];
  };
  const T& operator()(const I i0) const {
    assert(rank()==1); return ((T*)data())[i0];
  };

  jarray_of_type(jengine *je_, const I l0, const I l1) {
    T dummy; I shape[]={l0,l1}; allocate(je_,jtype(dummy), 2, shape);
  };

  T& operator()(const I i0,const I i1) {
    assert(rank()==2); return ((T*)data())[i0*extent(1)+i1];
  };
  const T& operator()(const I i0,const I i1) const {
    assert(rank()==2); return ((T*)data())[i0*extent(1)+i1];
  };
  
  jarray_of_type(jengine *je_, const I l0, const I l1, const I l2) {
    T dummy; I shape[]={l0,l1,l2}; allocate(je_, jtype(dummy), 3, shape);
  };

  T& operator()(const I i0,const I i1,const I i2) {
    assert(rank()==3); return ((T*)data())[(i0*extent(1)+i1)*extent(2)+i2];
  };

  const T& operator()(const I i0,const I i1,const I i2) const {
    assert(rank()==3); return ((T*)data())[(i0*extent(1)+i1)*extent(2)+i2];
  };

  jarray_of_type(jengine *je_, const I l0, const I l1, const I l2, 
                 const I l3) {
    T dummy; I shape[]={l0,l1,l2,l3}; allocate(je_,jtype(dummy), 4, shape);
  };

  T& operator()(const I i0,const I i1,const I i2,const I i3) {
    assert(rank()==4);
    return ((T*)data())[((i0*extent(1)+i1)*extent(2)+i2)*extent(3)+i3];
  };

  const T& operator()(const I i0,const I i1,const I i2,const I i3) const {
    assert(rank()==4);
    return ((T*)data())[((i0*extent(1)+i1)*extent(2)+i2)*extent(3)+i3];
  };

  jarray_of_type(jengine *je_, const I l0, const I l1, const I l2, 
                 const I l3, const I l4) {
    T dummy; I shape[]={l0,l1,l2,l3,l4}; allocate(je_,jtype(dummy), 5, shape);
  };

  T& operator()(const I i0,const I i1,const I i2,const I i3,const I i4) {
    assert(rank()==4);
    return ((T*)data())[(((i0*extent(1)+i1)*extent(2)+i2)*extent(3)+i3)*extent(4)+i4];
  };

  const T& operator()(const I i0,const I i1,const I i2,const I i3,const I i4) const {
    assert(rank()==4);
    return ((T*)data())[(((i0*extent(1)+i1)*extent(2)+i2)*extent(3)+i3)*extent(4)+i4];
  };
  

  jarray_of_type(jengine *je_, const I rank, const I *shape) {
    T dummy; allocate(je_, jtype(dummy), rank, shape);
  };

  jarray_of_type(jengine *je_, const std::vector<I> &shape) {
    T dummy; allocate(je_, jtype(dummy), shape.size(), &shape[0]);
  };

  T& operator()(const std::vector<I> &subscripts) {
    assert(rank()==subscripts.size());
    I pos=0;
    for(int i=0;i<subscripts.size();i++) pos=pos*extent(i)+subscripts[i];
    return ((T*)data())[pos];
  };
  const T& operator()(const std::vector<I> &subscripts) const {
    assert(rank()==subscripts.size());
    I pos=0;
    for(int i=0;i<subscripts.size();i++) pos=pos*extent(i)+subscripts[i];
    return ((T*)data())[pos];
  };
  T& operator()(const I *subscripts) {
    I pos=0;
    for(int i=0;i<rank();i++) pos=pos*extent(i)+subscripts[i];
    return ((T*)data())[pos];
  };
  const T& operator()(const I *subscripts) const {
    I pos=0;
    for(int i=0;i<rank();i++) pos=pos*extent(i)+subscripts[i];
    return ((T*)data())[pos];
  };
  
};
#endif