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

/***************************************************************************
 *   Copyright (C) 2008 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 IDXSPEC_H
#define IDXSPEC_H

#include "defines.h"

#ifndef __NOSTL__
#include <vector>
#include <algorithm>
#include <iterator>
#include <iostream>
#endif

#include <stdio.h>
#include "stl.h"
#include "smart.h"

namespace ebl {

  const int MAXDIMS=8;

  // forward declarations //////////////////////////////////////////////////////

  template <typename T = intg> class idxd;
  typedef idxd<intg> idxdim;
  typedef idxd<float> fidxdim;


  class EXPORT idxspec {
  public:
    virtual ~idxspec();
    const idxspec& operator=(const idxspec& src);
    void copy(const idxspec& src);
    idxspec(const idxspec& src);


    idxspec();
    idxspec(intg o);
    idxspec(intg o, intg size0);
    idxspec(intg o, intg size0, intg size1);
    idxspec(intg o, intg size0, intg size1, intg size2);
    idxspec(intg o, intg s0, intg s1, intg s2, intg s3,
            intg s4=-1, intg s5=-1, intg s6=-1, intg s7=-1);
    idxspec(intg o, int n, intg *ldim, intg *lmod);
    idxspec(intg o, const idxdim &d);

    // access methods //////////////////////////////////////////////////////////

    intg getoffset() const;
    void add_offset(intg n);
    int getndim() const;
    intg footprint() const;
    intg nelements() const;
    bool contiguousp() const;


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


    idxspec select(int d, intg i);
    intg select_into(idxspec *dst, int d, intg n) const;
    intg select_inplace(int d, intg i);

    idxspec narrow(int d, intg s, intg o);
    intg narrow_into(idxspec *dst, int d, intg s, intg o);
    intg narrow_inplace(int d, intg s, intg o);

    idxspec transpose(int d1, int d2);
    idxspec transpose(int *p);
    int transpose_into(idxspec *dst, int d1, int d2);
    int transpose_into(idxspec *dst, int *p);
    int transpose_inplace(int d1, int d2);
    int transpose_inplace(int *p);

    idxspec unfold(int d, intg k, intg s);
    intg unfold_into(idxspec *dst, int d, intg k, intg s);
    intg unfold_inplace(int d, intg k, intg s);


    friend class idxd<>;
    template <class T> friend class idxiter;
    template <class T> friend class idxlooper;
    template <class T> friend class contiguous_idxiter;
    template <class T> friend class noncontiguous_idxiter;
    template <class T> friend class idx;

    friend bool same_dim(idxspec &s1, idxspec &s2);
    friend EXPORT std::ostream& operator<<(std::ostream& out, idxspec& d);
    friend EXPORT std::ostream& operator<<(std::ostream& out, const idxspec& d);
    friend EXPORT std::string& operator<<(std::string& out, idxspec& d);

  private:
    int setndim(int n);

    int setndim(int n, intg *ldim, intg *lmod);

    int ndim;
    intg offset;
    intg *dim;
    intg *mod;

    intg 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);
    intg resize(const idxdim &d);
    intg resize1(intg dimn, intg size);
    /* template<typename SizeIter> */
    /*   intg resize(SizeIter& dimsBegin, SizeIter& dimsEnd); */
    intg setoffset(intg o) { return offset = o; }
    void init_spec(intg o, intg s0, intg s1, intg s2, intg s3,
                   intg s4, intg s5, intg s6, intg s7);
    void init_spec(intg o, intg s0, intg s1, intg s2, intg s3,
                   intg s4, intg s5, intg s6, intg s7, uint n);
  };

  bool same_dim(idxspec &s1, idxspec &s2);

  template <typename T> class idxd : public smart_pointer {
  public:
    // constructors

    idxd();
    idxd(const idxspec &s);
    template <class T2> idxd(const idx<T2> &i);
    template <class T2> idxd(const idxd<T2> &i);
    idxd(const idxd<T> &s);
    idxd(T s0, T s1=-1, T s2=-1, T s3=-1, T s4=-1, T s5=-1, T s6=-1, T s7=-1);
    virtual ~idxd();

    // set dimensions

    void setdim(intg dimn, T size);
    template <class Tidx> void setdims(const idx<Tidx> &i);
    void setdims(const idxd<T> &s);
    void setdims(const idxspec &s);
    void setdims(T n);
    void insert_dim(intg pos, T dim_size);
    T remove_dim(intg pos);
    void setoffset(intg dimn, T offset);
    bool has_offsets() const;
    void set_max(const idxd<T> &other);
    void shift_dim(int d, int pos);

    // get dimensions

    bool empty() const;
    intg order() const;
    T dim(intg dimn) const;
    T maxdim() const;
    T offset(intg dimn) const;
    bool operator==(const idxd<T>& other);
    bool operator!=(const idxd<T>& other);
    intg nelements();

    // operators

    /* //! Assign idxd 'd2' into current idxd (copies offsets if they exist). */
    /* idxd<T>& operator=(const idxd<T> &d2); */
    idxd<T>& operator=(idxd<T> d2);
    template <typename T2> idxd<T>& operator=(const idxd<T2> &d2);
    idxd<T> operator*(const idxd<T> &d2) const;
    template <typename T2> idxd<T> operator*(const idxd<T2> &d2) const;
    template <typename T2> idxd<T> operator*(idxd<T2> &d2);
    template <typename T2> idxd<T> operator*(T2 d);
    template <typename T2> idxd<T> operator+(T2 d);
    idxd<T> operator+(idxd<T> &d2);
    bool operator<=(idxd<T> &d2);
    bool operator>=(idxd<T> &d2);

    // friends

    template <typename T2>
      friend std::string& operator<<(std::string& out, const idxd<T2>& d);
    friend class idxspec;

    // member variables
  protected:
    T           dims[MAXDIMS];  
    intg        ndim;           
    T           *offsets;       
  };

  template <typename T>
    EXPORT std::ostream& operator<<(std::ostream& out, const idxd<T>& d);
  template <typename T>
    EXPORT std::string& operator<<(std::string& out, const idxd<T>& d);

  template <typename T> class midxd : public svector<idxd<T> > {
  public:
    // constructors ////////////////////////////////////////////////////////////

    midxd();
    midxd(uint n);
    midxd(const idxd<T> &s);
    template <typename T2> midxd(const midxd<T2> &s);
    virtual ~midxd();

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

    virtual midxd<T> narrow_copy(uint n, uint offset);
    template <typename T2> void push_back(const idxd<T2> &m);
    virtual void push_back(const midxd<T> &m);
    /* //! Appends all idxd contained in 'm' to this idxd. */
    /* virtual void push_back(midxd<T> &m); */
    virtual midxd<T> merge_all();
    template <typename T2> midxd<T>& operator=(const midxd<T2> &other);

    // member variables ////////////////////////////////////////////////////////
  protected:
  };

  // shortcut types
  typedef midxd<intg> midxdim;
  typedef midxd<float> mfidxdim;

  // printing //////////////////////////////////////////////////////////////////

  template<class T>
    EXPORT std::string& operator<<(std::string &o, const midxd<T> &v);
  template<class T>
    EXPORT std::ostream& operator<<(std::ostream &o, const midxd<T> &v);

} // end namespace ebl

#include "idxspec.hpp"

#endif /* IDXSPEC_H_ */