234 lines
6.8 KiB
C++
234 lines
6.8 KiB
C++
/*
|
|
* =====================================================================================
|
|
*
|
|
* Filename: sparse_vector_impl.h
|
|
*
|
|
* Description:
|
|
*
|
|
* Version: 1.0
|
|
* Created: 12/03/2007 07:12:26 PM EST
|
|
* Revision: none
|
|
* Compiler: gcc
|
|
*
|
|
* Author: Nikolaos Vasiloglou (NV), nvasil@ieee.org
|
|
* Company: Georgia Tech Fastlab-ESP Lab
|
|
*
|
|
* =====================================================================================
|
|
*/
|
|
|
|
inline SparseVector::SparseVector(std::vector<index_t> &indices,
|
|
Vector &values,
|
|
index_t dimension) {
|
|
Init(indices, values, dimension);
|
|
}
|
|
|
|
inline SparseVector::SparseVector(std::map<index_t, double> &data,
|
|
index_t dimension) {
|
|
Init(data, dimension);
|
|
}
|
|
|
|
inline SparseVector::SparseVector(index_t estimated_non_zero_elements,
|
|
index_t dimension) {
|
|
Init(estimated_non_zero_elements, dimension);
|
|
}
|
|
|
|
inline SparseVector::SparseVector(Epetra_CrsMatrix *one_dim_matrix,
|
|
index_t dimension) {
|
|
Init(one_dim_matrix, dimension);
|
|
}
|
|
|
|
inline SparseVector::SparseVector(const SparseVector &other) {
|
|
Copy(other);
|
|
}
|
|
inline void SparseVector::Init(index_t dimension) {
|
|
map_ = new Epetra_Map(dimension_, 0, comm_);
|
|
own_ = true;
|
|
}
|
|
|
|
inline void SparseVector::Init(std::vector<index_t> &indices,
|
|
Vector &values,
|
|
index_t dimension) {
|
|
if (unlikely((index_t)indices.size()!=values.length())) {
|
|
FATAL("Indices vector has %i elements while Values vectors has %i\n",
|
|
(index_t)indices.size(), values.length());
|
|
}
|
|
std::vector<index_t>::iterator it = std::max_element(indices.begin(), indices.end());
|
|
dimension_ = *it+1;
|
|
if (dimension>0) {
|
|
if (dimension > dimension_) {
|
|
dimension_= dimension;
|
|
} else {
|
|
FATAL("Error, the requested dimension was %i, while the maximum "
|
|
"index in the data is %i", dimension, dimension_);
|
|
}
|
|
}
|
|
|
|
Init(dimension_);
|
|
vector_ = new Epetra_CrsMatrix((Epetra_DataAccess)0, *map_, (index_t)indices.size());
|
|
my_global_elements_ = map_->MyGlobalElements();
|
|
vector_->InsertGlobalValues(*my_global_elements_,
|
|
values.length(),
|
|
values.ptr(),
|
|
&indices[0]);
|
|
start_ = 0;
|
|
end_ = dimension_-1;
|
|
}
|
|
|
|
void SparseVector::Init(std::vector<index_t> &indices, std::vector<double> &values,
|
|
index_t dimension) {
|
|
|
|
if (unlikely(indices.size()!=values.size())) {
|
|
FATAL("Indices vector has %i elements while Values vectors has %i\n",
|
|
(index_t)indices.size(), (index_t)values.size());
|
|
}
|
|
std::vector<index_t>::iterator it = std::max_element(indices.begin(), indices.end());
|
|
dimension_ = *it+1;
|
|
if (dimension>0) {
|
|
if (dimension > dimension_) {
|
|
dimension_= dimension;
|
|
} else {
|
|
FATAL("Error, the requested dimension was %i, while the maximum "
|
|
"index in the data is %i", dimension, dimension_);
|
|
}
|
|
}
|
|
Init(dimension_);
|
|
vector_ = new Epetra_CrsMatrix((Epetra_DataAccess)0, *map_, indices.size());
|
|
my_global_elements_ = map_->MyGlobalElements();
|
|
vector_->InsertGlobalValues(*my_global_elements_,
|
|
values.size(),
|
|
&values[0],
|
|
&indices[0]);
|
|
start_ = 0;
|
|
end_ = dimension_-1;
|
|
}
|
|
|
|
void SparseVector::Init(index_t *indices, double *values, index_t len, index_t dimension) {
|
|
dimension_ = dimension;
|
|
Init(dimension_);
|
|
vector_ = new Epetra_CrsMatrix((Epetra_DataAccess)0, *map_, len);
|
|
my_global_elements_ = map_->MyGlobalElements();
|
|
vector_->InsertGlobalValues(*my_global_elements_,
|
|
len,
|
|
values,
|
|
indices);
|
|
start_ = 0;
|
|
end_ = dimension_-1;
|
|
|
|
}
|
|
|
|
|
|
inline void SparseVector::Init(std::map<index_t, double> &data, index_t dimension) {
|
|
std::map<index_t, double>::iterator it=max_element(data.begin(), data.end());
|
|
dimension_ = it->first+1;
|
|
if (dimension>0) {
|
|
if (dimension > dimension_) {
|
|
dimension_= dimension;
|
|
} else {
|
|
FATAL("Error, the requested dimension was %i, while the maximum "
|
|
"index in the data is %i", dimension, dimension_);
|
|
}
|
|
}
|
|
Init(dimension_);
|
|
vector_ = new Epetra_CrsMatrix((Epetra_DataAccess)0, *map_, data.size());
|
|
index_t *indices = new index_t[data.size()];
|
|
double *values = new double[data.size()];
|
|
index_t i = 0;
|
|
for(it=data.begin(); it!=data.end(); it++) {
|
|
indices[i] = it->first;
|
|
values[i] = it->second;
|
|
i++;
|
|
}
|
|
my_global_elements_ = map_->MyGlobalElements();
|
|
vector_->InsertGlobalValues(*my_global_elements_,
|
|
data.size(),
|
|
values,
|
|
indices);
|
|
delete []indices;
|
|
delete []values;
|
|
start_ = 0;
|
|
end_ = dimension_-1;
|
|
|
|
}
|
|
|
|
inline void SparseVector::Init(index_t estimated_non_zero_elements, index_t dimension) {
|
|
dimension_ = dimension;
|
|
Init(dimension_);
|
|
vector_ = new Epetra_CrsMatrix((Epetra_DataAccess)0, *map_, estimated_non_zero_elements);
|
|
start_ = 0;
|
|
end_ = dimension_-1;
|
|
}
|
|
|
|
inline void SparseVector::Init(Epetra_CrsMatrix *one_dim_matrix, index_t dimension) {
|
|
vector_ = one_dim_matrix;
|
|
*map_ = one_dim_matrix->RowMap();
|
|
dimension_ = dimension;
|
|
Init(dimension_);
|
|
start_ = 0;
|
|
end_ = dimension_-1;
|
|
}
|
|
|
|
inline void SparseVector::Copy(const SparseVector &other) {
|
|
dimension_ = other.dimension_;
|
|
Init(dimension_);
|
|
vector_ = new Epetra_CrsMatrix(*other.vector_);
|
|
start_=other.start_;
|
|
end_=other.end_;
|
|
}
|
|
inline void SparseVector::Destruct() {
|
|
if (own_ == true) {
|
|
delete vector_;
|
|
}
|
|
if (map_!=NULL) {
|
|
delete map_;
|
|
}
|
|
}
|
|
|
|
inline void SparseVector::MakeSubvector(index_t start_index, index_t len, SparseVector* dest) {
|
|
DEBUG_BOUNDS(start_ + start_index, end_+1);
|
|
DEBUG_BOUNDS(start_ + start_index+len-1, end_+1);
|
|
dest->Init(this->vector_, dimension_);
|
|
dest->set_start(start_index + start_);
|
|
dest->set_end(start_ + start_index + len-1);
|
|
}
|
|
|
|
inline double SparseVector::get(index_t i) {
|
|
DEBUG_BOUNDS(start_+i, end_+1);
|
|
index_t pos = start_+i;
|
|
double *values;
|
|
index_t *indices;
|
|
index_t num_of_elements;
|
|
vector_->ExtractGlobalRowView(*my_global_elements_, num_of_elements, values, indices);
|
|
index_t *p = std::find(indices, indices+num_of_elements, pos);
|
|
if (p!=indices+num_of_elements) {
|
|
return values[p-indices];
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
inline void SparseVector::set(index_t i, double value) {
|
|
DEBUG_BOUNDS(start_+i, end_+1);
|
|
index_t pos = start_+i;
|
|
if (get(i)!=0) {
|
|
vector_->ReplaceGlobalValues(*my_global_elements_, 1, &value, &pos);
|
|
} else {
|
|
vector_->InsertGlobalValues(*my_global_elements_, 1, &value, &pos);
|
|
}
|
|
}
|
|
|
|
inline void SparseVector::Lock() {
|
|
if (unlikely(vector_==NULL)) {
|
|
FATAL("Attempted to Lock but you haven't initialized the Epetra_CrsMatrix pointer\n");
|
|
}
|
|
vector_->FillComplete();
|
|
}
|
|
|
|
inline void SparseVector::set_start(index_t ind) {
|
|
start_ = ind;
|
|
}
|
|
|
|
inline void SparseVector::set_end(index_t ind) {
|
|
end_ = ind;
|
|
}
|
|
|