dense_vector.h

Go to the documentation of this file.

// The libMesh Finite Element Library.
// Copyright (C) 2002-2014 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner

// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA



#ifndef LIBMESH_DENSE_VECTOR_H
#define LIBMESH_DENSE_VECTOR_H

// Local Includes
#include "libmesh/libmesh_common.h"
#include "libmesh/compare_types.h"
#include "libmesh/dense_vector_base.h"
#include "libmesh/tensor_tools.h"

// C++ includes
#include <vector>

namespace libMesh
{

// Forward Declarations



// ------------------------------------------------------------
// DenseVector class definition
template<typename T>
class DenseVector : public DenseVectorBase<T>
{
public:

  explicit
  DenseVector(const unsigned int n=0);

  template <typename T2>
  DenseVector (const DenseVector<T2>& other_vector);

  template <typename T2>
  DenseVector (const std::vector<T2>& other_vector);

  ~DenseVector() {}

  virtual unsigned int size() const {
    return cast_int<unsigned int>(_val.size());
  }

  virtual bool empty() const { return _val.empty(); }

  virtual void zero();

  const T & operator() (const unsigned int i) const;

  T & operator() (const unsigned int i);

  virtual T el(const unsigned int i) const { return (*this)(i); }

  virtual T & el(const unsigned int i)     { return (*this)(i); }

  template <typename T2>
  DenseVector<T>& operator = (const DenseVector<T2>& other_vector);

  void swap(DenseVector<T>& other_vector);

  void resize (const unsigned int n);

  void scale (const T factor);

  DenseVector<T>& operator*= (const T factor);

  template <typename T2, typename T3>
  typename boostcopy::enable_if_c<
    ScalarTraits<T2>::value, void >::type
  add (const T2 factor,
       const DenseVector<T3>& vec);

  template <typename T2>
  typename CompareTypes<T, T2>::supertype dot (const DenseVector<T2> &vec) const;

  template <typename T2>
  typename CompareTypes<T, T2>::supertype indefinite_dot (const DenseVector<T2> &vec) const;

  template <typename T2>
  bool operator== (const DenseVector<T2> &vec) const;

  template <typename T2>
  bool operator!= (const DenseVector<T2> &vec) const;

  template <typename T2>
  DenseVector<T>& operator+= (const DenseVector<T2> &vec);

  template <typename T2>
  DenseVector<T>& operator-= (const DenseVector<T2> &vec);

  Real min () const;

  Real max () const;

  Real l1_norm () const;

  Real l2_norm () const;

  Real linfty_norm () const;

  void get_principal_subvector (unsigned int sub_n, DenseVector<T>& dest) const;

  std::vector<T>& get_values() { return _val; }

  const std::vector<T>& get_values() const { return _val; }

private:

  std::vector<T> _val;

};



// ------------------------------------------------------------
// DenseVector member functions
template<typename T>
inline
DenseVector<T>::DenseVector(const unsigned int n) :
  _val (n, T(0.))
{
}



template<typename T>
template<typename T2>
inline
DenseVector<T>::DenseVector (const DenseVector<T2>& other_vector) :
  DenseVectorBase<T>()
{
  const std::vector<T2> &other_vals = other_vector.get_values();

  _val.clear();
  _val.reserve(other_vals.size());

  for (unsigned int i=0; i<other_vals.size(); i++)
    _val.push_back(other_vals[i]);
}



template<typename T>
template<typename T2>
inline
DenseVector<T>::DenseVector (const std::vector<T2>& other_vector) :
  _val(other_vector)
{
}





template<typename T>
template<typename T2>
inline
DenseVector<T>& DenseVector<T>::operator = (const DenseVector<T2>& other_vector)
{
  //  _val = other_vector._val;

  const std::vector<T2> &other_vals = other_vector.get_values();

  _val.clear();
  _val.reserve(other_vals.size());

  for (unsigned int i=0; i<other_vals.size(); i++)
    _val.push_back(other_vals[i]);

  return *this;
}



template<typename T>
inline
void DenseVector<T>::swap(DenseVector<T>& other_vector)
{
  _val.swap(other_vector._val);
}



template<typename T>
inline
void DenseVector<T>::resize(const unsigned int n)
{
  _val.resize(n);

  zero();
}



template<typename T>
inline
void DenseVector<T>::zero()
{
  std::fill (_val.begin(),
             _val.end(),
             T(0.));
}



template<typename T>
inline
const T & DenseVector<T>::operator () (const unsigned int i) const
{
  libmesh_assert_less (i, _val.size());

  return _val[i];
}



template<typename T>
inline
T & DenseVector<T>::operator () (const unsigned int i)
{
  libmesh_assert_less (i, _val.size());

  return _val[i];
}



template<typename T>
inline
void DenseVector<T>::scale (const T factor)
{
  for (unsigned int i=0; i<_val.size(); i++)
    _val[i] *= factor;
}



template<typename T>
inline
DenseVector<T>& DenseVector<T>::operator*= (const T factor)
{
  this->scale(factor);
  return *this;
}



template<typename T>
template<typename T2, typename T3>
inline
typename boostcopy::enable_if_c<
  ScalarTraits<T2>::value, void >::type
DenseVector<T>::add (const T2 factor,
                     const DenseVector<T3>& vec)
{
  libmesh_assert_equal_to (this->size(), vec.size());

  for (unsigned int i=0; i<this->size(); i++)
    (*this)(i) += static_cast<T>(factor)*vec(i);
}

template<typename T>
template<typename T2>
inline
typename CompareTypes<T, T2>::supertype DenseVector<T>::dot (const DenseVector<T2>& vec) const
{
  libmesh_assert_equal_to (this->size(), vec.size());

  typename CompareTypes<T, T2>::supertype val = 0.;

  for (unsigned int i=0; i<this->size(); i++)
    val += (*this)(i)*libmesh_conj(vec(i));

  return val;
}

template<typename T>
template<typename T2>
inline
typename CompareTypes<T, T2>::supertype DenseVector<T>::indefinite_dot (const DenseVector<T2>& vec) const
{
  libmesh_assert_equal_to (this->size(), vec.size());

  typename CompareTypes<T, T2>::supertype val = 0.;

  for (unsigned int i=0; i<this->size(); i++)
    val += (*this)(i)*(vec(i));

  return val;
}

template<typename T>
template<typename T2>
inline
bool DenseVector<T>::operator== (const DenseVector<T2>& vec) const
{
  libmesh_assert_equal_to (this->size(), vec.size());

  for (unsigned int i=0; i<this->size(); i++)
    if ((*this)(i) != vec(i))
      return false;

  return true;
}



template<typename T>
template<typename T2>
inline
bool DenseVector<T>::operator!= (const DenseVector<T2>& vec) const
{
  libmesh_assert_equal_to (this->size(), vec.size());

  for (unsigned int i=0; i<this->size(); i++)
    if ((*this)(i) != vec(i))
      return true;

  return false;
}



template<typename T>
template<typename T2>
inline
DenseVector<T>& DenseVector<T>::operator+= (const DenseVector<T2>& vec)
{
  libmesh_assert_equal_to (this->size(), vec.size());

  for (unsigned int i=0; i<this->size(); i++)
    (*this)(i) += vec(i);

  return *this;
}



template<typename T>
template<typename T2>
inline
DenseVector<T>& DenseVector<T>::operator-= (const DenseVector<T2>& vec)
{
  libmesh_assert_equal_to (this->size(), vec.size());

  for (unsigned int i=0; i<this->size(); i++)
    (*this)(i) -= vec(i);

  return *this;
}



template<typename T>
inline
Real DenseVector<T>::min () const
{
  libmesh_assert (this->size());
  Real my_min = libmesh_real((*this)(0));

  for (unsigned int i=1; i!=this->size(); i++)
    {
      Real current = libmesh_real((*this)(i));
      my_min = (my_min < current? my_min : current);
    }
  return my_min;
}



template<typename T>
inline
Real DenseVector<T>::max () const
{
  libmesh_assert (this->size());
  Real my_max = libmesh_real((*this)(0));

  for (unsigned int i=1; i!=this->size(); i++)
    {
      Real current = libmesh_real((*this)(i));
      my_max = (my_max > current? my_max : current);
    }
  return my_max;
}



template<typename T>
inline
Real DenseVector<T>::l1_norm () const
{
  Real my_norm = 0.;
  for (unsigned int i=0; i!=this->size(); i++)
    {
      my_norm += std::abs((*this)(i));
    }
  return my_norm;
}



template<typename T>
inline
Real DenseVector<T>::l2_norm () const
{
  Real my_norm = 0.;
  for (unsigned int i=0; i!=this->size(); i++)
    {
      my_norm += TensorTools::norm_sq((*this)(i));
    }
  return sqrt(my_norm);
}



template<typename T>
inline
Real DenseVector<T>::linfty_norm () const
{
  if (!this->size())
    return 0.;
  Real my_norm = TensorTools::norm_sq((*this)(0));

  for (unsigned int i=1; i!=this->size(); i++)
    {
      Real current = TensorTools::norm_sq((*this)(i));
      my_norm = (my_norm > current? my_norm : current);
    }
  return sqrt(my_norm);
}

template<typename T>
inline
void DenseVector<T>::get_principal_subvector (unsigned int sub_n,
                                              DenseVector<T>& dest) const
{
  libmesh_assert_less_equal ( sub_n, this->size() );

  dest.resize(sub_n);
  for(unsigned int i=0; i<sub_n; i++)
    dest(i) = (*this)(i);
}

} // namespace libMesh

#endif // LIBMESH_DENSE_VECTOR_H