|
PyTrilinos
Development
|
Public Member Functions | |
| def | __init__ |
| def | SetMaps |
| def | ExtractMyRowCopy |
| def | ExtractMyEntryView |
| def | NumMyRowEntries |
| def | Multiply |
| def | Solve |
| def | ExtractDiagonalCopy |
| def | InvRowSums |
| def | LeftScale |
| def | InvColSums |
| def | RightScale |
| def | Filled |
| def | LowerTriangular |
| def | UpperTriangular |
| def | NormInf |
| def | NormOne |
| def | NumGlobalNonzeros |
| def | NumGlobalNonzeros64 |
| def | NumGlobalRows |
| def | NumGlobalRows64 |
| def | NumGlobalCols |
| def | NumGlobalCols64 |
| def | NumGlobalDiagonals |
| def | NumGlobalDiagonals64 |
| def | NumMyNonzeros |
| def | NumMyRows |
| def | NumMyCols |
| def | NumMyDiagonals |
| def | MaxNumEntries |
| def | OperatorDomainMap |
| def | OperatorRangeMap |
| def | Map |
| def | RowMatrixRowMap |
| def | RowMatrixColMap |
| def | RowMatrixImporter |
| def | Comm |
| def | SetUseTranspose |
| def | Label |
| def | Apply |
| def | ApplyInverse |
| def | HasNormInf |
| def | UseTranspose |
| def | Importer |
| def | Exporter |
| def | ComputeStructureConstants |
| def | ComputeNumericConstants |
| def | __disown__ |
Public Attributes | |
| this | |
Epetra_BasicRowMatrix: A class for simplifying the development of Epetra_RowMatrix adapters. The Epetra_BasicRowMatrix is an adapter class for Epetra_RowMatrix that implements most of the Epetra_RowMatrix methods using reasonable default implementations. The Epetra_RowMatrix class has 39 pure virtual methods, requiring the adapter class to implement all of them. Epetra_BasicRowMatrix has only 4 pure virtual methods that must be implemented (See Epetra_JadMatrix for an example): ExtractMyRowCopy: Provide a row of values and indices for a specified local row. ExtractMyEntryView (const and non-const versions): Provide the memory address of the ith nonzero term stored on the calling processor, along with its corresponding local row and column index, where i goes from 0 to the NumMyNonzeros()-1. The order in which the nonzeros are traversed is not specified and is up to the adapter implementation. NumMyRowEntries: Provide the number of entries for a specified local row. An alternative is possible if you do not want to provide a non-trivial implementation of the ExtraMyEntryView methods (See Epetra_VbrRowMatrix for an example): Implement ExtractMyRowCopy and NumMyRowEntries as above. Implement ExtractMyEntryView (both versions) returning a -1 integer code with no other executable code. Implement the RightScale and LeftScale methods non-trivially. In addition, most adapters will probably re-implement the Multiply() method and perhaps the Solve() method, although one or the other may be implemented to return -1, signaling that there is no valid implementation. By default, the Multiply() method is implemented using ExtractMyRowCopy, which can usual be improved upon. By default Solve() and ApplyInverse() are implemented to return -1 (not implemented). All other implemented methods in Epetra_BasicRowMatrix should not exhibit a signficant performance degradation, either because they are relatively small and fast, or because they are not a significant portion of the runtime for most codes. All methods are virtual, so they can be re-implemented by the adapter. In addition to implementing the above methods, an adapter must inherit the Epetra_BasicRowMatrix interface and call the Epetra_BasicRowMatrix constructor as part of the adapter constructor. There are two constructors. The first requires the user to pass in the RowMap and ColMap, both of which are Epetra_Map objects. On each processor the RowMap (ColMap) must contain the global IDs (GIDs) of the rows (columns) that the processor cares about. The first constructor requires only these two maps, assuming that the RowMap will also serve as the DomainMap and RangeMap. In this case, the RowMap must be 1-to-1, meaning that if a global ID appears on one processor, it appears only once on that processor and does not appear on any other processor. For many sparse matrix data structures, it is the case that a given row is completely owned by one processor and that the global matrix is square. The first constructor is for this situation. The second constructor allows the caller to specify all four maps. In this case the DomainMap, the layout of multivectors/vectors that are in the domain of the matrix (the x vector if computing y = A*x), must be 1-to-1. Also, the RangeMap, the layout of y must be 1-to-1. The RowMap and ColMap do not need to be 1-to-1, but the GIDs must be found in the RangeMap and DomainMap, respectively. Note that Epetra_Operator is a base class for Epetra_RowMatrix, so any adapter for Epetra_BasicRowMatrix (or Epetra_RowMatrix) is also an adapter for Epetra_Operator. An example of how to provide an adapter for Epetra_BasicRowMatrix can be found by looking at Epetra_JadMatrix. C++ includes: Epetra_BasicRowMatrix.h
| def PyTrilinos.Epetra.BasicRowMatrix.__init__ | ( | self, | |
| args | |||
| ) |
__init__(Epetra_BasicRowMatrix self, Comm Comm) -> BasicRowMatrix Epetra_BasicRowMatrix::Epetra_BasicRowMatrix(const Epetra_Comm &Comm) Epetra_BasicRowMatrix constructor. This constructor requires a valid Epetra_Comm object as its only argument. The constructor will use Comm to build Epetra_Maps objects: RowMap, ColMap, DomainMap and RangeMap. However, these will be zero- length (trivial) maps that must be reset by calling one of the two SetMap() methods listed below. Parameters: ----------- Comm: An Epetra_Comm containing a valid Comm object.
Reimplemented from PyTrilinos.Epetra.Object.
Reimplemented in PyTrilinos.Epetra.JadMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.Apply | ( | self, | |
| args | |||
| ) |
Apply(BasicRowMatrix self, Epetra_MultiVector X, Epetra_MultiVector Y) -> int virtual int Epetra_BasicRowMatrix::Apply(const Epetra_MultiVector &X, Epetra_MultiVector &Y) const Returns the result of a Epetra_RowMatrix applied to a Epetra_MultiVector X in Y. Parameters: ----------- X: (In) - A Epetra_MultiVector of dimension NumVectors to multiply with matrix. Y: (Out) - A Epetra_MultiVector of dimension NumVectors containing result. Integer error code, set to 0 if successful.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.Epetra.BasicRowMatrix.ApplyInverse | ( | self, | |
| args | |||
| ) |
ApplyInverse(BasicRowMatrix self, Epetra_MultiVector X, Epetra_MultiVector Y) -> int virtual int Epetra_BasicRowMatrix::ApplyInverse(const Epetra_MultiVector &X, Epetra_MultiVector &Y) const Returns the result of a Epetra_RowMatrix inverse applied to an Epetra_MultiVector X in Y. Parameters: ----------- X: (In) - A Epetra_MultiVector of dimension NumVectors to solve for. Y: (Out) - A Epetra_MultiVector of dimension NumVectors containing result. Integer error code = -1. WARNING: This method is NOT supported.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.Epetra.BasicRowMatrix.Comm | ( | self, | |
| args | |||
| ) |
Comm(BasicRowMatrix self) -> Comm virtual const Epetra_Comm& Epetra_BasicRowMatrix::Comm() const Returns a pointer to the Epetra_Comm communicator associated with this matrix.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.Epetra.BasicRowMatrix.ComputeNumericConstants | ( | self, | |
| args | |||
| ) |
ComputeNumericConstants(BasicRowMatrix self)
| def PyTrilinos.Epetra.BasicRowMatrix.ComputeStructureConstants | ( | self, | |
| args | |||
| ) |
ComputeStructureConstants(BasicRowMatrix self)
| def PyTrilinos.Epetra.BasicRowMatrix.Exporter | ( | self, | |
| args | |||
| ) |
Exporter(BasicRowMatrix self) -> Export virtual const Epetra_Export* Epetra_BasicRowMatrix::Exporter() const Returns the Epetra_Export object that contains the export operations for distributed operations, returns zero if none. If RowMatrixRowMap!=OperatorRangeMap, then this method returns a pointer to an Epetra_Export object that exports objects from an RowMatrixRowMap layout to a OperatorRangeMap layout. This operation is needed for sparse matrix- vector multiplication, y = Ax, to scatter- add y elements generated during local multiplication operations. If RowMatrixRowMap==OperatorRangeMap, then the pointer will be returned as 0. For a typical Epetra_RowMatrix object, this pointer will be zero since it is often the case that RowMatrixRowMap==OperatorRangeMap. Raw pointer to exporter. This exporter will be valid as long as the Epetra_RowMatrix object is valid.
| def PyTrilinos.Epetra.BasicRowMatrix.ExtractDiagonalCopy | ( | self, | |
| args | |||
| ) |
ExtractDiagonalCopy(BasicRowMatrix self, Epetra_Vector Diagonal) -> int int Epetra_BasicRowMatrix::ExtractDiagonalCopy(Epetra_Vector &Diagonal) const Returns a copy of the main diagonal in a user-provided vector. Parameters: ----------- Diagonal: (Out) - Extracted main diagonal. Integer error code, set to 0 if successful.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.ExtractMyEntryView | ( | self, | |
| args | |||
| ) |
ExtractMyEntryView(BasicRowMatrix self, int CurEntry, double *& Value, int & RowIndex, int & ColIndex) -> int virtual int Epetra_BasicRowMatrix::ExtractMyEntryView(int CurEntry, double const *&Value, int &RowIndex, int &ColIndex) const =0 Returns a const reference to the ith entry in the matrix, along with its row and column index. Parameters: ----------- CurEntry: (In) - Index of local entry (from 0 to NumMyNonzeros()-1) to extract. Value: (Out) - Extracted reference to current values. RowIndex: (Out) - Row index for current entry. ColIndex: (Out) - Column index for current entry. Integer error code, set to 0 if successful, set to -1 if CurEntry not valid.
| def PyTrilinos.Epetra.BasicRowMatrix.ExtractMyRowCopy | ( | self, | |
| args | |||
| ) |
ExtractMyRowCopy(BasicRowMatrix self, int MyRow, int Length, int & NumEntries, double * Values, int * Indices) -> int virtual int Epetra_BasicRowMatrix::ExtractMyRowCopy(int MyRow, int Length, int &NumEntries, double *Values, int *Indices) const =0 Returns a copy of the specified local row in user-provided arrays. Parameters: ----------- MyRow: (In) - Local row to extract. Length: (In) - Length of Values and Indices. NumEntries: (Out) - Number of nonzero entries extracted. Values: (Out) - Extracted values for this row. Indices: (Out) - Extracted global column indices for the corresponding values. Integer error code, set to 0 if successful, set to -1 if MyRow not valid, -2 if Length is too short (NumEntries will have required length).
Reimplemented from PyTrilinos.Epetra.RowMatrix.
Reimplemented in PyTrilinos.Epetra.JadMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.Filled | ( | self, | |
| args | |||
| ) |
Filled(BasicRowMatrix self) -> bool virtual bool Epetra_BasicRowMatrix::Filled() const If FillComplete() has been called, this query returns true, otherwise it returns false, presently always returns true.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.HasNormInf | ( | self, | |
| args | |||
| ) |
HasNormInf(BasicRowMatrix self) -> bool bool Epetra_BasicRowMatrix::HasNormInf() const Returns true because this class can compute an Inf-norm.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.Epetra.BasicRowMatrix.Importer | ( | self, | |
| args | |||
| ) |
Importer(BasicRowMatrix self) -> Import virtual const Epetra_Import* Epetra_BasicRowMatrix::Importer() const Returns the Epetra_Import object that contains the import operations for distributed operations, returns zero if none. If RowMatrixColMap!=OperatorDomainMap, then this method returns a pointer to an Epetra_Import object that imports objects from an OperatorDomainMap layout to a RowMatrixColMap layout. This operation is needed for sparse matrix- vector multiplication, y = Ax, to gather x elements for local multiplication operations. If RowMatrixColMap==OperatorDomainMap, then the pointer will be returned as 0. Raw pointer to importer. This importer will be valid as long as the Epetra_RowMatrix object is valid.
| def PyTrilinos.Epetra.BasicRowMatrix.InvColSums | ( | self, | |
| args | |||
| ) |
InvColSums(BasicRowMatrix self, Epetra_Vector x) -> int int Epetra_BasicRowMatrix::InvColSums(Epetra_Vector &x) const Computes the sum of absolute values of the columns of the Epetra_BasicRowMatrix, results returned in x. The vector x will return such that x[j] will contain the inverse of sum of the absolute values of the this matrix will be sca such that A(i,j) = x(j)*A(i,j) where i denotes the global row number of A and j denotes the global column number of A. Using the resulting vector from this function as input to RighttScale() will make the one norm of the resulting matrix exactly 1. Parameters: ----------- x: (Out) - An Epetra_Vector containing the column sums of the this matrix. WARNING: It is assumed that the distribution of x is the same as the rows of this. Integer error code, set to 0 if successful.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.InvRowSums | ( | self, | |
| args | |||
| ) |
InvRowSums(BasicRowMatrix self, Epetra_Vector x) -> int int Epetra_BasicRowMatrix::InvRowSums(Epetra_Vector &x) const Computes the sum of absolute values of the rows of the Epetra_BasicRowMatrix, results returned in x. The vector x will return such that x[i] will contain the inverse of sum of the absolute values of the this matrix will be scaled such that A(i,j) = x(i)*A(i,j) where i denotes the global row number of A and j denotes the global column number of A. Using the resulting vector from this function as input to LeftScale() will make the infinity norm of the resulting matrix exactly 1. Parameters: ----------- x: (Out) - An Epetra_Vector containing the row sums of the this matrix. WARNING: It is assumed that the distribution of x is the same as the rows of this. Integer error code, set to 0 if successful.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.Label | ( | self, | |
| args | |||
| ) |
Label(BasicRowMatrix self) -> char const * virtual const char* Epetra_BasicRowMatrix::Label() const Returns a character string describing the operator.
Reimplemented from PyTrilinos.Epetra.Object.
| def PyTrilinos.Epetra.BasicRowMatrix.LeftScale | ( | self, | |
| args | |||
| ) |
LeftScale(BasicRowMatrix self, Epetra_Vector x) -> int int Epetra_BasicRowMatrix::LeftScale(const Epetra_Vector &x) Scales the Epetra_BasicRowMatrix on the left with a Epetra_Vector x. The this matrix will be scaled such that A(i,j) = x(i)*A(i,j) where i denotes the row number of A and j denotes the column number of A. Parameters: ----------- x: (In) - An Epetra_Vector to solve for. Integer error code, set to 0 if successful.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.LowerTriangular | ( | self, | |
| args | |||
| ) |
LowerTriangular(BasicRowMatrix self) -> bool bool Epetra_BasicRowMatrix::LowerTriangular() const If matrix is lower triangular, this query returns true, otherwise it returns false.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.Map | ( | self, | |
| args | |||
| ) |
Map(BasicRowMatrix self) -> BlockMap virtual const Epetra_BlockMap& Epetra_BasicRowMatrix::Map() const Implement the Epetra_SrcDistObjec::Map() function.
Reimplemented from PyTrilinos.Epetra.SrcDistObject.
| def PyTrilinos.Epetra.BasicRowMatrix.MaxNumEntries | ( | self, | |
| args | |||
| ) |
MaxNumEntries(BasicRowMatrix self) -> int virtual int Epetra_BasicRowMatrix::MaxNumEntries() const Returns the maximum number of nonzero entries across all rows on this processor.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.Multiply | ( | self, | |
| args | |||
| ) |
Multiply(BasicRowMatrix self, bool TransA, Epetra_MultiVector X, Epetra_MultiVector Y) -> int int Epetra_BasicRowMatrix::Multiply(bool TransA, const Epetra_MultiVector &X, Epetra_MultiVector &Y) const Returns the result of a Epetra_BasicRowMatrix multiplied by a Epetra_MultiVector X in Y. Parameters: ----------- TransA: (In) - If true, multiply by the transpose of matrix, otherwise just use matrix. X: (Out) - An Epetra_MultiVector of dimension NumVectors to multiply with matrix. Y: (Out) - An Epetra_MultiVector of dimension NumVectorscontaining result. Integer error code, set to 0 if successful.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
Reimplemented in PyTrilinos.Epetra.JadMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NormInf | ( | self, | |
| args | |||
| ) |
NormInf(BasicRowMatrix self) -> double
virtual double
Epetra_BasicRowMatrix::NormInf() const
Returns the infinity norm of the global matrix.
Returns the quantity $ \\| A \\|_\\infty$ such that \\[\\| A
\\|_\\infty = \\max_{1\\lei\\lem} \\sum_{j=1}^n |a_{ij}|
\\].
WARNING: This method is supported if and only if the Epetra_RowMatrix
Object that was used to create this supports this method.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NormOne | ( | self, | |
| args | |||
| ) |
NormOne(BasicRowMatrix self) -> double
virtual double
Epetra_BasicRowMatrix::NormOne() const
Returns the one norm of the global matrix.
Returns the quantity $ \\| A \\|_1$ such that \\[\\| A
\\|_1= \\max_{1\\lej\\len} \\sum_{i=1}^m |a_{ij}| \\].
WARNING: This method is supported if and only if the Epetra_RowMatrix
Object that was used to create this supports this method.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NumGlobalCols | ( | self, | |
| args | |||
| ) |
NumGlobalCols(BasicRowMatrix self) -> int virtual int Epetra_BasicRowMatrix::NumGlobalCols() const Returns the number of global matrix columns.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NumGlobalCols64 | ( | self, | |
| args | |||
| ) |
NumGlobalCols64(BasicRowMatrix self) -> long long virtual long long Epetra_BasicRowMatrix::NumGlobalCols64() const
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NumGlobalDiagonals | ( | self, | |
| args | |||
| ) |
NumGlobalDiagonals(BasicRowMatrix self) -> int virtual int Epetra_BasicRowMatrix::NumGlobalDiagonals() const Returns the number of global nonzero diagonal entries.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NumGlobalDiagonals64 | ( | self, | |
| args | |||
| ) |
NumGlobalDiagonals64(BasicRowMatrix self) -> long long virtual long long Epetra_BasicRowMatrix::NumGlobalDiagonals64() const
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NumGlobalNonzeros | ( | self, | |
| args | |||
| ) |
NumGlobalNonzeros(BasicRowMatrix self) -> int virtual int Epetra_BasicRowMatrix::NumGlobalNonzeros() const Returns the number of nonzero entries in the global matrix. Note that if the data decomposition is defined such that some nonzeros appear on multiple processors, then those nonzeros will be counted multiple times.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NumGlobalNonzeros64 | ( | self, | |
| args | |||
| ) |
NumGlobalNonzeros64(BasicRowMatrix self) -> long long virtual long long Epetra_BasicRowMatrix::NumGlobalNonzeros64() const
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NumGlobalRows | ( | self, | |
| args | |||
| ) |
NumGlobalRows(BasicRowMatrix self) -> int virtual int Epetra_BasicRowMatrix::NumGlobalRows() const Returns the number of global matrix rows.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NumGlobalRows64 | ( | self, | |
| args | |||
| ) |
NumGlobalRows64(BasicRowMatrix self) -> long long virtual long long Epetra_BasicRowMatrix::NumGlobalRows64() const
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NumMyCols | ( | self, | |
| args | |||
| ) |
NumMyCols(BasicRowMatrix self) -> int virtual int Epetra_BasicRowMatrix::NumMyCols() const Returns the number of matrix columns owned by the calling processor.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NumMyDiagonals | ( | self, | |
| args | |||
| ) |
NumMyDiagonals(BasicRowMatrix self) -> int virtual int Epetra_BasicRowMatrix::NumMyDiagonals() const Returns the number of local nonzero diagonal entries.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NumMyNonzeros | ( | self, | |
| args | |||
| ) |
NumMyNonzeros(BasicRowMatrix self) -> int virtual int Epetra_BasicRowMatrix::NumMyNonzeros() const Returns the number of nonzero entries in the calling processor's portion of the matrix.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NumMyRowEntries | ( | self, | |
| args | |||
| ) |
NumMyRowEntries(BasicRowMatrix self, int MyRow, int & NumEntries) -> int virtual int Epetra_BasicRowMatrix::NumMyRowEntries(int MyRow, int &NumEntries) const =0 Return the current number of values stored for the specified local row. Similar to NumMyEntries() except NumEntries is returned as an argument and error checking is done on the input value MyRow. Parameters: ----------- MyRow: (In) - Local row. NumEntries: (Out) - Number of nonzero values. Integer error code, set to 0 if successful, set to -1 if MyRow not valid.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
Reimplemented in PyTrilinos.Epetra.JadMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.NumMyRows | ( | self, | |
| args | |||
| ) |
NumMyRows(BasicRowMatrix self) -> int virtual int Epetra_BasicRowMatrix::NumMyRows() const Returns the number of matrix rows owned by the calling processor.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.OperatorDomainMap | ( | self, | |
| args | |||
| ) |
OperatorDomainMap(BasicRowMatrix self) -> Map virtual const Epetra_Map& Epetra_BasicRowMatrix::OperatorDomainMap() const Returns the Epetra_Map object associated with the domain of this operator.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.Epetra.BasicRowMatrix.OperatorRangeMap | ( | self, | |
| args | |||
| ) |
OperatorRangeMap(BasicRowMatrix self) -> Map virtual const Epetra_Map& Epetra_BasicRowMatrix::OperatorRangeMap() const Returns the Epetra_Map object associated with the range of this operator (same as domain).
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.Epetra.BasicRowMatrix.RightScale | ( | self, | |
| args | |||
| ) |
RightScale(BasicRowMatrix self, Epetra_Vector x) -> int int Epetra_BasicRowMatrix::RightScale(const Epetra_Vector &x) Scales the Epetra_BasicRowMatrix on the right with a Epetra_Vector x. The this matrix will be scaled such that A(i,j) = x(j)*A(i,j) where i denotes the global row number of A and j denotes the global column number of A. Parameters: ----------- x: (In) - The Epetra_Vector used for scaling this. Integer error code, set to 0 if successful.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.RowMatrixColMap | ( | self, | |
| args | |||
| ) |
RowMatrixColMap(BasicRowMatrix self) -> Map virtual const Epetra_Map& Epetra_BasicRowMatrix::RowMatrixColMap() const Returns the Column Map object needed for implementing Epetra_RowMatrix.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.RowMatrixImporter | ( | self, | |
| args | |||
| ) |
RowMatrixImporter(BasicRowMatrix self) -> Import virtual const Epetra_Import* Epetra_BasicRowMatrix::RowMatrixImporter() const Returns the Epetra_Import object that contains the import operations for distributed operations.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.RowMatrixRowMap | ( | self, | |
| args | |||
| ) |
RowMatrixRowMap(BasicRowMatrix self) -> Map virtual const Epetra_Map& Epetra_BasicRowMatrix::RowMatrixRowMap() const Returns the Row Map object needed for implementing Epetra_RowMatrix.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.SetMaps | ( | self, | |
| args | |||
| ) |
SetMaps(BasicRowMatrix self, Map RowMap, Map ColMap) SetMaps(BasicRowMatrix self, Map RowMap, Map ColMap, Map DomainMap, Map RangeMap) void Epetra_BasicRowMatrix::SetMaps(const Epetra_Map &RowMap, const Epetra_Map &ColMap, const Epetra_Map &DomainMap, const Epetra_Map &RangeMap) Set maps (Version 2); call this function or the previous, but not both. This constructor takes a row, column, domain and range map. On each processor these maps describe the global rows, columns, domain and range, resp, that the processor will care about. The domain and range maps must be one-to-one, but note that the row and column maps do not have to be one-to-one. In other words, a row ID can appear on more than one processor, as can a column ID. Parameters: ----------- RowMap: An Epetra_Map containing on each processor a list of GIDs of rows that the processor cares about. ColMap: An Epetra_Map containing on each processor a list of GIDs of columns that the processor cares about. DomainMap: An Epetra_Map describing the distribution of domain vectors and multivectors. RangeMap: An Epetra_Map describing the distribution of range vectors and multivectors.
| def PyTrilinos.Epetra.BasicRowMatrix.SetUseTranspose | ( | self, | |
| args | |||
| ) |
SetUseTranspose(BasicRowMatrix self, bool use_transpose) -> int virtual int Epetra_BasicRowMatrix::SetUseTranspose(bool use_transpose) If set true, transpose of this operator will be applied. This flag allows the transpose of the given operator to be used implicitly. Setting this flag affects only the Apply() and ApplyInverse() methods. If the implementation of this interface does not support transpose use, this method should return a value of -1. Parameters: ----------- use_transpose: (In) - If true, multiply by the transpose of operator, otherwise just use operator. Always returns 0.
Reimplemented from PyTrilinos.Epetra.Operator.
| def PyTrilinos.Epetra.BasicRowMatrix.Solve | ( | self, | |
| args | |||
| ) |
Solve(BasicRowMatrix self, bool Upper, bool Trans, bool UnitDiagonal, Epetra_MultiVector X, Epetra_MultiVector Y) -> int virtual int Epetra_BasicRowMatrix::Solve(bool Upper, bool Trans, bool UnitDiagonal, const Epetra_MultiVector &X, Epetra_MultiVector &Y) const Returns the result of a Epetra_BasicRowMatrix solve with a Epetra_MultiVector X in Y (not implemented). Parameters: ----------- Upper: (In) - If true, solve Ux = y, otherwise solve Lx = y. Trans: (In) - If true, solve transpose problem. UnitDiagonal: (In) - If true, assume diagonal is unit (whether it's stored or not). X: (In) - An Epetra_MultiVector of dimension NumVectors to solve for. Y: (Out) - An Epetra_MultiVector of dimension NumVectors containing result. Integer error code, set to 0 if successful.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
Reimplemented in PyTrilinos.Epetra.JadMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.UpperTriangular | ( | self, | |
| args | |||
| ) |
UpperTriangular(BasicRowMatrix self) -> bool virtual bool Epetra_BasicRowMatrix::UpperTriangular() const If matrix is upper triangular, this query returns true, otherwise it returns false.
Reimplemented from PyTrilinos.Epetra.RowMatrix.
| def PyTrilinos.Epetra.BasicRowMatrix.UseTranspose | ( | self, | |
| args | |||
| ) |
UseTranspose(BasicRowMatrix self) -> bool virtual bool Epetra_BasicRowMatrix::UseTranspose() const Returns the current UseTranspose setting.
Reimplemented from PyTrilinos.Epetra.Operator.
1.7.6.1