예제 #1
0
  void row_normalize_system(boost::numeric::ublas::compressed_matrix<NumericT> & A, 
                            boost::numeric::ublas::vector<NumericT>            & b)
  {
      typedef typename boost::numeric::ublas::compressed_matrix<NumericT>::iterator1    Iterator1;
      typedef typename boost::numeric::ublas::compressed_matrix<NumericT>::iterator2    Iterator2;

      //preprocessing: scale rows such that ||a_i|| = 1
      for (Iterator1 iter1  = A.begin1();
          iter1 != A.end1();
        ++iter1)
      {
        double row_norm = 0.0;
        for (Iterator2 iter2  = iter1.begin();
          iter2 != iter1.end();
        ++iter2)
        {
          row_norm += *iter2 * *iter2;
        }

        row_norm = sqrt(row_norm);

        if (A(iter1.index1(), iter1.index1()) < 0.0)
          row_norm *= -1.0;

        for (Iterator2 iter2  = iter1.begin();
             iter2 != iter1.end();
           ++iter2)
        {
          *iter2 /= row_norm;
        }
        b(iter1.index1()) /= row_norm;
      }
  }
예제 #2
0
matrix_map<T, ptrdiff_t>
map(const boost::numeric::ublas::compressed_matrix<T, boost::numeric::ublas::row_major> &A) {
    return matrix_map<T, ptrdiff_t>(
            A.size1(),
            A.size2(),
            // amgcl expects signed type for row and col data. This should work
            // for decently sized matrices:
            reinterpret_cast<const ptrdiff_t*>(A.index1_data().begin()),
            reinterpret_cast<const ptrdiff_t*>(A.index2_data().begin()),
            A.value_data().begin()
            );
}
예제 #3
0
파일: io.hpp 프로젝트: bollig/viennacl
bool readMatrixFromFile(const std::string & filename, boost::numeric::ublas::compressed_matrix<TYPE> & matrix)
{
  std::cout << "Reading ublas matrix" << std::endl;
  
  std::ifstream file(filename.c_str());

  if (!file) return false;

  std::string id;
  file >> id;
  if (id != "Matrix") return false;

  unsigned int num_rows, num_columns;
  file >> num_rows >> num_columns;
  if (num_rows != num_columns) return false;
  
  matrix.resize(num_rows, num_rows, false);

  for (unsigned int row = 0; row < num_rows; ++row)
  {
    int num_entries;
    file >> num_entries;
    for (int j = 0; j < num_entries; ++j)
    {
      unsigned int column;
      TYPE element;
      file >> column >> element;

      //matrix.insert_element(row, column, element);
      matrix(row, column) = element;
    }
  }

  return true;
}
예제 #4
0
void axpy(
        const boost::numeric::ublas::compressed_matrix<real, boost::numeric::ublas::row_major> &A,
        const boost::numeric::ublas::vector<real> &x,
        boost::numeric::ublas::vector<real> &y
        )
{
    const ptrdiff_t n = A.size1();

    const size_t *Arow = A.index1_data().begin();
    const size_t *Acol = A.index2_data().begin();
    const real   *Aval = A.value_data().begin();

#pragma omp parallel for schedule(dynamic, 1024)
    for(ptrdiff_t i = 0; i < n; ++i) {
        real buf = 0;
        for(size_t j = Arow[i], e = Arow[i + 1]; j < e; ++j)
            buf += Aval[j] * x[Acol[j]];
        y[i] = buf;
    }
}
예제 #5
0
파일: ublas.hpp 프로젝트: tkoziara/parmec
std::tuple<
    size_t,
    boost::iterator_range<const size_t*>,
    boost::iterator_range<const size_t*>,
    boost::iterator_range<const T*>
    >
map(const boost::numeric::ublas::compressed_matrix<T, boost::numeric::ublas::row_major> &A) {
    return std::make_tuple(
            A.size1(),
            boost::make_iterator_range(
                A.index1_data().begin(), A.index1_data().end()
                ),
            boost::make_iterator_range(
                A.index2_data().begin(), A.index2_data().end()
                ),
            boost::make_iterator_range(
                A.value_data().begin(), A.value_data().end()
                )
            );
}
예제 #6
0
 void resize(boost::numeric::ublas::compressed_matrix<ScalarType> & matrix,
             size_t rows,
             size_t cols)
 {
   matrix.resize(rows, cols, false); //Note: omitting third parameter leads to compile time error (not implemented in ublas <= 1.42) 
 }