converters.h

Go to the documentation of this file.

// include guard
#ifndef AFF_CONVERTERS_H_VERSION

#define AFF_CONVERTERS_H_VERSION \
  "AFF_CONVERTERS_H   V1.0   "

#include<aff/array.h>
#include<aff/series.h>
#include<aff/lib/error.h>

namespace aff {

  template<class T>
    aff::Series<T> series_from_array(const aff::Array<T>& array)
    {
      typedef aff::Series<T> Tseries;
      typedef aff::Array<T> Tarray;
      typename Tarray::Tshape shape(array.shape());
      AFF_assert(aff::util::is_dense_1D_array(shape),
                 "ERROR: array is not suitable to be converted to series");
      typename Tseries::Trepresentation representation=array.representation();
      typename Tseries::Tshape seriesshape(shape.first(0), 
                                           shape.last(0),
                                           shape.first_offset());
      Tseries retval(seriesshape, representation);
      return retval;
    } // aff::Series<T> series_from_array(const aff::Array<T>& array)

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

  template<class T>
    aff::ConstSeries<T> series_from_array(const aff::ConstArray<T>& array)
    {
      typedef aff::ConstSeries<T> Tseries;
      typedef aff::ConstArray<T> Tarray;
      typename Tarray::Tshape shape(array.shape());
      AFF_assert(aff::util::is_dense_1D_array(shape),
                 "ERROR: array is not suitable to be converted to series");
      typename Tseries::Trepresentation representation=array.representation();
      typename Tseries::Tshape seriesshape(shape.first(0), 
                                           shape.last(0),
                                           shape.first_offset());
      Tseries retval(seriesshape, representation);
      return retval;
    } // aff::ConstSeries<T> series_from_array(const aff::ConstArray<T>& array)

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

  template<class T>
    aff::Array<T> array_from_series(const aff::Series<T>& array)
    {
      AFF_abort("not yet implemented");
    } // aff::Series<T> series_from_array(const aff::Array<T>& array)

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

  template<class T>
    aff::ConstArray<T> array_from_series(const aff::ConstSeries<T>& array)
    {
      AFF_abort("not yet implemented");
    } // aff::Series<T> series_from_array(const aff::Array<T>& array)

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

  template<class T>
    aff::Series<T> series_from_raw_memory(T* pointer,
                                          const unsigned int size)
    {
      typedef aff::Series<T> Tseries;
      typename Tseries::Tshape shape(0, size-1, 0);
      typename Tseries::Trepresentation representation(pointer, size);
      Tseries retval(shape, representation);
      return(retval);
    } // aff::Series<T> series_from_raw_memory

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

  template<class T>
    class CSeries {
      public:
        typedef aff::Series<T> Tseries;
        typedef typename Tseries::Trepresentation Trepresentation;
        typedef typename Tseries::Tshape Tshape;
        typedef typename Tseries::Tvalue Tvalue;
        typedef typename Tseries::Tpointer Tpointer;
        typedef typename Tseries::Treference Treference;
        typedef typename Tseries::Tconst_value Tconst_value;
        typedef typename Tseries::Tconst_pointer Tconst_pointer;
        typedef typename Tseries::Tconst_reference Tconst_reference;
        typedef CSeries<T> Tcontainer;

        /*-----------------------------------------------------------------*/
        
        CSeries(const Tseries& series)
          : Mrepresentation(series.representation())
        {
          Tshape shape=series.shape();
          Moffset=shape.offset(shape.first());
          Msize=shape.size();
        }

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

        const Tsize& size() const
        { return (Msize); }

        /*-----------------------------------------------------------------*/
        
        Tpointer pointer() const 
        { return(&Mrepresentation[Moffset]); }
        template<class TT>
          TT* castedpointer() const
          { return(SizeCheckedCast<Tvalue,TT>::cast(this->pointer())); }

      private:
        Trepresentation Mrepresentation;
        aff::Tsize Msize;
        aff::Tsize Moffset;
    }; // class CSeries

} // namespace aff

#endif // AFF_CONVERTERS_H_VERSION (includeguard)

/* ----- END OF  converters.h ----- */