include/ewalena/lac/vector.h

Go to the documentation of this file.

// -------------------------------------------------------------------
// @author Toby D. Young
// @version $Id: vector.h 1002 2012-12-04 15:01:40Z 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 <cmath>
#include <cstring>
#include <iostream>

#ifndef __ewalena_vector_h
#define __ewalena_vector_h

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

#include <ewalena/lac/matrix.h>
#include <ewalena/lac/vector_basis.h>


namespace ewalena
{
  
  template <typename ValueType = double>
    class Vector
    {
    public:
    
    Vector ();
    
    ~Vector ();
    
    explicit Vector (const unsigned int m,
                     const bool         zero = true);
    
    Vector (const Vector<ValueType> &v);
    
    Vector (std::initializer_list<ValueType> list);
    
    void reinit ();
    
    unsigned int size () const;
    
    void reinit (const unsigned int m,
                 const bool         zero = true);
    
    ValueType l1_norm ();
    
    ValueType l2_norm ();
    
    ValueType lp_norm (unsigned int p);
    
    void l2_normalize ();
    
    void lp_normalize (const unsigned int p);
    
    ValueType& operator () (const unsigned int i);
    
    const ValueType& operator () (const unsigned int i) const;
    
    void operator = (const Vector<ValueType> &v);
    
    void operator += (const Vector<ValueType> &v);
    
    void operator -= (const Vector<ValueType> &v);
    
    void operator *= (const ValueType &scalar);
    
    void operator /= (const ValueType &scalar);
    
    bool operator == (const Vector<ValueType> &v) const;
    
    friend std::ostream& operator << (std::ostream& output, 
                                      const Vector<ValueType> &v)
    {
      for (unsigned int i=0; i<v.__n_rows; ++i) 

        /* Try to pretty print */
        (v.data[i]<(ValueType) 0)
          ?
          output << v.data[i] << " "
          :
          output << " " 
                 << v.data[i] << " "; 
      
      return output; 
    }
    
    
    unsigned int n_rows () const;
    
    void diag (const Matrix<ValueType> &M); 
    
    void sadd (const ValueType          a,
               const Vector<ValueType> &v); 
    
    void sadd (const ValueType          a,
               const Vector<ValueType> &v,
               const ValueType          b,
               const Vector<ValueType> &w); 
    
    protected:
    
    inline
    const 
    ValueType* operator* () const
    {
      return (*this).data;
    }
    
    inline
    ValueType* operator* () 
    {
      return (*this).data;
    }
    
    private:
    
    unsigned int __n_rows;
    
    ValueType *data;    
    
    
    }; /* Vector */

  /*-------------- Inline and Other Functions -----------------------*/

  template <typename ValueType>
    inline 
    const ValueType& 
    Vector<ValueType>::operator () (const unsigned int i) const
    {
      assert (i < __n_rows);
      return data[i];
    }
  
  template <typename ValueType>
    inline 
    ValueType& 
    Vector<ValueType>::operator () (const unsigned int i) 
    {
      assert (i < __n_rows);
      return data[i];
    }

  template <typename ValueType>
    inline 
    void
    Vector<ValueType>::operator += (const Vector<ValueType> &v) 
    {
      assert (v.__n_rows == this->__n_rows);
      for (unsigned int i=0; i<__n_rows; ++i)
        data[i] += v.data[i];
    }

  template <typename ValueType>
    inline 
    void
    Vector<ValueType>::operator = (const Vector<ValueType> &v) 
    {
      if (this->__n_rows != v.__n_rows)
        this->reinit (v.__n_rows);

      std::memcpy (this->data, v.data, sizeof (ValueType)*__n_rows);      
    }
  
  template <typename ValueType>
    inline 
    void
    Vector<ValueType>::operator -= (const Vector<ValueType> &v) 
    {
      assert (v.__n_rows == __n_rows);
      for (unsigned int i=0; i<__n_rows; ++i)
        data[i] -= v.data[i];
    }
  
  template <typename ValueType>
    inline 
    void
    Vector<ValueType>::operator *= (const ValueType &scalar) 
    {
      for (unsigned int i=0; i<__n_rows; ++i)
        data[i] *= scalar;
    }

  template <typename ValueType>
    inline 
    void
    Vector<ValueType>::operator /= (const ValueType &scalar) 
    {
      for (unsigned int i=0; i<__n_rows; ++i)
        data[i] /= scalar;
    }

  template <typename ValueType>
    inline 
    bool
    Vector<ValueType>::operator == (const Vector<ValueType> &v) const
    {
      assert (v.__n_rows == this->__n_rows);

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

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

  template <typename ValueType>
    ValueType
    Vector<ValueType>::l1_norm () 
    {
      ValueType l1_norm = (ValueType) 0;

      for (unsigned int i=0; i<__n_rows; ++i)    
        l1_norm += std::fabs (data[i]);
      
      return l1_norm;
    }

  template <typename ValueType>
    ValueType
    Vector<ValueType>::l2_norm () 
    {
      ValueType l2_norm = (ValueType) 0;

      for (unsigned int i=0; i<__n_rows; ++i)    
        l2_norm += data[i] * data[i];

      return std::sqrt (l2_norm);
    }
  
  template <typename ValueType>
    ValueType
    Vector<ValueType>::lp_norm (const unsigned int p) 
    {
      assert (p>0);

      ValueType lp_norm = (ValueType) 0;

      for (unsigned int i=0; i<__n_rows; ++i)    
        lp_norm += std::pow (data[i], static_cast<ValueType> (p));
      
      return std::pow (lp_norm, (ValueType) 1./(ValueType) p); 
    }


  template <typename ValueType>
    inline
    void
    Vector<ValueType>::l2_normalize () 
    {
      ValueType l2_norm = this->l2_norm ();
      assert (l2_norm != (ValueType) 0);

      for (unsigned int i=0; i<__n_rows; ++i)    
        data[i] /= l2_norm;
    }

  template <typename ValueType>
    inline
    void
    Vector<ValueType>::lp_normalize (const unsigned int p) 
    {
      ValueType lp_norm = this->lp_norm (p);

      for (unsigned int i=0; i<__n_rows; ++i)    
        data[i] /= lp_norm;
    }

  template <typename ValueType>
    inline
    void
    Vector<ValueType>::diag (const Matrix<ValueType> &M) 
    {
      assert (M.n_rows () == M.n_cols ());
      assert (__n_rows    == M.n_rows ());

      if (__n_rows == 0) return;
      
      for (unsigned int i=0; i<__n_rows; ++i)
        data[i] = M(i, i);
    }

  template <typename ValueType>
    inline
    void
    Vector<ValueType>::sadd (const ValueType          a,
                             const Vector<ValueType> &v) 
    {
      assert (__n_rows   != 0);
      assert (v.__n_rows == __n_rows);

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

  template <typename ValueType>
    inline
    void
    Vector<ValueType>::sadd (const ValueType          a,
                             const Vector<ValueType> &v,
                             const ValueType          b,
                             const Vector<ValueType> &w) 
    {
      assert (__n_rows   != 0);
      assert (v.__n_rows == __n_rows);

      for (unsigned int i=0; i<__n_rows; ++i)
        data[i] = a*v(i) + b*w(i);
    }

} /* namespace ewalena */
  
#endif /* __ewalena_vector_h */