Amesos2 - Direct Sparse Solver Interfaces  Version of the Day
Amesos2_MatrixAdapter_def.hpp
1 // @HEADER
2 //
3 // ***********************************************************************
4 //
5 // Amesos2: Templated Direct Sparse Solver Package
6 // Copyright 2011 Sandia Corporation
7 //
8 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
9 // the U.S. Government retains certain rights in this software.
10 //
11 // Redistribution and use in source and binary forms, with or without
12 // modification, are permitted provided that the following conditions are
13 // met:
14 //
15 // 1. Redistributions of source code must retain the above copyright
16 // notice, this list of conditions and the following disclaimer.
17 //
18 // 2. Redistributions in binary form must reproduce the above copyright
19 // notice, this list of conditions and the following disclaimer in the
20 // documentation and/or other materials provided with the distribution.
21 //
22 // 3. Neither the name of the Corporation nor the names of the
23 // contributors may be used to endorse or promote products derived from
24 // this software without specific prior written permission.
25 //
26 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 //
38 // Questions? Contact Michael A. Heroux (maherou@sandia.gov)
39 //
40 // ***********************************************************************
41 //
42 // @HEADER
43 
44 
45 #ifndef AMESOS2_MATRIXADAPTER_DEF_HPP
46 #define AMESOS2_MATRIXADAPTER_DEF_HPP
47 #include <Tpetra_Util.hpp>
48 #include "Amesos2_MatrixAdapter_decl.hpp"
49 #include "Amesos2_ConcreteMatrixAdapter_def.hpp"
50 //#include "Amesos2_ConcreteMatrixAdapter.hpp"
51 
52 
53 namespace Amesos2 {
54 
55 
56  template < class Matrix >
57  MatrixAdapter<Matrix>::MatrixAdapter(const Teuchos::RCP<Matrix> m)
58  : mat_(m)
59  {
60  comm_ = static_cast<const adapter_t*>(this)->getComm_impl();
61  col_map_ = static_cast<const adapter_t*>(this)->getColMap_impl();
62  row_map_ = static_cast<const adapter_t*>(this)->getRowMap_impl();
63  }
64 
65  template < class Matrix >
66  void
67  MatrixAdapter<Matrix>::getCrs(const Teuchos::ArrayView<scalar_t> nzval,
68  const Teuchos::ArrayView<global_ordinal_t> colind,
69  const Teuchos::ArrayView<typename MatrixAdapter<Matrix>::global_size_t> rowptr,
70  typename MatrixAdapter<Matrix>::global_size_t& nnz,
71  const Teuchos::Ptr<const Tpetra::Map<local_ordinal_t, global_ordinal_t, node_t> > rowmap,
72  EStorage_Ordering ordering) const
73  {
74  help_getCrs(nzval, colind, rowptr,
75  nnz, rowmap, ordering,
76  typename adapter_t::get_crs_spec());
77  }
78 
79  template < class Matrix >
80  void
81  MatrixAdapter<Matrix>::getCrs(const Teuchos::ArrayView<scalar_t> nzval,
82  const Teuchos::ArrayView<global_ordinal_t> colind,
83  const Teuchos::ArrayView<typename MatrixAdapter<Matrix>::global_size_t> rowptr,
84  typename MatrixAdapter<Matrix>::global_size_t& nnz,
85  EDistribution distribution,
86  EStorage_Ordering ordering) const
87  {
88  const Teuchos::RCP<const Tpetra::Map<local_ordinal_t,global_ordinal_t,node_t> > rowmap
89  = Util::getDistributionMap<local_ordinal_t,global_ordinal_t,global_size_t,node_t>(distribution,
90  this->getGlobalNumRows(),
91  this->getComm());
92  this->getCrs(nzval, colind, rowptr, nnz, Teuchos::ptrInArg(*rowmap), ordering);
93  }
94 
95  template < class Matrix >
96  void
97  MatrixAdapter<Matrix>::getCcs(const Teuchos::ArrayView<scalar_t> nzval,
98  const Teuchos::ArrayView<global_ordinal_t> rowind,
99  const Teuchos::ArrayView<typename MatrixAdapter<Matrix>::global_size_t> colptr,
100  typename MatrixAdapter<Matrix>::global_size_t& nnz,
101  const Teuchos::Ptr<const Tpetra::Map<local_ordinal_t, global_ordinal_t, node_t> > colmap,
102  EStorage_Ordering ordering) const
103  {
104  help_getCcs(nzval, rowind, colptr,
105  nnz, colmap, ordering,
106  typename adapter_t::get_ccs_spec());
107  }
108 
109  template < class Matrix >
110  void
111  MatrixAdapter<Matrix>::getCcs(const Teuchos::ArrayView<scalar_t> nzval,
112  const Teuchos::ArrayView<global_ordinal_t> rowind,
113  const Teuchos::ArrayView<typename MatrixAdapter<Matrix>::global_size_t> colptr,
114  typename MatrixAdapter<Matrix>::global_size_t& nnz,
115  EDistribution distribution,
116  EStorage_Ordering ordering) const
117  {
118  const Teuchos::RCP<const Tpetra::Map<local_ordinal_t,global_ordinal_t,node_t> > colmap
119  = Util::getDistributionMap<local_ordinal_t,global_ordinal_t,global_size_t,node_t>(distribution,
120  this->getGlobalNumCols(),
121  this->getComm());
122  this->getCcs(nzval, rowind, colptr, nnz, Teuchos::ptrInArg(*colmap), ordering);
123  }
124 
125  template < class Matrix >
126  typename MatrixAdapter<Matrix>::global_size_t
128  {
129  return static_cast<const adapter_t*>(this)->getGlobalNumRows_impl();
130  }
131 
132  template < class Matrix >
133  typename MatrixAdapter<Matrix>::global_size_t
135  {
136  return static_cast<const adapter_t*>(this)->getGlobalNumCols_impl();
137  }
138 
139  template < class Matrix >
140  typename MatrixAdapter<Matrix>::global_size_t
142  {
143  return row_map_->getIndexBase();
144  }
145 
146  template < class Matrix >
147  typename MatrixAdapter<Matrix>::global_size_t
149  {
150  return col_map_->getIndexBase();
151  }
152 
153  template < class Matrix >
154  typename MatrixAdapter<Matrix>::global_size_t
156  {
157  return static_cast<const adapter_t*>(this)->getGlobalNNZ_impl();
158  }
159 
160  template < class Matrix >
161  size_t
163  {
164  return row_map_->getNodeNumElements(); // TODO: verify
165  }
166 
167  template < class Matrix >
168  size_t
170  {
171  return col_map_->getNodeNumElements();
172  }
173 
174  template < class Matrix >
175  size_t
177  {
178  return static_cast<const adapter_t*>(this)->getLocalNNZ_impl();
179  }
180 
181  template < class Matrix >
182  std::string
184  {
185  std::ostringstream oss;
186  oss << "Amesos2::MatrixAdapter wrapping: ";
187  oss << mat_->description();
188  return oss.str();
189  }
190 
191  template < class Matrix >
192  void
193  MatrixAdapter<Matrix>::describe(Teuchos::FancyOStream &out,
194  const Teuchos::EVerbosityLevel verbLevel) const
195  {}
196 
197 
198 
199  /******************************
200  * Private method definitions *
201  ******************************/
202 
203  template < class Matrix >
204  void
205  MatrixAdapter<Matrix>::help_getCrs(const Teuchos::ArrayView<scalar_t> nzval,
206  const Teuchos::ArrayView<global_ordinal_t> colind,
207  const Teuchos::ArrayView<typename MatrixAdapter<Matrix>::global_size_t> rowptr,
208  typename MatrixAdapter<Matrix>::global_size_t& nnz,
209  const Teuchos::Ptr<const Tpetra::Map<local_ordinal_t,global_ordinal_t,node_t> > rowmap,
210  EStorage_Ordering ordering,
211  has_special_impl hsi) const
212  {
213  hsi.set = false;
214  static_cast<const adapter_t*>(this)->getCrs_spec(nzval, colind, rowptr,
215  nnz, rowmap, ordering);
216  }
217 
218  template < class Matrix >
219  void
220  MatrixAdapter<Matrix>::help_getCrs(const Teuchos::ArrayView<scalar_t> nzval,
221  const Teuchos::ArrayView<global_ordinal_t> colind,
222  const Teuchos::ArrayView<typename MatrixAdapter<Matrix>::global_size_t> rowptr,
223  typename MatrixAdapter<Matrix>::global_size_t& nnz,
224  const Teuchos::Ptr<const Tpetra::Map<local_ordinal_t,global_ordinal_t,node_t> > rowmap,
225  EStorage_Ordering ordering,
226  no_special_impl nsi) const
227  {
228 
229  //Added void to remove parameter not used warning
230  ((void)nsi);
231  do_getCrs(nzval, colind, rowptr,
232  nnz, rowmap, ordering,
233  typename adapter_t::major_access());
234  }
235 
236  template < class Matrix >
237  void
238  MatrixAdapter<Matrix>::do_getCrs(const Teuchos::ArrayView<scalar_t> nzval,
239  const Teuchos::ArrayView<global_ordinal_t> colind,
240  const Teuchos::ArrayView<typename MatrixAdapter<Matrix>::global_size_t> rowptr,
241  typename MatrixAdapter<Matrix>::global_size_t& nnz,
242  const Teuchos::Ptr<const Tpetra::Map<local_ordinal_t,global_ordinal_t,node_t> > rowmap,
243  EStorage_Ordering ordering,
244  row_access ra) const
245  {
246  using Teuchos::rcp;
247  using Teuchos::RCP;
248  using Teuchos::ArrayView;
249  using Teuchos::OrdinalTraits;
250 
251 
252  ((void) ra);
253 
254  RCP<const type> get_mat;
255  if( *rowmap == *this->row_map_ ){
256  // No need to redistribute
257  get_mat = rcp(this,false); // non-owning
258  } else {
259  get_mat = get(rowmap);
260  }
261  // RCP<const type> get_mat = get(rowmap);
262 
263  // rmap may not necessarily check same as rowmap because rmap may
264  // have been constructued with Tpetra's "expert" constructor,
265  // which assumes that the map points are non-contiguous.
266  //
267  // TODO: There may be some more checking between the row map
268  // compatibility, but things are working fine now.
269  RCP<const Tpetra::Map<local_ordinal_t,global_ordinal_t,node_t> > rmap = get_mat->getRowMap();
270 
271  ArrayView<const global_ordinal_t> node_elements = rmap->getNodeElementList();
272  if( node_elements.size() == 0 ) return; // no more contribution
273 
274  typename ArrayView<const global_ordinal_t>::iterator row_it, row_end;
275  row_end = node_elements.end();
276 
277  size_t rowptr_ind = OrdinalTraits<size_t>::zero();
278  global_ordinal_t rowInd = OrdinalTraits<global_ordinal_t>::zero();
279  for( row_it = node_elements.begin(); row_it != row_end; ++row_it ){
280  rowptr[rowptr_ind++] = rowInd;
281  size_t rowNNZ = get_mat->getGlobalRowNNZ(*row_it);
282  size_t nnzRet = OrdinalTraits<size_t>::zero();
283  ArrayView<global_ordinal_t> colind_view = colind.view(rowInd,rowNNZ);
284  ArrayView<scalar_t> nzval_view = nzval.view(rowInd,rowNNZ);
285 
286  get_mat->getGlobalRowCopy(*row_it, colind_view, nzval_view, nnzRet);
287  for (size_t rr = 0; rr < nnzRet ; rr++)
288  {
289  colind_view[rr] = colind_view[rr] - rmap->getIndexBase();
290  }
291 
292  // It was suggested that instead of sorting each row's indices
293  // individually, that we instead do a double-transpose at the
294  // end, which would also lead to the indices being sorted.
295  if( ordering == SORTED_INDICES ){
296  Tpetra::sort2(colind_view.begin(), colind_view.end(), nzval_view.begin());
297  }
298 
299  TEUCHOS_TEST_FOR_EXCEPTION( rowNNZ != nnzRet,
300  std::runtime_error,
301  "Number of values returned different from "
302  "number of values reported");
303  rowInd += rowNNZ;
304  }
305  rowptr[rowptr_ind] = nnz = rowInd;
306  }
307 
308  // TODO: This may not work with distributed matrices.
309  template < class Matrix >
310  void
311  MatrixAdapter<Matrix>::do_getCrs(const Teuchos::ArrayView<scalar_t> nzval,
312  const Teuchos::ArrayView<global_ordinal_t> colind,
313  const Teuchos::ArrayView<typename MatrixAdapter<Matrix>::global_size_t> rowptr,
314  typename MatrixAdapter<Matrix>::global_size_t& nnz,
315  const Teuchos::Ptr<const Tpetra::Map<local_ordinal_t,global_ordinal_t,node_t> > rowmap,
316  EStorage_Ordering ordering,
317  col_access ca) const
318  {
319  using Teuchos::Array;
320  // get the ccs and transpose
321 
322  Array<scalar_t> nzval_tmp(nzval.size(), 0);
323  Array<global_ordinal_t> rowind(colind.size(), 0);
324  Array<global_size_t> colptr(this->getGlobalNumCols() + 1);
325  this->getCcs(nzval_tmp(), rowind(), colptr(), nnz, rowmap, ordering);
326 
327  if( !nzval.is_null() && !colind.is_null() && !rowptr.is_null() )
328  Util::transpose(nzval_tmp(), rowind(), colptr(), nzval, colind, rowptr);
329  }
330 
331  template < class Matrix >
332  void
333  MatrixAdapter<Matrix>::help_getCcs(const Teuchos::ArrayView<scalar_t> nzval,
334  const Teuchos::ArrayView<global_ordinal_t> rowind,
335  const Teuchos::ArrayView<typename MatrixAdapter<Matrix>::global_size_t> colptr,
336  typename MatrixAdapter<Matrix>::global_size_t& nnz,
337  const Teuchos::Ptr<const Tpetra::Map<local_ordinal_t,global_ordinal_t,node_t> > colmap,
338  EStorage_Ordering ordering,
339  has_special_impl hsi) const
340  {
341  static_cast<const adapter_t*>(this)->getCcs_spec(nzval, rowind, colptr,
342  nnz, colmap, ordering);
343  }
344 
345  template < class Matrix >
346  void
347  MatrixAdapter<Matrix>::help_getCcs(const Teuchos::ArrayView<scalar_t> nzval,
348  const Teuchos::ArrayView<global_ordinal_t> rowind,
349  const Teuchos::ArrayView<typename MatrixAdapter<Matrix>::global_size_t> colptr,
350  typename MatrixAdapter<Matrix>::global_size_t& nnz,
351  const Teuchos::Ptr<const Tpetra::Map<local_ordinal_t,global_ordinal_t,node_t> > colmap,
352  EStorage_Ordering ordering,
353  no_special_impl nsi) const
354  {
355  ((void)nsi);
356 
357  do_getCcs(nzval, rowind, colptr,
358  nnz, colmap, ordering,
359  typename adapter_t::major_access());
360  }
361 
362  template < class Matrix >
363  void
364  MatrixAdapter<Matrix>::do_getCcs(const Teuchos::ArrayView<scalar_t> nzval,
365  const Teuchos::ArrayView<global_ordinal_t> rowind,
366  const Teuchos::ArrayView<typename MatrixAdapter<Matrix>::global_size_t> colptr,
367  typename MatrixAdapter<Matrix>::global_size_t& nnz,
368  const Teuchos::Ptr<const Tpetra::Map<local_ordinal_t,global_ordinal_t,node_t> > colmap,
369  EStorage_Ordering ordering,
370  row_access ra) const
371  {
372  using Teuchos::Array;
373  // get the crs and transpose
374 
375  ((void) ra);
376 
377  Array<scalar_t> nzval_tmp(nzval.size(), 0);
378  Array<global_ordinal_t> colind(rowind.size(), 0);
379  Array<global_size_t> rowptr(this->getGlobalNumRows() + 1);
380  this->getCrs(nzval_tmp(), colind(), rowptr(), nnz, colmap, ordering);
381 
382  if( !nzval.is_null() && !rowind.is_null() && !colptr.is_null() )
383  Util::transpose(nzval_tmp(), colind(), rowptr(), nzval, rowind, colptr);
384  }
385 
386  template < class Matrix >
387  void
388  MatrixAdapter<Matrix>::do_getCcs(const Teuchos::ArrayView<scalar_t> nzval,
389  const Teuchos::ArrayView<global_ordinal_t> rowind,
390  const Teuchos::ArrayView<typename MatrixAdapter<Matrix>::global_size_t> colptr,
391  typename MatrixAdapter<Matrix>::global_size_t& nnz,
392  const Teuchos::Ptr<const Tpetra::Map<local_ordinal_t,global_ordinal_t,node_t> > colmap,
393  EStorage_Ordering ordering,
394  col_access ca) const
395  {
396  using Teuchos::RCP;
397  using Teuchos::ArrayView;
398  using Teuchos::OrdinalTraits;
399 
400  RCP<const type> get_mat;
401  if( *colmap == *this->col_map_ ){
402  // No need to redistribute
403  get_mat = rcp(this,false); // non-owning
404  } else {
405  get_mat = get(colmap);
406  }
407 
408  // If all is well and good, then colmap == cmap
409  RCP<const Tpetra::Map<scalar_t,local_ordinal_t,global_ordinal_t> > cmap = get_mat->getColMap();
410  TEUCHOS_ASSERT( *colmap == *cmap );
411 
412  ArrayView<global_ordinal_t> node_elements = cmap->getNodeElementList();
413  if( node_elements.size() == 0 ) return; // no more contribution
414 
415  typename ArrayView<global_ordinal_t>::iterator col_it, col_end;
416  col_end = node_elements.end();
417 
418  size_t colptr_ind = OrdinalTraits<size_t>::zero();
419  global_ordinal_t colInd = OrdinalTraits<global_ordinal_t>::zero();
420  for( col_it = node_elements.begin(); col_it != col_end; ++col_it ){
421  colptr[colptr_ind++] = colInd;
422  size_t colNNZ = getGlobalColNNZ(*col_it);
423  size_t nnzRet = 0;
424  ArrayView<global_ordinal_t> rowind_view = rowind.view(colInd,colNNZ);
425  ArrayView<scalar_t> nzval_view = nzval.view(colInd,colNNZ);
426  getGlobalColCopy(*col_it, rowind_view, nzval_view, nnzRet);
427 
428  // It was suggested that instead of sorting each row's indices
429  // individually, that we instead do a double-transpose at the
430  // end, which would also lead to the indices being sorted.
431  if( ordering == SORTED_INDICES ){
432  Tpetra::sort2(rowind_view.begin(), rowind_view.end(), nzval_view.begin());
433  }
434 
435  TEUCHOS_TEST_FOR_EXCEPTION( colNNZ != nnzRet,
436  std::runtime_error,
437  "Number of values returned different from "
438  "number of values reported");
439  colInd += colNNZ;
440  }
441  colptr[colptr_ind] = nnz = colInd;
442  }
443 
444 
445  // These will link to concrete implementations
446  template < class Matrix >
447  void
449  const Teuchos::ArrayView<global_ordinal_t>& indices,
450  const Teuchos::ArrayView<scalar_t>& vals,
451  size_t& nnz) const
452  {
453  static_cast<const adapter_t*>(this)->getGlobalRowCopy_impl(row, indices, vals, nnz);
454  }
455 
456  template < class Matrix >
457  void
459  const Teuchos::ArrayView<global_ordinal_t>& indices,
460  const Teuchos::ArrayView<scalar_t>& vals,
461  size_t& nnz) const
462  {
463  static_cast<const adapter_t*>(this)->getGlobalColCopy_impl(col, indices, vals, nnz);
464  }
465 
466  template < class Matrix >
467  size_t
469  {
470  return static_cast<const adapter_t*>(this)->getMaxRowNNZ_impl();
471  }
472 
473  template < class Matrix >
474  size_t
475  MatrixAdapter<Matrix>::getMaxColNNZ() const
476  {
477  return static_cast<const adapter_t*>(this)->getMaxColNNZ_impl();
478  }
479 
480  template < class Matrix >
481  size_t
482  MatrixAdapter<Matrix>::getGlobalRowNNZ(global_ordinal_t row) const
483  {
484  return static_cast<const adapter_t*>(this)->getGlobalRowNNZ_impl(row);
485  }
486 
487  template < class Matrix >
488  size_t
489  MatrixAdapter<Matrix>::getLocalRowNNZ(local_ordinal_t row) const
490  {
491  return static_cast<const adapter_t*>(this)->getLocalRowNNZ_impl(row);
492  }
493 
494  template < class Matrix >
495  size_t
496  MatrixAdapter<Matrix>::getGlobalColNNZ(global_ordinal_t col) const
497  {
498  return static_cast<const adapter_t*>(this)->getGlobalColNNZ_impl(col);
499  }
500 
501  template < class Matrix >
502  size_t
503  MatrixAdapter<Matrix>::getLocalColNNZ(local_ordinal_t col) const
504  {
505  return static_cast<const adapter_t*>(this)->getLocalColNNZ_impl(col);
506  }
507 
508  template < class Matrix >
509  bool
510  MatrixAdapter<Matrix>::isLocallyIndexed() const
511  {
512  return static_cast<const adapter_t*>(this)->isLocallyIndexed_impl();
513  }
514 
515  template < class Matrix >
516  bool
517  MatrixAdapter<Matrix>::isGloballyIndexed() const
518  {
519  return static_cast<const adapter_t*>(this)->isGloballyIndexed_impl();
520  }
521 
522  template < class Matrix >
523  Teuchos::RCP<const MatrixAdapter<Matrix> >
524  MatrixAdapter<Matrix>::get(const Teuchos::Ptr<const Tpetra::Map<local_ordinal_t,global_ordinal_t,node_t> > map) const
525  {
526  return static_cast<const adapter_t*>(this)->get_impl(map);
527  }
528 
529 
530  template <class Matrix>
531  Teuchos::RCP<MatrixAdapter<Matrix> >
532  createMatrixAdapter(Teuchos::RCP<Matrix> m){
533  using Teuchos::rcp;
534  using Teuchos::rcp_const_cast;
535 
536  if(m.is_null()) return Teuchos::null;
537  return( rcp(new ConcreteMatrixAdapter<Matrix>(m)) );
538  }
539 
540  template <class Matrix>
541  Teuchos::RCP<const MatrixAdapter<Matrix> >
542  createConstMatrixAdapter(Teuchos::RCP<const Matrix> m){
543  using Teuchos::rcp;
544  using Teuchos::rcp_const_cast;
545 
546  if(m.is_null()) return Teuchos::null;
547  return( rcp(new ConcreteMatrixAdapter<Matrix>(rcp_const_cast<Matrix,const Matrix>(m))).getConst() );
548  }
549 
550 } // end namespace Amesos2
551 
552 #endif // AMESOS2_MATRIXADAPTER_DEF_HPP
EStorage_Ordering
Definition: Amesos2_TypeDecl.hpp:140
Indicates that the concrete class has a special implementation that should be called.
Definition: Amesos2_TypeDecl.hpp:82
void transpose(ArrayView< Scalar > vals, ArrayView< GlobalOrdinal > indices, ArrayView< GlobalSizeT > ptr, ArrayView< Scalar > trans_vals, ArrayView< GlobalOrdinal > trans_indices, ArrayView< GlobalSizeT > trans_ptr)
Definition: Amesos2_AbstractConcreteMatrixAdapter.hpp:48
A Matrix adapter interface for Amesos2.
Definition: Amesos2_MatrixAdapter_decl.hpp:76
std::string description() const
Returns a short description of this Solver.
Definition: Amesos2_MatrixAdapter_def.hpp:183
EDistribution
Definition: Amesos2_TypeDecl.hpp:123