strided.h

Go to the documentation of this file.

// include guard
#ifndef AFF_STRIDED_H_VERSION

#define AFF_STRIDED_H_VERSION \
  "AFF_STRIDED_H   V1.8"

#include<aff/lib/types.h>
#include<aff/lib/simplearray.h>

namespace aff {

  namespace util {
    class StridedStepper;
  } // namespace util

  class Strided {
    public:
      static const Tdim Mmax_dimen=4;
        
      typedef SimpleRigidArray<Tsize, Mmax_dimen> TSizeVec;
      typedef SimpleRigidArray<Tsubscript, Mmax_dimen> TIndexVec;
      typedef aff::util::StridedStepper Tstepper;

      /*-----------------------------------------------------------------*/

      Strided(): Mstride(0), Mfirst(0), Mlast(0), Mbase(0) { }
      explicit Strided(const TSizeVec& sizes, const Tsubscript& first=1,
              const Tsubscript& shift=0)
      { setup_from_size(sizes, first, shift); }
      explicit Strided(const TIndexVec& first, const TIndexVec& last, 
              const Tsubscript& shift=0);
      explicit Strided(const Tsize& s0, const Tsize& s1=1, 
              const Tsize& s2=1, const Tsize& s3=1);

      /*-----------------------------------------------------------------*/

      Tsize memory_size() const
      { return (offset(Mlast)-offset(Mfirst)+1); }
      Tsize size() const;
      Tsubscript first_offset() const
      { return offset(Mfirst[0]); }
      Tsubscript last_offset() const
      { return offset(Mlast); }
      const Tsubscript& first(const Tsubscript& i) const
      { return Mfirst[i]; }
      const Tsubscript& last(const Tsubscript& i) const
      { return (Mlast[i]); }
      Tsize size(const Tsubscript& i) const
      { return (static_cast<Tsize>(Mlast[i]-Mfirst[i]+1)); }
      const Tsize& stride(const Tsubscript& i) const
      { return Mstride[i]; }
      const TIndexVec& first() const { return(Mfirst); }
      const TIndexVec& last() const { return(Mlast); }
      const TSizeVec& stride() const { return(Mstride); }

      /*-----------------------------------------------------------------*/

      Tsubscript offset(const TIndexVec& index) const
      { return(inline_innerproduct(index,Mstride)+Mbase[Mmax_dimen-1]); }
      Tsubscript offset(const Tsubscript& i0) const
      { return(i0*Mstride[0]+Mbase[0]); }
      Tsubscript offset(const Tsubscript& i0,
                        const Tsubscript& i1) const
      { return(i0*Mstride[0]+i1*Mstride[1]+Mbase[1]); }
      Tsubscript offset(const Tsubscript& i0,
                        const Tsubscript& i1,
                        const Tsubscript& i2) const
      { return(i0*Mstride[0]+i1*Mstride[1]+i2*Mstride[2]+Mbase[2]); }
      Tsubscript offset(const Tsubscript& i0,
                        const Tsubscript& i1,
                        const Tsubscript& i2,
                        const Tsubscript& i3) const
      { return(i0*Mstride[0]+i1*Mstride[1]+i2*Mstride[2]+
               i3*Mstride[3]+Mbase[3]); }

      /*-----------------------------------------------------------------*/

      Strided& shrink(const TIndexVec& last);
      Strided& shrink(const TIndexVec& first, const TIndexVec& last);
      Strided& shrink(const Tdim& i, 
                      const Tsubscript& first, const Tsubscript& last);
      Strided& shrink(const Tdim& i, 
                      const Tsubscript& last);
      Strided& collapse(const Tdim& i, const Tsubscript& index);
      Strided& shift(const Tdim& i, const Tsubscript& index);
      Strided& shift(const TIndexVec& index);
      Strided& setfirst(const Tdim& i, const Tsubscript& index);
      Strided& setfirst(const TIndexVec& index);

      /*-----------------------------------------------------------------*/

    private:
      void calculate_base(const Tsubscript& offset);
      void setup_from_size(const TSizeVec& size, 
                           const Tsubscript& first=1,
                           const Tsubscript& shift=0);

      TSizeVec Mstride;   //<! strides for each dimension
      TIndexVec Mfirst;   //<! first index of each dimension
      TIndexVec Mlast;    //<! last index of each dimension
      TIndexVec Mbase;    //<! base for each dimension (see index operators)
  };

  /*======================================================================*/
  // helper functions
  
  namespace util {

    bool is_dense_1D_array(const aff::Strided& shape);

  } // namespace util

} // namespace aff

#endif // AFF_STRIDED_H_VERSION (includeguard)

/* ----- END OF strided.h ----- */