/home/rex/ebltrunk/core/libidx/include/idx.h

/***************************************************************************
 *   Copyright (C) 2011 by Yann LeCun and Pierre Sermanet *
 *   yann@cs.nyu.edu, pierre.sermanet@gmail.com *
 *   All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Redistribution under a license not approved by the Open Source
 *       Initiative (http://www.opensource.org) must display the
 *       following acknowledgement in all advertising material:
 *        This product includes software developed at the Courant
 *        Institute of Mathematical Sciences (http://cims.nyu.edu).
 *     * The names of the authors may not be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL ThE AUTHORS BE LIABLE FOR ANY
 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ***************************************************************************/

#ifndef IDX_H
#define IDX_H

#include <stdio.h>
#include "defines.h"
#include "srg.h"
#include "stl.h"
#include "idxspec.h"
#include "idxiter.h"
#include "smart.h"

namespace ebl {


  template <class T> class idx : public smart_pointer {
  public:
    // basic constructors/destructor ///////////////////////////////////////////

    virtual ~idx();
    idx(int n, intg *dims, intg *mods);
    idx(const idx<T>& other);

    // constructors initialized with an array //////////////////////////////////

    idx(const T *mat, intg s0, intg s1);
    idx(const T *mat, intg s0, intg s1, intg s2);

    // specific constructors for each number of dimensions /////////////////////

    idx();
    idx(intg size0);
    idx(intg size0, intg size1);
    idx(intg size0, intg size1, intg size2);
    idx(intg s0, intg s1, intg s2, intg s3, intg s4=-1, intg s5=-1, intg s6=-1,
        intg s7=-1);
    idx(const idxdim &d);

    // constructors from existing srg and offset ///////////////////////////////

    idx(srg<T> *srg, idxspec &s);
    idx(srg<T> *srg, intg o, intg n, intg *dims, intg *mods);
    idx(srg<T> *srg, intg o);
    idx(srg<T> *srg, intg o, intg size0);
    idx(srg<T> *srg, intg o, intg size0, intg size1);
    idx(srg<T> *srg, intg o, intg size0, intg size1, intg size2);
    idx(srg<T> *srg, intg o, intg s0, intg s1, intg s2, intg s3, intg s4=-1,
        intg s5=-1, intg s6=-1, intg s7=-1);
    idx(srg<T> *srg, intg o, const idxdim &d);

    // operators ///////////////////////////////////////////////////////////////

    // TODO: Find out why code such as idx<float> = 1 compiles
    // (even without default operator below).
    // default operator below outputs an error that this is forbidden.
    virtual idx<T>& operator=(T other);
    virtual idx<T>& operator=(const idx<T>& other);
    virtual idx<T> operator[](const intg i);

    // resize methods //////////////////////////////////////////////////////////

    virtual void add_offset(intg n);
    virtual intg setoffset(intg o);
    virtual void resize(intg s0=-1, intg s1=-1, intg s2=-1, intg s3=-1,
                        intg s4=-1, intg s5=-1, intg s6=-1, intg s7=-1);
    virtual void resize(const idxdim &d);
    virtual void resize1(intg dimn, intg size);
    virtual void resize_chunk(intg s_chunk, intg s0=-1, intg s1=-1, intg s2=-1,
                              intg s3=-1, intg s4=-1, intg s5=-1, intg s6=-1,
                              intg s7=-1);

    // idx manipulation methods ////////////////////////////////////////////////

    idx<T> select(int d, intg i);
    idx<T> narrow(int d, intg s, intg o);
    idx<T> transpose(int d1, int d2);
    idx<T> transpose(int *p);
    virtual idx<T> unfold(int d, intg k, intg s);
    // TODO: forbid this function as it conflicts with the forbidden
    // order-change rule? unfold also conflicts with this rule?
    idx<T> view_as_order(int n);
    idx<T> shift_dim(int d, int pos);


    virtual srg<T> *getstorage() { return storage; }
    virtual intg dim(int d) const { return spec.dim[d]; }
    virtual const intg* dims(){ return spec.dim; }
    virtual intg mod(int d) const { return spec.mod[d]; }
    virtual const intg* mods(){ return spec.mod; }
    virtual int order() const { return spec.ndim; }
    virtual intg offset() { return spec.offset; }
    virtual intg nelements() const { return spec.nelements(); }
    virtual intg footprint() const { return spec.footprint(); }
    virtual bool contiguousp() const { return spec.contiguousp(); }

    //  T &operator*() {
    //    if (spec.ndim==0) {
    //      return *(storage->data + spec.offset);
    //    }else { eblerror("idx::operator*: only an idx0 can be dereferenced");}
    //  }

    virtual bool same_dim(const idxdim &d);
    virtual bool same_dim(intg s0, intg s1, intg s2, intg s3, intg s4, intg s5,
                          intg s6, intg s7);
    virtual idxdim& get_idxdim();
    virtual idxdim get_idxdim() const;

    // data access methods /////////////////////////////////////////////////////

    virtual T *idx_ptr();
    virtual const T *idx_ptr() const;
    virtual intg *mod_ptr();
    
    virtual T *ptr();
    virtual T *ptr(intg i0);
    virtual T *ptr(intg i0, intg i1);
    virtual T *ptr(intg i0, intg i1, intg i2);
    virtual T *ptr(intg i0, intg i1, intg i2, intg i3, intg i4=-1, intg i5=-1,
                   intg i6=-1, intg i7=-1);

    virtual T get() const;
    virtual T& get(intg i0) const;
    virtual T get(intg i0, intg i1) const;
    virtual T get(intg i0, intg i1, intg i2) const;
    virtual T get(intg i0, intg i1, intg i2, intg i3, intg i4=-1,
                  intg i5=-1, intg i6=-1, intg i7=-1);
    virtual T gget(intg i0=0, intg i1=0, intg i2=0, intg i3=0, intg i4=0,
                  intg i5=0, intg i6=0, intg i7=0);

    virtual T set(T val);
    virtual T set(T val, intg i0);
    virtual T set(T val, intg i0, intg i1);
    virtual T set(T val, intg i0, intg i1, intg i2);
    virtual T set(T val, intg i0, intg i1, intg i2, intg i3, intg i4=-1,
                  intg i5=-1, intg i6=-1, intg i7=-1);
    virtual T sset(T val, intg i0=0, intg i1=0, intg i2=0, intg i3=0, intg i4=0,
                   intg i5=0, intg i6=0, intg i7=0);

    // print methods ///////////////////////////////////////////////////////////

    //friend std::ostream& operator<<(std::ostream& out, idx<T>& tensor );

    virtual void pretty() const;
    virtual void pretty(std::ostream& out) const;
    virtual void pretty(FILE *) const;

    virtual void print() const;
    virtual std::string str() const;
    virtual void printElems() const;
    virtual void printElems(std::ostream& out, bool newline = true) const;
    virtual void printElems(std::string& out, bool newline = true) const;
    // void printElems( FILE* out );  doesn't work (cf implementation)

    virtual int fdump(std::ostream &f);

    // friends /////////////////////////////////////////////////////////////////
    template <class T2> friend class idxiter;
    template <class T2> friend class idxlooper;
    template <class T2> friend class contiguous_idxiter;
    template <class T2> friend class noncontiguous_idxiter;

    // protected methods ///////////////////////////////////////////////////////
  protected:
    void growstorage();
    void growstorage_chunk(intg s_chunk);
    template <class stream>
      void printElems_impl(int indent, stream&, bool newline = true) const;
    idx(dummyt *dummy);

    // members variables ///////////////////////////////////////////////////////
  public:
    idxspec spec; 
  protected:
    srg<T> *storage; 



    idxdim *pidxdim;
    idxd<intg> idd;
  };

  // midx //////////////////////////////////////////////////////////////////////

  template <typename T>
    class midx : public idx<idx<T>*> {
  public:
    midx(intg size, std::file *fp = NULL, idx<int64> *offsets = NULL);
    midx(intg size0, intg size1,
         std::file *fp = NULL, idx<int64> *offsets = NULL);
    midx(idxdim &d, std::file *fp = NULL, idx<int64> *offsets = NULL);
    midx();
    //    midx(const idx<idx<T>*> &o);
    midx(const midx<T> &o);
    virtual ~midx();

    virtual midx<T>& operator=(const midx<T>& other);

    // resizing ////////////////////////////////////////////////////////////////

    void resize(intg i0);
    void resize(intg i0, intg i1);
    void resize(midx<T> &other);

    // deletions ///////////////////////////////////////////////////////////////

    void remove(intg i0);
    void remove(intg i0, intg i1);
    void clear();

    // accessors ///////////////////////////////////////////////////////////////

    void set(idx<T> &e, intg i0);
    void set(idx<T> &e, intg i0, intg i1);
    idx<T> get(intg i0);
    idx<T> get(intg i0, intg i1);

    midx<T> narrow(int d, intg s, intg o);
    midx<T> select(int d, intg s);
    bool exists(intg pos) const;
    bool exists(intg i0, intg i1) const;
    idxdim get_maxdim();
    virtual bool same_dim(const midx<T> &other) const;
    idx<int64> get_offsets();
    std::file *get_file_pointer();
    virtual intg nelements_all() const;

    virtual idx<T> pack();

    virtual void shift_dim_internal(int d, int pos);

    virtual void pretty() const;
    template <class stream> void pretty(stream &out, bool newline = true) const;
    virtual std::string str() const;

    // internal methods ////////////////////////////////////////////////////////
  protected:
    void lock_all();
    void unlock_all();

    // members /////////////////////////////////////////////////////////////////
  protected:
    std::file *fp; 
    idx<int64> offsets; 
  };

  // stream printing ///////////////////////////////////////////////////////////

  template <class T>
    std::ostream& operator<<(std::ostream& out, const idx<T>& m);
  template <class T>
    std::string& operator<<(std::string& out, idx<T>& m);
  template <class T>
    std::string& operator<<(std::string& out, idx<T>* m);

  template <typename T, class stream>
    stream& operator<<(stream& out, midx<T>& m);

  // debugging /////////////////////////////////////////////////////////////////

#ifdef __DEBUGMEM__

#define INIT_DEBUGMEM()                                                 \
  /* memsize */                                                         \
  template <typename T> ebl::intg ebl::srg<T>::memsize = 0;             \
  template <> EXPORT ebl::intg ebl::srg<double>::memsize = 0;           \
  template <> EXPORT ebl::intg ebl::srg<float>::memsize = 0;            \
  template <> EXPORT ebl::intg ebl::srg<int>::memsize = 0;              \
  template <> EXPORT ebl::intg ebl::srg<long>::memsize = 0;             \
  template <> EXPORT ebl::intg ebl::srg<unsigned long>::memsize = 0;    \
  template <> EXPORT ebl::intg ebl::srg<short>::memsize = 0;            \
  template <> EXPORT ebl::intg ebl::srg<unsigned char>::memsize = 0;    \
  template <> EXPORT ebl::intg ebl::srg<signed char>::memsize = 0;      \
  template <> EXPORT ebl::intg ebl::srg<unsigned short>::memsize = 0;   \
  template <> EXPORT ebl::intg ebl::srg<ebl::idx<float>*>::memsize = 0; \
  template <> EXPORT ebl::intg ebl::srg<ebl::idx<unsigned char>*>::memsize = 0; \
  template <> EXPORT ebl::intg ebl::srg<const char*>::memsize = 0;      \
  template <> EXPORT ebl::intg ebl::srg<void *>::memsize = 0;           \
  template <> EXPORT ebl::intg ebl::srg<bool>::memsize = 0;             \
  template <> EXPORT ebl::intg ebl::srg<uint>::memsize = 0;             \
  /* locks */                                                           \
  EXPORT ebl::intg ebl::smart_pointer::locks = 0;                       \
  EXPORT ebl::intg ebl::smart_pointer::spointers = 0;

  EXPORT void pretty_memory(const char *prefix = "");

#define DEBUGMEM_PRETTY(prefix) {               \
    std::string pf; pf << prefix;               \
    pretty_memory(pf.c_str());                  \
}

#else
#define INIT_DEBUGMEM()
#define DEBUGMEM_PRETTY(prefix)
#endif


} // end namespace ebl

#include "idx.hpp"

#endif /* IDX_H_ */