vecdouble.cpp

Go to the documentation of this file.

#include "vecdouble.h"
#include "globals.h"
#include <lac/sparse_matrix.h>
#include <lac/sparse_matrix.templates.h>
#include "exception.h"


VecDouble::~VecDouble() 
{
  if (!m_owner)
  {
    val=0;
    max_vec_size = vec_size = 0;
  }
}

 VecDouble::VecDouble(const VecDouble& v) 
   :Vector<double>(v)
 {
   m_owner=true;
 }

 VecDouble::VecDouble(const std::vector<double> &p) 
{
  m_owner=true;
  reinit(p.size());
  for (unsigned i=0;i<p.size();i++)
  {
    operator()(i)=p[i];
  }
}



VecDouble::VecDouble(const Point<3> &p)
{
  m_owner=true;
  Point<3> &paux = const_cast<Point<3>& >(p);
  setRef(&(paux[0]),3);
}

VecDouble::VecDouble(const Point<2> &p)
{
  m_owner=true;
  Point<2> &paux = const_cast<Point<2>& >(p);
  setRef(&(paux[0]),2);
}

VecDouble::VecDouble(const Point<1> &p)
{
  m_owner=true;
  Point<1> &paux = const_cast<Point<1>& >(p);
  setRef(&(paux[0]),1);
}



  

 VecDouble::VecDouble(unsigned n) 
   :Vector<double>(n)
 {
   m_owner=true;
}

 

void VecDouble::reinit(const unsigned int N,const bool fast) 
{
  if (!m_owner)
  {
    throw new Exception("VecDouble::reinit Attemp to reinit a vector that does not own its memory\n");
  }
  Vector<double>::reinit(N,fast);
}


void VecDouble::reinit(const VecDouble &V,const bool fast) 
{
  reinit(V.size(),fast);
} 

void VecDouble::swap(VecDouble &v) 
{
  Vector<double>::swap(v);
  std::swap(m_owner,v.m_owner);
}


VecDouble& VecDouble::operator=(const VecDouble &v) 
{
  /*
    This method is valid only if the vector owns its memory
    or in the case that both vectors have equal size
  */
  assert(m_owner || (v.size() == size()) );
  Vector< double >::operator=(v);  
  return *this;
}

VecDouble& VecDouble::operator=(const BlockVector<double> &v) 
{
  /*
    This method is valid only if the vector owns its memory
    or in the case that both vectors have equal size
  */
  assert(m_owner || (v.size() == size()) );
  Vector<double>::operator=(v);
  return *this;
}


VecDouble& VecDouble::operator=(const Vector<double> &v) 
{
  assert(m_owner || (v.size() == size()) );
  Vector<double>::operator=(v);
  return *this;
}


void VecDouble::setRef(double *p,unsigned size) 
{
  if (m_owner)
  {
    reinit(0);
  }
  m_owner=false;
  val=p;
  max_vec_size=vec_size=size;
}







void VecDouble::setRef(Vector<double> &v) 
{
  setRef(&(v(0)),v.size());
}



template void SparseMatrix<double>::vmult<VecDouble,VecDouble>(VecDouble &dst,const VecDouble &src) const;


void VecDouble::operator=(double dd) 
{
  if (vec_size!=0)
    std::fill (begin(), end(), dd);
}


 VecDouble::VecDouble() 
{
  m_owner=true;
}



std::ostream& operator<< (std::ostream & out,const VecDouble &v)
{
  for (unsigned i=0;i<v.size();i++)
  {
    out <<  v(i) << " ";
  }
  return out;
}


void VecDouble::getMinMaxValues(double *min,double *max)  const
{
  assert(size() != 0);
  *min=*max=(*this)(0);
  for (unsigned i=1;i<size();i++)
  {
    if ((*this)(i) < *min)
      *min=operator()(i);
    if ((*this)(i) > *max)
      *max=operator()(i);
  }

}


void VecDouble::term_mult(const VecDouble &v1,const VecDouble &v2) 
{
  assert(v1.size() == v2.size());
  assert(v1.size() == size());
  const double *d1 = v1.val;
  const double *d2 = v2.val;
  double *d3 = &(operator()(0));
  for (unsigned i=0;i<v1.size();i++)
  {
    *d3++=*d1++ * *d2++;
  }
}



void VecDouble::copyRow(unsigned row,Matrix &M) 
{
   assert(M.n() == size());
  for (unsigned i=0;i<size();i++)
  {
    (*this)(i)=M(row,i);
  }
}



void VecDouble::set(double d1,double d2) 
{
  reinit(2);
  operator()(0)=d1;
  operator()(1)=d2;
}

---