|
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 | |
Proxy of C++ Epetra_BasicRowMatrix class
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.__init__ | ( | self, | |
| args | |||
| ) |
__init__(Epetra_BasicRowMatrix self, Comm Comm) -> BasicRowMatrix
Reimplemented from PyTrilinos.NOX.Epetra.Object.
Reimplemented in PyTrilinos.NOX.Epetra.JadMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.Apply | ( | self, | |
| args | |||
| ) |
Apply(self, MultiVector x, MultiVector y) -> int
In C++, the Apply() method is pure virtual, thus intended to be
overridden by derived classes. In python, cross-language polymorphism
is supported, and you are expected to derive classes from this base
class and redefine the Apply() method. C++ code (e.g., AztecOO
solvers) can call back to your Apply() method as needed. You must
support two arguments, labeled here MultiVector x and MultiVector y.
These will be converted from Epetra_MultiVector C++ objects to
numpy-hybrid Epetra.MultiVector objects before they are passed to you.
Thus, it is legal to use slice indexing and other numpy features to
compute y from x.
If application of your operator is successful, return 0; else return
some non-zero error code.
It is strongly suggested that you prevent Apply() from raising any
exceptions. Accidental errors can be prevented by wrapping your code
in a try block:
try:
# Your code goes here...
except Exception, e:
print 'A python exception was raised by method Apply:'
print e
return -1
By returning a -1, you inform the calling routine that Apply() was
unsuccessful.
Reimplemented from PyTrilinos.NOX.Epetra.Operator.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.ApplyInverse | ( | self, | |
| args | |||
| ) |
ApplyInverse(self, MultiVector x, MultiVector y) -> int
In C++, the ApplyInverse() method is pure virtual, thus intended to be
overridden by derived classes. In python, cross-language polymorphism
is supported, and you are expected to derive classes from this base
class and redefine the ApplyInverse() method. C++ code (e.g., AztecOO
solvers) can call back to your ApplyInverse() method as needed. You
must support two arguments, labeled here MultiVector x and MultiVector
y. These will be converted from Epetra_MultiVector C++ objects to
numpy-hybrid Epetra.MultiVector objects before they are passed to you.
Thus, it is legal to use slice indexing and other numpy features to
compute y from x.
If application of your operator is successful, return 0; else return
some non-zero error code.
It is strongly suggested that you prevent ApplyInverse() from raising
any exceptions. Accidental errors can be prevented by wrapping your
code in a try block:
try:
# Your code goes here...
except Exception, e:
print 'A python exception was raised by method ApplyInverse:'
print e
return -1
By returning a -1, you inform the calling routine that ApplyInverse()
was unsuccessful.
Reimplemented from PyTrilinos.NOX.Epetra.Operator.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.Comm | ( | self, | |
| args | |||
| ) |
Comm(BasicRowMatrix self) -> Comm
Reimplemented from PyTrilinos.NOX.Epetra.Operator.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.ComputeNumericConstants | ( | self, | |
| args | |||
| ) |
ComputeNumericConstants(BasicRowMatrix self)
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.ComputeStructureConstants | ( | self, | |
| args | |||
| ) |
ComputeStructureConstants(BasicRowMatrix self)
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.Exporter | ( | self, | |
| args | |||
| ) |
Exporter(BasicRowMatrix self) -> Export
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.ExtractDiagonalCopy | ( | self, | |
| args | |||
| ) |
ExtractDiagonalCopy(Vector diagonal) -> int Argument diagonal is provided to you as a numpy-hybrid Epetra.Vector, giving you access to the numpy interface in addition to the Epetra_Vector C++ interface.
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.ExtractMyEntryView | ( | self, | |
| args | |||
| ) |
ExtractMyEntryView(BasicRowMatrix self, int CurEntry, double *& Value, int & RowIndex, int & ColIndex) -> int
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.ExtractMyRowCopy | ( | self, | |
| args | |||
| ) |
ExtractMyRowCopy(int myRow, int length, numpy.ndarray numEntries,
numpy.ndarray values, numpy.ndarray indices) -> int
In C++, numEntries in an int&. In python, it is provided to you as a
numpy array of length one so that you can set its value in-place using
numEntries[0] = ....
Arguments values and indices are double* and int*, respectively, in
C++. In python, these are provided to you as numpy arrays of the
given length, so that you may alter their entries in-place.
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
Reimplemented in PyTrilinos.NOX.Epetra.JadMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.Filled | ( | self, | |
| args | |||
| ) |
Filled(BasicRowMatrix self) -> bool
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.HasNormInf | ( | self, | |
| args | |||
| ) |
HasNormInf(BasicRowMatrix self) -> bool
Reimplemented from PyTrilinos.NOX.Epetra.Operator.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.Importer | ( | self, | |
| args | |||
| ) |
Importer(BasicRowMatrix self) -> Import
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.InvColSums | ( | self, | |
| args | |||
| ) |
InvColSums(Vector x) -> int Argument x is provided to you as a numpy-hybrid Epetra.Vector, giving you access to the numpy interface in addition to the Epetra_Vector C++ interface.
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.InvRowSums | ( | self, | |
| args | |||
| ) |
InvRowSums(Vector x) -> int Argument x is provided to you as a numpy-hybrid Epetra.Vector, giving you access to the numpy interface in addition to the Epetra_Vector C++ interface.
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.Label | ( | self, | |
| args | |||
| ) |
Label(BasicRowMatrix self) -> char const *
Reimplemented from PyTrilinos.NOX.Epetra.Object.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.LeftScale | ( | self, | |
| args | |||
| ) |
LeftScale(Vector x) -> int Argument x is provided to you as a numpy-hybrid Epetra.Vector, giving you access to the numpy interface in addition to the Epetra_Vector C++ interface.
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.LowerTriangular | ( | self, | |
| args | |||
| ) |
LowerTriangular(BasicRowMatrix self) -> bool
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.Map | ( | self, | |
| args | |||
| ) |
Map(BasicRowMatrix self) -> BlockMap
Reimplemented from PyTrilinos.NOX.Epetra.SrcDistObject.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.MaxNumEntries | ( | self, | |
| args | |||
| ) |
MaxNumEntries(BasicRowMatrix self) -> int
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.Multiply | ( | self, | |
| args | |||
| ) |
Multiply(bool useTranspose, MultiVector x, MultiVector y) -> int In C++, arguments x and y are Epetra_MultiVectors. In python, they are provided to you as numpy-hybrid Epetra.MultiVectors, giving you access to the numpy interface in addition to the Epetra_MultiVector C++ interface.
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
Reimplemented in PyTrilinos.NOX.Epetra.JadMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NormInf | ( | self, | |
| args | |||
| ) |
NormInf(BasicRowMatrix self) -> double
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NormOne | ( | self, | |
| args | |||
| ) |
NormOne(BasicRowMatrix self) -> double
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NumGlobalCols | ( | self, | |
| args | |||
| ) |
NumGlobalCols(BasicRowMatrix self) -> int
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NumGlobalCols64 | ( | self, | |
| args | |||
| ) |
NumGlobalCols64(BasicRowMatrix self) -> long long
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NumGlobalDiagonals | ( | self, | |
| args | |||
| ) |
NumGlobalDiagonals(BasicRowMatrix self) -> int
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NumGlobalDiagonals64 | ( | self, | |
| args | |||
| ) |
NumGlobalDiagonals64(BasicRowMatrix self) -> long long
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NumGlobalNonzeros | ( | self, | |
| args | |||
| ) |
NumGlobalNonzeros(BasicRowMatrix self) -> int
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NumGlobalNonzeros64 | ( | self, | |
| args | |||
| ) |
NumGlobalNonzeros64(BasicRowMatrix self) -> long long
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NumGlobalRows | ( | self, | |
| args | |||
| ) |
NumGlobalRows(BasicRowMatrix self) -> int
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NumGlobalRows64 | ( | self, | |
| args | |||
| ) |
NumGlobalRows64(BasicRowMatrix self) -> long long
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NumMyCols | ( | self, | |
| args | |||
| ) |
NumMyCols(BasicRowMatrix self) -> int
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NumMyDiagonals | ( | self, | |
| args | |||
| ) |
NumMyDiagonals(BasicRowMatrix self) -> int
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NumMyNonzeros | ( | self, | |
| args | |||
| ) |
NumMyNonzeros(BasicRowMatrix self) -> int
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NumMyRowEntries | ( | self, | |
| args | |||
| ) |
NumMyRowEntries(int myRow, numpy.ndarray numEntries) -> int In C++, numEntries in an int&. In python, it is provided to you as a numpy array of length one so that you can set its value in-place using numEntries[0] = ....
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
Reimplemented in PyTrilinos.NOX.Epetra.JadMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.NumMyRows | ( | self, | |
| args | |||
| ) |
NumMyRows(BasicRowMatrix self) -> int
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.OperatorDomainMap | ( | self, | |
| args | |||
| ) |
OperatorDomainMap(BasicRowMatrix self) -> Map
Reimplemented from PyTrilinos.NOX.Epetra.Operator.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.OperatorRangeMap | ( | self, | |
| args | |||
| ) |
OperatorRangeMap(BasicRowMatrix self) -> Map
Reimplemented from PyTrilinos.NOX.Epetra.Operator.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.RightScale | ( | self, | |
| args | |||
| ) |
RightScale(Vector x) -> int Argument x is provided to you as a numpy-hybrid Epetra.Vector, giving you access to the numpy interface in addition to the Epetra_Vector C++ interface.
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.RowMatrixColMap | ( | self, | |
| args | |||
| ) |
RowMatrixColMap(BasicRowMatrix self) -> Map
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.RowMatrixImporter | ( | self, | |
| args | |||
| ) |
RowMatrixImporter(BasicRowMatrix self) -> Import
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.RowMatrixRowMap | ( | self, | |
| args | |||
| ) |
RowMatrixRowMap(BasicRowMatrix self) -> Map
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.SetMaps | ( | self, | |
| args | |||
| ) |
SetMaps(BasicRowMatrix self, Map RowMap, Map ColMap) SetMaps(BasicRowMatrix self, Map RowMap, Map ColMap, Map DomainMap, Map RangeMap)
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.SetUseTranspose | ( | self, | |
| args | |||
| ) |
SetUseTranspose(BasicRowMatrix self, bool use_transpose) -> int
Reimplemented from PyTrilinos.NOX.Epetra.Operator.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.Solve | ( | self, | |
| args | |||
| ) |
Solve((bool upper, bool trans, bool unitDiagonal, MultiVector x,
MultiVector y) -> int
In C++, arguments x and y are Epetra_MultiVectors. In python, they
are provided to you as numpy-hybrid Epetra.MultiVectors, giving you
access to the numpy interface in addition to the Epetra_MultiVector
C++ interface.
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
Reimplemented in PyTrilinos.NOX.Epetra.JadMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.UpperTriangular | ( | self, | |
| args | |||
| ) |
UpperTriangular(BasicRowMatrix self) -> bool
Reimplemented from PyTrilinos.NOX.Epetra.RowMatrix.
| def PyTrilinos.NOX.Epetra.BasicRowMatrix.UseTranspose | ( | self, | |
| args | |||
| ) |
UseTranspose(BasicRowMatrix self) -> bool
Reimplemented from PyTrilinos.NOX.Epetra.Operator.
1.7.6.1