include/ewalena/lac/super_matrix.h

Go to the documentation of this file.

// -------------------------------------------------------------------
// @author Toby D. Young
// @version $Id: super_matrix.h 1000 2012-12-04 13:21:14Z oneliefleft $
//
// Copyright 2012 namespace ewalena authors. All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. 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.
//
// THIS SOFTWARE IS PROVIDED BY THE NAMEPSACE EWALENA AUTHORS ``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
// NAMESPACE EWALENA AUTHORS OR CONTRIBUTORS 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.
//
// The views and conclusions contained in the software and
// documentation are those of the authors and should not be
// interpreted as representing official policies, either expressed or
// implied, of the namespace ewalena authors.
// -------------------------------------------------------------------

#include <cassert>
#include <cstring>
#include <stdlib.h>
#include <iostream>

#ifndef __ewalena_super_matrix_h
#define __ewalena_super_matrix_h

#ifdef EWALENA_HAVE_CONFIG_H
#include <ewalena/base/config.h>
#endif

namespace ewalena
{
  
  template <typename ValueType = double>
    class SuperMatrix
    {
      
      
    public:
    
    SuperMatrix ();
    
    ~SuperMatrix ();
    
    explicit SuperMatrix (const unsigned int p, 
                          const unsigned int q,
                          const unsigned int r,
                          const unsigned int s,
                          const bool         zero = true);
    
    
    unsigned int n_rows () const;
    
    unsigned int n_cols () const;
    
    
    void reinit (const unsigned int p,
                 const unsigned int q,
                 const unsigned int r,
                 const unsigned int s,
                 const bool         zero = true);
    
    ValueType& operator () (const unsigned int i, 
                            const unsigned int j,
                            const unsigned int k,
                            const unsigned int l);
    
    const ValueType& operator () (const unsigned int i, 
                                  const unsigned int j,
                                  const unsigned int k,
                                  const unsigned int l) const;
    
    void reinit ();
    
    friend std::ostream& operator << (std::ostream            &output, 
                                      const SuperMatrix<ValueType> &M) 
    { 
      for (unsigned int i=0; i<M.n_rows ()*M.n_cols (); ++i)  
        output << M.data[i] << " ";  
      
      return output;  
    }
    
    protected:
    
    inline
    const 
    ValueType* operator* () const
    {
      return (*this).data;
    }
    
    inline
    ValueType* operator* () 
    {
      return (*this).data;
    }
    
    private:
    
    unsigned int __n_rows;
    
    unsigned int __n_cols;
    
    unsigned int I, J, K, L;
    
    ValueType* data;
    
    }; /* SuperMatrix */
  
  /*-------------- Inline and Other Functions -----------------------*/
  
  template <typename ValueType>
    inline
    unsigned int
    SuperMatrix<ValueType>::n_rows () const
    {
      return this->__n_rows;
    }
  
  template <typename ValueType>
    inline
    unsigned int
    SuperMatrix<ValueType>::n_cols () const
    {
      return this->__n_cols;
    }

  template <typename ValueType>
    inline 
    const ValueType& 
    SuperMatrix<ValueType>::operator () (const unsigned int i, 
                                         const unsigned int j,
                                         const unsigned int k,
                                         const unsigned int l) const
    {
      assert (i<I);
      assert (j<J);
      assert (k<K);
      assert (l<L);

      unsigned int index = __n_cols*I*l + J*k + (__n_cols*i+j);

      return data[index];
    }
  
  template <typename ValueType>
    inline 
    ValueType& 
    SuperMatrix<ValueType>::operator () (const unsigned int i, 
                                         const unsigned int j,
                                         const unsigned int k,
                                         const unsigned int l) 
    {
      assert (i<I);
      assert (j<J);
      assert (k<K);
      assert (l<L);

      unsigned int index = __n_cols*I*l + J*k + (__n_cols*i+j);

      return data[index];
    }

  /*-------------- Template and Other Functions ---------------------*/

} /* namespace ewalena */
  
#endif /* __ewalena_super_matrix_h */