include/ewalena/lac/vector_basis.h

Go to the documentation of this file.

// -------------------------------------------------------------------
// @author Toby D. Young
// @version $Id: vector_basis.h 987 2012-11-26 15:16:27Z 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 <iostream>

#ifndef __ewalena_vector_basis_h
#define __ewalena_vector_basis_h

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


namespace ewalena
{
  
  template <typename ValueType = double>
    class VectorBasis
    {      
    public:
    
    VectorBasis ();
    
    ~VectorBasis ();
    
    explicit VectorBasis (const unsigned int n_vecs, 
                          const unsigned int m,
                          const bool         zero = true);
    
    VectorBasis (const VectorBasis &V);
    
    unsigned int n_rows () const;
    
    unsigned int size () const;
    
    void reinit (const unsigned int m,
                 const unsigned int n,
                 const bool         fast = false);
    
    void reinit ();
    
    ValueType& operator () (const unsigned int i, 
                            const unsigned int j);
    
    const ValueType& operator () (const unsigned int i, 
                                  const unsigned int j) const;
    
    void make_orthonormal_basis ();
    
    void operator += (const VectorBasis<ValueType> &v);
    
    void operator -= (const VectorBasis<ValueType> &v);
    
    bool operator == (const VectorBasis<ValueType> &v) const;
    
    inline
    const 
    ValueType* operator* () const
    {
      return (*this).data;
    }
    
    inline
    ValueType* operator* () 
    {
      return (*this).data;
    }
    
    private:
    
    unsigned int n_vecs;
    
    unsigned int __n_rows;
    
    ValueType *data;
    
    }; /* VectorBasis */
  
  /*-------------- Inline and Other Functions -----------------------*/
  
  template <typename ValueType>
    inline 
    const ValueType& 
    VectorBasis<ValueType>::operator () (const unsigned int i, 
                                         const unsigned int j) const
    {
      assert (i<__n_rows);
      assert (j<n_vecs);
      
      return data[__n_rows*i+j];
    }
  
  template <typename ValueType>
    inline 
    ValueType& 
    VectorBasis<ValueType>::operator () (const unsigned int i, 
                                         const unsigned int j) 
    {
      assert (i<__n_rows);
      assert (j<n_vecs);
      
      return data[__n_rows*i+j];
    }
  
  template <typename ValueType>
    inline 
    void
    VectorBasis<ValueType>::operator += (const VectorBasis<ValueType> &v) 
    {
      assert (v.__n_rows == __n_rows);
      assert (v.n_vecs == n_vecs);
      
      for (unsigned int i=0; i< __n_rows*n_vecs; ++i)
        data[i] += v.data[i];
    }

  template <typename ValueType>
    inline
    unsigned int
    VectorBasis<ValueType>::n_rows () const
    {
      return __n_rows;
    }
  
  template <typename ValueType>
    inline
    unsigned int
    VectorBasis<ValueType>::size () const
    {
      return n_vecs;
    }

  template <typename ValueType>
    inline 
    void
    VectorBasis<ValueType>::operator -= (const VectorBasis<ValueType> &v) 
    {
      assert (v.__n_rows == __n_rows);
      assert (v.n_vecs == n_vecs);

      for (unsigned int i=0; i< __n_rows*n_vecs; ++i)
        data[i] -= v.data[i];
    }

  template <typename ValueType>
    inline 
    bool
    VectorBasis<ValueType>::operator == (const VectorBasis<ValueType> &V) const
    {
      assert (V.__n_rows == __n_rows);
      assert (V.n_vecs == n_vecs);

      return static_cast<bool> (!std::memcmp (this->data, V.data, sizeof (ValueType)*(__n_rows*n_vecs)));
    }

  template <typename ValueType>
    inline 
    void
    VectorBasis<ValueType>::make_orthonormal_basis ()
    {
      /* An identity vector basis is always a square vector basis. */
      assert (__n_rows==n_vecs);
      reinit ();

      /* If the vector basis is zero size - there is nothing to do. */
      if (__n_rows==0) 
        return;


      /* This is a cyclic counter that runs one past the length of a
         column; ie. where 1 appears cyclicly in an identity vector
         basis. */
      unsigned int j = __n_rows+1;
    
      for (unsigned int i=0; i<__n_rows*n_vecs; ++i, ++j)
        {
          if (j==__n_rows+1) 
            {
              data[i] = 1.;
              j=0;
            }
        }
    }

} /* namespace ewalena */
  
#endif /* __ewalena_vector_basis_h */