Пример #1
0
    void pretty_print_matrix(std::ostream &ostr, MatrixT const &mat)
    {
        IndexType rows, cols;
        mat.get_shape(rows, cols);
        typename MatrixT::ScalarType zero(mat.get_zero());

        for (IndexType row = 0; row < rows; ++row)
        {
            ostr << ((row == 0) ? "[[" : " [");
            if (cols > 0)
            {
                auto val = mat.get_value_at(row, 0);
                if (val == zero)
                    ostr << " ";
                else
                    ostr << val;
            }

            for (IndexType col = 1; col < cols; ++col)
            {
                auto val = mat.get_value_at(row, col);
                if (val == zero)
                    ostr << ",  ";
                else
                    ostr << ", " << val;
            }
            ostr << ((row == rows - 1) ? "]]\n" : "]\n");
        }
    }
void
test_transpose_readonly(MatrixT view)
{
  typedef typename MatrixT::value_type T;

  // Check that view is initialized
  check_matrix(view, 0);

  length_type const size1 = view.size(1);

  typename MatrixT::const_transpose_type trans = view.transpose();

  test_assert(trans.size(0) == view.size(1));
  test_assert(trans.size(1) == view.size(0));

  for (index_type idx0=0; idx0<trans.size(0); ++idx0)
    for (index_type idx1=0; idx1<trans.size(1); ++idx1)
    {
      T expected = T(idx1 * size1 + idx0 + 0);
      test_assert(equal(trans.get(idx0, idx1), expected));
      test_assert(equal(trans.get(idx0,  idx1),
		   view. get(idx1, idx0)));
      }

  // Check that view is unchanged
  check_matrix(view, 0);
}
Пример #3
0
void LDLDecomposition<T>::getPseudoInverse(MatrixT& Ainv) const
{
  Ainv.resize(LDL.n,LDL.n);
  VectorT temp(LDL.n,Zero),y,x;
  for(int i=0;i<LDL.n;i++) {
    temp(i)=One;
    LBackSub(temp,y);
    for(int j=0;j<y.n;j++) {
      if(!FuzzyZero(LDL(j,j),zeroTolerance))
	y(j) = y(j)/LDL(j,j);
      else
	y(j) = 0.0;
    }
    LTBackSub(y,x);
    //fill in a column
    for(int j=0;j<LDL.n;j++)
      Ainv(j,i)=x(j);
    temp(i)=Zero;
  }

  T tol = Ainv.maxAbsElement()*Epsilon;
  for(int i=0;i<LDL.n;i++)
    for(int j=0;j<i;j++) {
      if(!FuzzyEquals(Ainv(i,j),Ainv(j,i),tol))
	LOG4CXX_INFO(KrisLibrary::logger(),Ainv);
      Assert(FuzzyEquals(Ainv(i,j),Ainv(j,i),tol));
      Ainv(i,j)=Ainv(j,i) = 0.5*(Ainv(i,j)+Ainv(j,i));
    }
}
      void operator()(LinPdeSysT const & pde_system,
                      SegmentT   const & segment,
                      StorageType      & storage,
                      MatrixT          & system_matrix,
                      VectorT          & load_vector)
      {
        typedef viennamath::equation                          equ_type;
        typedef viennamath::expr                              expr_type;
        typedef typename expr_type::interface_type            interface_type;
        typedef typename expr_type::numeric_type              numeric_type;

        typedef typename viennagrid::result_of::cell_tag<SegmentT>::type CellTag;

        std::size_t map_index = viennafvm::create_mapping(pde_system, segment, storage);

        system_matrix.clear();
        system_matrix.resize(map_index, map_index, false);
        load_vector.clear();
        load_vector.resize(map_index);


        for (std::size_t pde_index = 0; pde_index < pde_system.size(); ++pde_index)
        {
#ifdef VIENNAFVM_DEBUG
          std::cout << std::endl;
          std::cout << "//" << std::endl;
          std::cout << "//   Equation " << pde_index << std::endl;
          std::cout << "//" << std::endl;
#endif
          assemble(pde_system, pde_index,
                   segment, storage,
                   system_matrix, load_vector);

        } // for pde_index
      } // functor
Пример #5
0
bool QRDecomposition<T>::set(const MatrixT& A)
{
  QR.copy(A);
  tau.resize(Min(A.m,A.n));

  for (int i=0;i<Min(A.m,A.n);i++) {
    /* Compute the Householder transformation to reduce the j-th
       column of the matrix to a multiple of the j-th unit vector */
    
    VectorT c_full,c;
    QR.getColRef(i,c_full);
    c.setRef(c_full,i);
    T tau_i = HouseholderTransform (c);
    tau(i)=tau_i;
    
    /* Apply the transformation to the remaining columns and
       update the norms */
    
    if (i+1 < A.n) {
      MatrixT m;
      m.setRef(QR,i,i+1);
      HouseholderPreMultiply (tau_i, c, m);
    }
  }
  return true;
}
 inline DCMatrix inv(const MatrixT &mat, double regularizationCoeff = 0.0) {
   BOOST_ASSERT(mat.size1() == mat.size2());
   unsigned int n = mat.size1();
   DCMatrix inv = mat; // copy data, as it will be modified below
   if (regularizationCoeff != 0.0)
     inv += regularizationCoeff * ublas::identity_matrix<double>(n);
   std::vector<int> ipiv(n); // pivot vector, is first filled by trf, then used by tri to inverse matrix
   lapack::getrf(inv,ipiv); // inv and ipiv will both be modified
   lapack::getri(inv,ipiv); // afterwards, "inv" is the inverse
   return inv;
 }
Пример #7
0
void DiagonalMatrixTemplate<T>::postMultiplyInverse(const MatrixT& a,MatrixT& x) const
{
  Assert(this->n == a.n);
  x.resize(a.m,this->n);
  MyT xrow,arow;
  for(int i=0;i<a.m;i++) {
    x.getRowRef(i,xrow);
    a.getRowRef(i,arow);
    xrow.componentDiv(arow,*this);
  }
}
Пример #8
0
void DiagonalMatrixTemplate<T>::postMultiplyTranspose(const MatrixT& a,MatrixT& x) const
{
  Assert(this->n == a.m);
  x.resize(a.n,this->n);
  MyT xrow,acol;
  for(int i=0;i<a.n;i++) {
    x.getRowRef(i,xrow);
    a.getColRef(i,acol);
    xrow.componentMul(acol,*this);
  }
}
Пример #9
0
void DiagonalMatrixTemplate<T>::preMultiplyInverse(const MatrixT& a,MatrixT& x) const
{
  Assert(this->n == a.m);
  x.resize(this->n,a.n);
  ItT v=this->begin();
  MyT xrow,arow;
  for(int i=0;i<this->n;i++,v++) {
    x.getRowRef(i,xrow);
    a.getRowRef(i,arow);
    xrow.div(arow,*v);
  }
}
Пример #10
0
void DiagonalMatrixTemplate<T>::preMultiplyTranspose(const MatrixT& a,MatrixT& x) const
{
  Assert(this->n == a.n);
  x.resize(this->n,a.m);
  ItT v=this->begin();
  MyT xrow,acol;
  for(int i=0;i<this->n;i++,v++) {
    x.getRowRef(i,xrow);
    a.getColRef(i,acol);
    xrow.mul(acol,*v);
  }
}
Пример #11
0
void NRQRDecomposition<T>::getQ(MatrixT& Q) const
{
  int n=c.n;
  Q.resize(n,n);
  VectorT Qi;
  Q.set(0);
  for(int i=0;i<n;i++) {
    Q.getRowRef(i,Qi);
    Qi(i)=1;
    QBackSub(Qi,Qi);
  }
}
Пример #12
0
void backwardSolve(MatrixT const & R, VectorT const & y, VectorT & x)
{
  for (long i2 = static_cast<long>(R.size2())-1; i2 >= 0; i2--)
  {
    vcl_size_t i = static_cast<vcl_size_t>(i2);
    x(i) = y(i);
    for (vcl_size_t j = static_cast<vcl_size_t>(i)+1; j < R.size2(); ++j)
      x(i) -= R(i,j)*x(j);

    x(i) /= R(i,i);
  }
}
Пример #13
0
void CholeskyDecomposition<T>::getInverse(MatrixT& Ainv) const
{
  Ainv.resize(L.n,L.n);
  VectorT temp(L.n,Zero),y,x;
  for(int i=0;i<L.n;i++) {
    Ainv.getColRef(i,x);  //x &= col i of A
    temp(i)=One;
    LBackSub(temp,y);
    LTBackSub(y,x);
    temp(i)=Zero;
  }
}
void
fill_matrix(MatrixT view, int offset=0)
{
  typedef typename MatrixT::value_type T;

  length_type const size1 = view.size(1);

  // Initialize view

  for (index_type idx0=0; idx0<view.size(0); ++idx0)
    for (index_type idx1=0; idx1<view.size(1); ++idx1)
      view.put(idx0, idx1, T(idx0 * size1 + idx1 + offset));
}
 inline DCMatrix invSym(const MatrixT &mat, double regularizationCoeff = 0.0) {
   BOOST_ASSERT(mat.size1() == mat.size2());
   unsigned int n = mat.size1();
   DCMatrix inv = mat; // copy data, as it will be modified below
   if (regularizationCoeff != 0.0)
     inv += regularizationCoeff * ublas::identity_matrix<double>(n);
   std::vector<int> ipiv(n); // pivot vector, is first filled by trf, then used by tri to inverse matrix
   // TODO (9): use "po..." (po=positive definite matrix) instead if "sy..." (symmetric indefinite matrix) to make it faster
   lapack::sytrf('U',inv,ipiv); // inv and ipiv will both be modified
   lapack::sytri('U',inv,ipiv); // afterwards, "inv" is the real inverse, but only the upper elements are valid!!!
   ublas::symmetric_adaptor<DCMatrix, ublas::upper> iSym(inv);
   return iSym; // copies upper matrix to lower
 }
void convolute_3d_out_of_place(MatrixT& _image, MatrixT& _kernel) {

  if (_image.size() != _kernel.size()) {
    std::cerr << "received image and kernel of mismatching size!\n";
    return;
  }

  unsigned M, N, K;
  M = _image.shape()[0];
  N = _image.shape()[1];
  K = _image.shape()[2];

  unsigned fft_size = M * N * (K / 2 + 1);

  // setup fourier space arrays
  fftwf_complex* image_fourier = static_cast<fftwf_complex*>(
      fftwf_malloc(sizeof(fftwf_complex) * fft_size));
  fftwf_complex* kernel_fourier = static_cast<fftwf_complex*>(
      fftwf_malloc(sizeof(fftwf_complex) * fft_size));
  float scale = 1.0 / (M * N * K);

  // define+run forward plans
  fftwf_plan image_fwd_plan = fftwf_plan_dft_r2c_3d(
      M, N, K, _image.data(), image_fourier, FFTW_ESTIMATE);
  fftwf_execute(image_fwd_plan);

  fftwf_plan kernel_fwd_plan = fftwf_plan_dft_r2c_3d(
      M, N, K, _kernel.data(), kernel_fourier, FFTW_ESTIMATE);
  fftwf_execute(kernel_fwd_plan);

  // multiply
  for (unsigned index = 0; index < fft_size; ++index) {
    float real = image_fourier[index][0] * kernel_fourier[index][0] -
                 image_fourier[index][1] * kernel_fourier[index][1];
    float imag = image_fourier[index][0] * kernel_fourier[index][1] +
                 image_fourier[index][1] * kernel_fourier[index][0];
    image_fourier[index][0] = real;
    image_fourier[index][1] = imag;
  }

  fftwf_destroy_plan(kernel_fwd_plan);
  fftwf_destroy_plan(image_fwd_plan);

  fftwf_plan image_rev_plan = fftwf_plan_dft_c2r_3d(
      M, N, K, image_fourier, _image.data(), FFTW_ESTIMATE);
  fftwf_execute(image_rev_plan);

  for (unsigned index = 0; index < _image.num_elements(); ++index) {
    _image.data()[index] *= scale;
  }

  fftwf_destroy_plan(image_rev_plan);
  fftwf_free(image_fourier);
  fftwf_free(kernel_fourier);
}
Пример #17
0
 void MatrixT<ValueType>::transform_point(ValueType out[4], const MatrixT& m, const ValueType in[4])
 {
    out[0] = m.get(0, 0) * in[0] + m.get(0, 1) * in[1] + m.get(0, 2) * in[2] + m.get(0, 3) * in[3];
    out[1] = m.get(1, 0) * in[0] + m.get(1, 1) * in[1] + m.get(1, 2) * in[2] + m.get(1, 3) * in[3];
    out[2] = m.get(2, 0) * in[0] + m.get(2, 1) * in[1] + m.get(2, 2) * in[2] + m.get(2, 3) * in[3];
    out[3] = m.get(3, 0) * in[0] + m.get(3, 1) * in[1] + m.get(3, 2) * in[2] + m.get(3, 3) * in[3];
 }
void
check_matrix(MatrixT view, int offset=0)
{
  typedef typename MatrixT::value_type T;

  length_type const size1 = view.size(1);

  for (index_type idx0=0; idx0<view.size(0); ++idx0)
    for (index_type idx1=0; idx1<view.size(1); ++idx1)
    {
      test_assert(equal(view.get(idx0, idx1),
		   T(idx0 * size1 + idx1 + offset)));
    }
}
Пример #19
0
	/// <summary> Creates a shear matrix. </summary>
	/// <param name="slope"> Strength of the shear. </param>
	/// <param name="principalAxis"> Points are moved along this axis. </param>
	/// <param name="modulatorAxis"> The displacement of points is proportional to this coordinate's value. </param>
	/// <remarks> The formula for displacement along the pricipal axis is 
	///		<paramref name="slope"/>&ast;pos[<paramref name="modulatorAxis"/>]. </remarks>
	static MatrixT Shear(T slope, int principalAxis, int modulatorAxis) {
		assert(principalAxis != modulatorAxis);
		assert(principalAxis < Rows);
		assert(modulatorAxis < Rows);
		MatrixT ret;
		ret.SetIdentity();
		if (Order == eMatrixOrder::FOLLOW_VECTOR) {
			ret(modulatorAxis, principalAxis) = slope;
		}
		else {
			ret(principalAxis, modulatorAxis) = slope;
		}
		return ret;
	}
void print_mismatching_items(MatrixT& _reference, MatrixT& _other) {
  for (long x = 0; x < _reference.shape()[0]; ++x)
    for (long y = 0; y < _reference.shape()[1]; ++y)
      for (long z = 0; z < _reference.shape()[2]; ++z) {
        float reference = _reference[x][y][z];
        float to_compared = _other[x][y][z];
        if (std::fabs(reference - to_compared) > (1e-3 * reference) &&
            (std::fabs(reference) > 1e-4 || std::fabs(to_compared) > 1e-4)) {
          std::cout << "[" << x << "][" << y << "][" << z
                    << "] mismatch, ref: " << reference
                    << " != to_compare: " << to_compared << "\n";
        }
      }
}
Пример #21
0
void CholeskyDecomposition<T>::backSub(const MatrixT& B, MatrixT& X) const
{
  X.resize(B.m,B.n);
  MatrixT temp(B.m,B.n);
  if(!LBackSubstitute(L,B,temp)) FatalError("CholeskyDecomposition: LBackSubstitute failed!");
  if(!LtBackSubstitute(L,temp,X)) FatalError("CholeskyDecomposition: LtBackSubstitute failed!");
}
Пример #22
0
 ichol0_precond(MatrixT const & mat, ichol0_tag const & tag) : tag_(tag), LLT(mat.size1(), mat.size2(), viennacl::context(viennacl::MAIN_MEMORY))
 {
     //initialize preconditioner:
     //std::cout << "Start CPU precond" << std::endl;
     init(mat);
     //std::cout << "End CPU precond" << std::endl;
 }
Пример #23
0
void QRDecomposition<T>::getQ(MatrixT& Q) const
{
  Assert(tau.n == Min(QR.m,QR.n));
  Q.resize(QR.m,QR.m);

  int i;
  Q.setIdentity();
  for (i=Min(QR.m,QR.n);i>0 && i--;) {
    VectorT c,h;
    QR.getColRef(i,c);
    h.setRef(c,i);
    MatrixT m;
    m.setRef(Q,i,i);
    HouseholderPreMultiply(tau(i),h,m);
  }
}
Пример #24
0
 ilut_precond(MatrixT const & mat, ilut_tag const & tag) : tag_(tag), LU_(mat.size1(), mat.size2())
 {
   //initialize preconditioner:
   //std::cout << "Start CPU precond" << std::endl;
   init(mat);
   //std::cout << "End CPU precond" << std::endl;
 }
Пример #25
0
void DiagonalMatrixTemplate<T>::copyDiagonal(const MatrixT& m)
{
	if(!m.isSquare())
	{
		FatalError(MatrixError_ArgIncompatibleDimensions);
	}
	if(BaseT::n == 0)
	{
		resize(m.m);
	}
	else if(BaseT::n != m.m)
	{
		FatalError(MatrixError_DestIncompatibleDimensions);
	}
  m.getDiagCopy(0,*this);
}
Пример #26
0
void SparseMatrixTemplate_RM<T>::get(MatrixT& A) const
{
  A.resize(m,n,Zero);
  for(int i=0;i<m;i++) {
    for(ConstRowIterator it=rows[i].begin();it!=rows[i].end();it++)
      A(i,it->first) = it->second;
  }
}
Пример #27
0
    void row_index_of(MatrixT &mat)
    {
        graphblas::IndexType rows, cols;
        mat.get_shape(rows, cols);

        for (IndexType i = 0; i < rows; ++i)
        {
            for (IndexType j = 0; j < cols; ++j)
            {
                auto mat_ij = mat.get_value_at(i, j);
                if (mat_ij != mat.get_zero())
                {
                    mat.set_value_at(i, j, i);
                }
            }
        }
    }
Пример #28
0
    typename viennacl::result_of::cpu_value_type<typename MatrixT::value_type>::type
    eig(MatrixT const& A, power_iter_tag const & tag)
    {
      typedef typename viennacl::result_of::vector_for_matrix<MatrixT>::type    VectorT;

      VectorT eigenvec(A.size1());
      return eig(A, tag, eigenvec);
    }
Пример #29
0
void LDLDecomposition<T>::getA(MatrixT& A) const
{
  MatrixT L,temp;
  DiagonalMatrixTemplate<T> D;
  getL(L);
  getD(D);
  D.postMultiply(L,temp);
  A.mulTransposeB(temp,L);
}
Пример #30
0
void
banded_lu_decompose(MatrixT & _A)
{
    size_t n = _A.rows();
    for(size_t k = 0; k < n - 1; ++k) {
        _A(k + 1, k)     = _A(k + 1, k) / _A(k, k);
        _A(k + 1, k + 1) -=  _A(k + 1, k) * _A(k, k + 1);
    }
}