PyTrilinos::Epetra::CrsMatrix Class Reference

Inheritance diagram for PyTrilinos::Epetra::CrsMatrix:

Inheritance graph
[legend]
Collaboration diagram for PyTrilinos::Epetra::CrsMatrix:

Collaboration graph
[legend]

List of all members.

Public Member Functions

def PutScalar
def Scale
def ReplaceDiagonalValues
def FillComplete
def OptimizeStorage
def MakeDataContiguous
def ExtractDiagonalCopy
def Multiply
def Multiply1
def Solve
def InvRowSums
def InvRowMaxs
def LeftScale
def InvColSums
def InvColMaxs
def RightScale
def Filled
def StorageOptimized
def IndicesAreGlobal
def IndicesAreLocal
def IndicesAreContiguous
def LowerTriangular
def UpperTriangular
def NoDiagonal
def NormInf
def NormOne
def NormFrobenius
def NumGlobalNonzeros
def NumGlobalRows
def NumGlobalCols
def NumGlobalDiagonals
def NumMyNonzeros
def NumMyRows
def NumMyCols
def NumMyDiagonals
def NumGlobalEntries
def NumAllocatedGlobalEntries
def MaxNumEntries
def GlobalMaxNumEntries
def NumMyEntries
def NumAllocatedMyEntries
def IndexBase
def StaticGraph
def Graph
def RowMap
def ReplaceRowMap
def HaveColMap
def ReplaceColMap
def ColMap
def DomainMap
def RangeMap
def Importer
def Exporter
def Comm
def LRID
def GRID
def LCID
def GCID
def MyGRID
def MyLRID
def MyGCID
def MyLCID
def MyGlobalRow
def Label
def SetUseTranspose
def Apply
def ApplyInverse
def HasNormInf
def UseTranspose
def OperatorDomainMap
def OperatorRangeMap
def NumMyRowEntries
def RowMatrixRowMap
def RowMatrixColMap
def RowMatrixImporter
def SortGhostsAssociatedWithEachProcessor
def ImportMap
def TransformToLocal
def InsertGlobalValues
def ReplaceGlobalValues
def SumIntoGlobalValues
def InsertMyValues
def ReplaceMyValues
def SumIntoMyValues
def __init__
def ExtractGlobalRowCopy
def ExtractMyRowCopy
def __setitem__
def __getitem__
def PutScalar
def Scale
def ReplaceDiagonalValues
def FillComplete
def OptimizeStorage
def MakeDataContiguous
def ExtractDiagonalCopy
def Multiply
def Multiply1
def Solve
def InvRowSums
def InvRowMaxs
def LeftScale
def InvColSums
def InvColMaxs
def RightScale
def Filled
def StorageOptimized
def IndicesAreGlobal
def IndicesAreLocal
def IndicesAreContiguous
def LowerTriangular
def UpperTriangular
def NoDiagonal
def NormInf
def NormOne
def NormFrobenius
def NumGlobalNonzeros
def NumGlobalRows
def NumGlobalCols
def NumGlobalDiagonals
def NumMyNonzeros
def NumMyRows
def NumMyCols
def NumMyDiagonals
def NumGlobalEntries
def NumAllocatedGlobalEntries
def MaxNumEntries
def GlobalMaxNumEntries
def NumMyEntries
def NumAllocatedMyEntries
def IndexBase
def StaticGraph
def Graph
def RowMap
def ReplaceRowMap
def HaveColMap
def ReplaceColMap
def ColMap
def DomainMap
def RangeMap
def Importer
def Exporter
def Comm
def LRID
def GRID
def LCID
def GCID
def MyGRID
def MyLRID
def MyGCID
def MyLCID
def MyGlobalRow
def Label
def SetUseTranspose
def Apply
def ApplyInverse
def HasNormInf
def UseTranspose
def OperatorDomainMap
def OperatorRangeMap
def NumMyRowEntries
def RowMatrixRowMap
def RowMatrixColMap
def RowMatrixImporter
def SortGhostsAssociatedWithEachProcessor
def ImportMap
def TransformToLocal
def InsertGlobalValues
def ReplaceGlobalValues
def SumIntoGlobalValues
def InsertMyValues
def ReplaceMyValues
def SumIntoMyValues
def __init__
def ExtractGlobalRowCopy
def ExtractMyRowCopy
def __setitem__
def __getitem__

Public Attributes

 this


Detailed Description

Epetra_CrsMatrix: A class for constructing and using real-valued
double-precision sparse compressed row matrices.

The Epetra_CrsMatrix class is a sparse compressed row matrix object.
This matrix can be used in a parallel setting, with data distribution
described by Epetra_Map attributes. The structure or graph of the
matrix is defined by an Epetra_CrsGraph attribute.

In addition to coefficient access, the primary operations provided by
Epetra_CrsMatrix are matrix times vector and matrix times multi-vector
multiplication.

Epetra_CrsMatrix matrices can be square or rectangular.

Creating and filling Epetra_CrsMatrix objects

Constructing Epetra_CrsMatrix objects is a multi-step process. The
basic steps are as follows: Create Epetra_CrsMatrix instance,
including storage, via one of the constructors: Constructor that
accepts one Epetra_Map object, a row-map defining the distribution of
matrix rows.

Constructor that accepts two Epetra_Map objects. (The second map is a
column-map, and describes the set of column-indices that appear in
each processor's portion of the matrix. Generally these are
overlapping sets -- column-indices may appear on more than one
processor.)

Constructor that accepts an Epetra_CrsGraph object, defining the non-
zero structure of the matrix.  Note that the constructors which accept
Epetra_Map arguments also accept an argument that gives an estimate of
the number of nonzeros per row. This allows storage to be pre-
allocated and can improve the performance of the data input methods.
The estimate need not be accurate, as additional storage is allocated
automatically when needed. However, a more accurate estimate helps
performance by reducing the amount of extra memory allocation.

Enter values via one or more Insert/Replace/SumInto functions.

Complete construction by calling FillComplete.

Note that, even after a matrix is constructed (FillComplete has been
called), it is possible to update existing matrix entries. It is not
possible to create new entries.

Epetra_Map attributes

Epetra_CrsMatrix objects have four Epetra_Map attributes, which are
held by the Epetra_CrsGraph attribute.

The Epetra_Map attributes can be obtained via these accessor methods:
RowMap() Describes the numbering and distribution of the rows of the
matrix. The row-map exists and is valid for the entire life of the
matrix. The set of matrix rows is defined by the row-map and may not
be changed. Rows may not be inserted or deleted by the user. The only
change that may be made is that the user can replace the row-map with
a compatible row-map (which is the same except for re-numbering) by
calling the ReplaceRowMap() method.

ColMap() Describes the set of column-indices that appear in the rows
in each processor's portion of the matrix. Unless provided by the user
at construction time, a valid column-map doesn't exist until
FillComplete() is called.

RangeMap() Describes the range of the matrix operator. e.g., for a
matrix-vector product operation, the result vector's map must be
compatible with the range-map of this matrix. The range-map is usually
the same as the row-map. The range-map is set equal to the row-map at
matrix creation time, but may be specified by the user when
FillComplete() is called.

DomainMap() Describes the domain of the matrix operator. The domain-
map can be specified by the user when FillComplete() is called. Until
then, it is set equal to the row-map.

It is important to note that while the row-map and the range-map are
often the same, the column-map and the domain-map are almost never the
same. The set of entries in a distributed column-map almost always
form overlapping sets, with entries being associated with more than
one processor. A domain-map, on the other hand, must be a 1-to-1 map,
with entries being associated with only a single processor.

Local versus Global Indices

Epetra_CrsMatrix has query functions IndicesAreLocal() and
IndicesAreGlobal(), which are used to determine whether the underlying
Epetra_CrsGraph attribute's column-indices have been transformed into
a local index space or not. (This transformation occurs when the
method Epetra_CrsGraph::FillComplete() is called, which happens when
the method Epetra_CrsMatrix::FillComplete() is called.) The state of
the indices in the graph determines the behavior of many
Epetra_CrsMatrix methods. If an Epetra_CrsMatrix instance is
constructed using one of the constructors that does not accept a pre-
existing Epetra_CrsGraph object, then an Epetra_CrsGraph attribute is
created internally and its indices remain untransformed (
IndicesAreGlobal()==true) until Epetra_CrsMatrix::FillComplete() is
called. The query function Epetra_CrsMatrix::Filled() returns true if
Epetra_CrsMatrix::FillComplete() has been called.

Note the following method characteristics:

InsertGlobalValues() may only be used to insert new nonzeros in the
matrix if indices are global.

SumIntoGlobalValues() may be used regardless of whether indices are
global or local, but can only be used to update matrix locations that
already exist; it can never be used to establish new nonzero
locations.

ReplaceGlobalValues() may also be used only to update matrix locations
that already exist, and works regardless of whether indices are local
or global.

SumIntoMyValues() and ReplaceMyValues() may only be used if indices
are local.

Multiply() may only be used after FillComplete() has been called.

Most methods have preconditions documented, check documentation for
specific methods not mentioned here.

Counting Floating Point Operations

Each Epetra_CrsMatrix object keeps track of the number of serial
floating point operations performed using the specified object as the
this argument to the function. The Flops() function returns this
number as a double precision number. Using this information, in
conjunction with the Epetra_Time class, one can get accurate parallel
performance numbers. The ResetFlops() function resets the floating
point counter.

WARNING:  A Epetra_Map is required for the Epetra_CrsMatrix
constructor.

C++ includes: Epetra_CrsMatrix.h 

Member Function Documentation

def PyTrilinos::Epetra::CrsMatrix::__getitem__ (   self,
  args 
)

__getitem__(self, PyTuple index) -> double
__getitem__(self, int row) -> numpy.ndarray

The __getitem__() method is called when square-bracket indexing is
used to get a value from the matrix.  For example, the last two lines
of::

    comm = Epetra.SerialComm()
    m = Epetra.CrsMatrix(9,0,comm)
    m.InsertGlobalValues(0, [0.0, 1.0, 2.0], [0,1,2])
    diag = m[0,0]
    row  = m[0]

call::

    m.__getitem__((0,0))
    m.__getitem__(0)

The __getitem__() method behaves according to the following table:

            FillComplete()    #    
    Index               called      procs  Return value
    --------------  --------------  -----  ---------------------------
    single integer       true        any   numpy array of doubles
    single integer       false        1    numpy array of doubles
    single integer       false       >1    raise IndexError
    two integers         either      any   double

You should provide global IDs as the integer indices if FillComplete()
has been called.  If not, you should provide local IDs.  If you
reference a matrix element that is off-processor, __getitem__() will
raise an IndexError.

Under the covers, __getitem__() will call ExtractGlobalRowView() if
FillComplete() has been called, or ExtractMyRowView() if it has not.
If either of these return a non-zero return code, this is converted to
a python RuntimeError.  The resulting data is copied to the output
array.

Reimplemented in PyTrilinos::Epetra::FECrsMatrix, and PyTrilinos::Epetra::FECrsMatrix.

def PyTrilinos::Epetra::CrsMatrix::__getitem__ (   self,
  args 
)

__getitem__(self, PyTuple index) -> double
__getitem__(self, int row) -> numpy.ndarray

The __getitem__() method is called when square-bracket indexing is
used to get a value from the matrix.  For example, the last two lines
of::

    comm = Epetra.SerialComm()
    m = Epetra.CrsMatrix(9,0,comm)
    m.InsertGlobalValues(0, [0.0, 1.0, 2.0], [0,1,2])
    diag = m[0,0]
    row  = m[0]

call::

    m.__getitem__((0,0))
    m.__getitem__(0)

The __getitem__() method behaves according to the following table:

            FillComplete()    #    
    Index               called      procs  Return value
    --------------  --------------  -----  ---------------------------
    single integer       true        any   numpy array of doubles
    single integer       false        1    numpy array of doubles
    single integer       false       >1    raise IndexError
    two integers         either      any   double

You should provide global IDs as the integer indices if FillComplete()
has been called.  If not, you should provide local IDs.  If you
reference a matrix element that is off-processor, __getitem__() will
raise an IndexError.

Under the covers, __getitem__() will call ExtractGlobalRowView() if
FillComplete() has been called, or ExtractMyRowView() if it has not.
If either of these return a non-zero return code, this is converted to
a python RuntimeError.  The resulting data is copied to the output
array.

Reimplemented in PyTrilinos::Epetra::FECrsMatrix, and PyTrilinos::Epetra::FECrsMatrix.

def PyTrilinos::Epetra::CrsMatrix::__init__ (   self,
  args 
)

__init__(self, Epetra_DataAccess CV, Map rowMap, int numEntriesPerRow, 
    bool staticProfile=False) -> CrsMatrix

  CrsMatrix constructor with implicit column map and constant number
  of entries per row.  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - describes distribution of rows across processors
    numEntriesPerRow  - constant number of entries per row
    staticProfile     - static profile flag

__init__(self, Epetra_DataAccess CV, Map rowMap, Map colMap, int numEntriesPerRow, 
    bool staticProfile=False) -> CrsMatrix

  CrsMatrix constructor with specified column map and constant number
  of entries per row.  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - describes distribution of rows across processors
    colMap            - describes distribution of columns across processors
    numEntriesPerRow  - constant number of entries per row
    staticProfile     - static profile flag

__init__(self, Epetra_DataAccess CV, CrsGraph graph) -> CrsMatrix

  CrsMatrix constructor with CrsGraph.  Arguments:

    CV     - Epetra.Copy or Epetra.View
    graph  - CrsGraph describing structure of matrix

__init__(self, CrsMatrix matrix) -> CrsMatrix

  CrsMatrix copy constructor.  Argument:

    matrix  - source CrsMatrix

__init__(self, Epetra_DataAccess CV, Map rowMap, PySequence numEntriesPerRow, 
    bool staticProfile=False) -> CrsMatrix

  CrsMatrix constructor with implicit column map and variable number
  of entries per row.  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - describes distribution of rows across processors
    numEntriesPerRow  - variable number of entries per row
    staticProfile     - static profile flag

__init__(self, Epetra_DataAccess CV, Map rowMap, Map colMap, PySequence
    numEntriesPerRow, bool staticProfile=False) -> CrsMatrix

  CrsMatrix constructor with specified column map and variable number
  of entries per row.  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - describes distribution of rows across processors
    colMap            - describes distribution of columns across processors
    numEntriesPerRow  - variable number of entries per row
    staticProfile     - static profile flag


Epetra_CrsMatrix::Epetra_CrsMatrix(const Epetra_CrsMatrix &Matrix)

Copy constructor. 

Reimplemented from PyTrilinos::Epetra::CompObject.

Reimplemented in PyTrilinos::Epetra::FECrsMatrix, and PyTrilinos::Epetra::FECrsMatrix.

def PyTrilinos::Epetra::CrsMatrix::__init__ (   self,
  args 
)

__init__(self, Epetra_DataAccess CV, Map rowMap, int numEntriesPerRow, 
    bool staticProfile=False) -> CrsMatrix

  CrsMatrix constructor with implicit column map and constant number
  of entries per row.  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - describes distribution of rows across processors
    numEntriesPerRow  - constant number of entries per row
    staticProfile     - static profile flag

__init__(self, Epetra_DataAccess CV, Map rowMap, Map colMap, int numEntriesPerRow, 
    bool staticProfile=False) -> CrsMatrix

  CrsMatrix constructor with specified column map and constant number
  of entries per row.  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - describes distribution of rows across processors
    colMap            - describes distribution of columns across processors
    numEntriesPerRow  - constant number of entries per row
    staticProfile     - static profile flag

__init__(self, Epetra_DataAccess CV, CrsGraph graph) -> CrsMatrix

  CrsMatrix constructor with CrsGraph.  Arguments:

    CV     - Epetra.Copy or Epetra.View
    graph  - CrsGraph describing structure of matrix

__init__(self, CrsMatrix matrix) -> CrsMatrix

  CrsMatrix copy constructor.  Argument:

    matrix  - source CrsMatrix

__init__(self, Epetra_DataAccess CV, Map rowMap, PySequence numEntriesPerRow, 
    bool staticProfile=False) -> CrsMatrix

  CrsMatrix constructor with implicit column map and variable number
  of entries per row.  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - describes distribution of rows across processors
    numEntriesPerRow  - variable number of entries per row
    staticProfile     - static profile flag

__init__(self, Epetra_DataAccess CV, Map rowMap, Map colMap, PySequence
    numEntriesPerRow, bool staticProfile=False) -> CrsMatrix

  CrsMatrix constructor with specified column map and variable number
  of entries per row.  Arguments:

    CV                - Epetra.Copy or Epetra.View
    rowMap            - describes distribution of rows across processors
    colMap            - describes distribution of columns across processors
    numEntriesPerRow  - variable number of entries per row
    staticProfile     - static profile flag


Epetra_CrsMatrix::Epetra_CrsMatrix(const Epetra_CrsMatrix &Matrix)

Copy constructor. 

Reimplemented from PyTrilinos::Epetra::CompObject.

Reimplemented in PyTrilinos::Epetra::FECrsMatrix, and PyTrilinos::Epetra::FECrsMatrix.

def PyTrilinos::Epetra::CrsMatrix::__setitem__ (   self,
  args 
)

__setitem__(self, PyTuple index, double val)

The __setitem__() method is called when square-bracket indexing is
used to set a value of the matrix.  For example, the last line of::

    comm = Epetra.SerialComm()
    m = Epetra.CrsMatrix(9,0,comm)
    m[0,0] = 3.14

calls::

    m.__setitem__((0,0), 3.14)

Thus, argument 'index' is a tuple filled with whatever indices you
give the square-bracket operator when setting.  For __setitem__(),
this raises an IndexError unless 'index' is a two-tuple of integers.
Argument 'val' must be convertible to a double.  Under the covers,
__setitem__() calls ReplaceGlobalValues() or InsertGlobalValues() as
necessary, so the indices are expected to be global IDs.  Note that if
you use __setitem__() to insert a new matrix element, you will need to
call FillComplete() again, whether or not you have called it before.

Reimplemented in PyTrilinos::Epetra::FECrsMatrix, and PyTrilinos::Epetra::FECrsMatrix.

def PyTrilinos::Epetra::CrsMatrix::__setitem__ (   self,
  args 
)

__setitem__(self, PyTuple index, double val)

The __setitem__() method is called when square-bracket indexing is
used to set a value of the matrix.  For example, the last line of::

    comm = Epetra.SerialComm()
    m = Epetra.CrsMatrix(9,0,comm)
    m[0,0] = 3.14

calls::

    m.__setitem__((0,0), 3.14)

Thus, argument 'index' is a tuple filled with whatever indices you
give the square-bracket operator when setting.  For __setitem__(),
this raises an IndexError unless 'index' is a two-tuple of integers.
Argument 'val' must be convertible to a double.  Under the covers,
__setitem__() calls ReplaceGlobalValues() or InsertGlobalValues() as
necessary, so the indices are expected to be global IDs.  Note that if
you use __setitem__() to insert a new matrix element, you will need to
call FillComplete() again, whether or not you have called it before.

Reimplemented in PyTrilinos::Epetra::FECrsMatrix, and PyTrilinos::Epetra::FECrsMatrix.

def PyTrilinos::Epetra::CrsMatrix::Apply (   self,
  args 
)

Apply(self, Epetra_MultiVector X, Epetra_MultiVector Y) -> int

int
Epetra_CrsMatrix::Apply(const Epetra_MultiVector &X,
Epetra_MultiVector &Y) const

Returns the result of a Epetra_Operator applied to a
Epetra_MultiVector X in Y.

Parameters:
-----------

X:  - (In) An Epetra_MultiVector of dimension NumVectors to multiply
with matrix.

Y:  -(Out) An Epetra_MultiVector of dimension NumVectors containing
result.

Integer error code, set to 0 if successful.

Filled()==true

Unchanged. 

Reimplemented from PyTrilinos::Epetra::Operator.

def PyTrilinos::Epetra::CrsMatrix::Apply (   self,
  args 
)

Apply(self, Epetra_MultiVector X, Epetra_MultiVector Y) -> int

int
Epetra_CrsMatrix::Apply(const Epetra_MultiVector &X,
Epetra_MultiVector &Y) const

Returns the result of a Epetra_Operator applied to a
Epetra_MultiVector X in Y.

Parameters:
-----------

X:  - (In) An Epetra_MultiVector of dimension NumVectors to multiply
with matrix.

Y:  -(Out) An Epetra_MultiVector of dimension NumVectors containing
result.

Integer error code, set to 0 if successful.

Filled()==true

Unchanged. 

Reimplemented from PyTrilinos::Epetra::Operator.

def PyTrilinos::Epetra::CrsMatrix::ApplyInverse (   self,
  args 
)

ApplyInverse(self, Epetra_MultiVector X, Epetra_MultiVector Y) -> int

int
Epetra_CrsMatrix::ApplyInverse(const Epetra_MultiVector &X,
Epetra_MultiVector &Y) const

Returns the result of a Epetra_Operator inverse applied to an
Epetra_MultiVector X in Y.

In this implementation, we use several existing attributes to
determine how virtual method ApplyInverse() should call the concrete
method Solve(). We pass in the UpperTriangular(), the
Epetra_CrsMatrix::UseTranspose(), and NoDiagonal() methods. The most
notable warning is that if a matrix has no diagonal values we assume
that there is an implicit unit diagonal that should be accounted for
when doing a triangular solve.

Parameters:
-----------

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.

Filled()==true

Unchanged. 

Reimplemented from PyTrilinos::Epetra::Operator.

def PyTrilinos::Epetra::CrsMatrix::ApplyInverse (   self,
  args 
)

ApplyInverse(self, Epetra_MultiVector X, Epetra_MultiVector Y) -> int

int
Epetra_CrsMatrix::ApplyInverse(const Epetra_MultiVector &X,
Epetra_MultiVector &Y) const

Returns the result of a Epetra_Operator inverse applied to an
Epetra_MultiVector X in Y.

In this implementation, we use several existing attributes to
determine how virtual method ApplyInverse() should call the concrete
method Solve(). We pass in the UpperTriangular(), the
Epetra_CrsMatrix::UseTranspose(), and NoDiagonal() methods. The most
notable warning is that if a matrix has no diagonal values we assume
that there is an implicit unit diagonal that should be accounted for
when doing a triangular solve.

Parameters:
-----------

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.

Filled()==true

Unchanged. 

Reimplemented from PyTrilinos::Epetra::Operator.

def PyTrilinos::Epetra::CrsMatrix::ColMap (   self,
  args 
)

ColMap(self) -> Map

const Epetra_Map&
Epetra_CrsMatrix::ColMap() const

Returns the Epetra_Map object that describes the set of column-indices
that appear in each processor's locally owned matrix rows.

Note that if the matrix was constructed with only a row-map, then
until FillComplete() is called, this method returns a column-map that
is a copy of the row-map. That 'initial' column-map is replaced with a
computed column- map (that contains the set of column-indices
appearing in each processor's local portion of the matrix) when
FillComplete() is called.

HaveColMap()==true 

def PyTrilinos::Epetra::CrsMatrix::ColMap (   self,
  args 
)

ColMap(self) -> Map

const Epetra_Map&
Epetra_CrsMatrix::ColMap() const

Returns the Epetra_Map object that describes the set of column-indices
that appear in each processor's locally owned matrix rows.

Note that if the matrix was constructed with only a row-map, then
until FillComplete() is called, this method returns a column-map that
is a copy of the row-map. That 'initial' column-map is replaced with a
computed column- map (that contains the set of column-indices
appearing in each processor's local portion of the matrix) when
FillComplete() is called.

HaveColMap()==true 

def PyTrilinos::Epetra::CrsMatrix::Comm (   self,
  args 
)

Comm(self) -> Comm

const Epetra_Comm&
Epetra_CrsMatrix::Comm() const

Returns a pointer to the Epetra_Comm communicator associated with this
matrix. 

Reimplemented from PyTrilinos::Epetra::DistObject.

def PyTrilinos::Epetra::CrsMatrix::Comm (   self,
  args 
)

Comm(self) -> Comm

const Epetra_Comm&
Epetra_CrsMatrix::Comm() const

Returns a pointer to the Epetra_Comm communicator associated with this
matrix. 

Reimplemented from PyTrilinos::Epetra::DistObject.

def PyTrilinos::Epetra::CrsMatrix::DomainMap (   self,
  args 
)

DomainMap(self) -> Map

const Epetra_Map&
Epetra_CrsMatrix::DomainMap() const

Returns the Epetra_Map object associated with the domain of this
matrix operator.

Filled()==true 

def PyTrilinos::Epetra::CrsMatrix::DomainMap (   self,
  args 
)

DomainMap(self) -> Map

const Epetra_Map&
Epetra_CrsMatrix::DomainMap() const

Returns the Epetra_Map object associated with the domain of this
matrix operator.

Filled()==true 

def PyTrilinos::Epetra::CrsMatrix::Exporter (   self,
  args 
)

Exporter(self) -> Export

const
Epetra_Export* Epetra_CrsMatrix::Exporter() const

Returns the Epetra_Export object that contains the export operations
for distributed operations. 

def PyTrilinos::Epetra::CrsMatrix::Exporter (   self,
  args 
)

Exporter(self) -> Export

const
Epetra_Export* Epetra_CrsMatrix::Exporter() const

Returns the Epetra_Export object that contains the export operations
for distributed operations. 

def PyTrilinos::Epetra::CrsMatrix::ExtractDiagonalCopy (   self,
  args 
)

ExtractDiagonalCopy(self, Epetra_Vector Diagonal) -> int

int
Epetra_CrsMatrix::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.

Filled()==true

Unchanged. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::ExtractDiagonalCopy (   self,
  args 
)

ExtractDiagonalCopy(self, Epetra_Vector Diagonal) -> int

int
Epetra_CrsMatrix::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.

Filled()==true

Unchanged. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::ExtractGlobalRowCopy (   self,
  args 
)

ExtractGlobalRowCopy(self, int globalRow) -> (numpy.ndarray,numpy.ndarray)

  Returns a two-tuple of numpy arrays of the same size; the first is
  an array of integers that represent the nonzero columns on the
  matrix; the second is an array of doubles that represent the values
  of the matrix entries.  The input argument is a global row index.

int
Epetra_CrsMatrix::ExtractGlobalRowCopy(int GlobalRow, int Length, int
&NumEntries, double *Values) const

Returns a copy of the specified global row values in user-provided
array.

Parameters:
-----------

GlobalRow:  - (In) Global row to extract.

Length:  - (In) Length of Values.

NumEntries:  - (Out) Number of nonzero entries extracted.

Values:  - (Out) Extracted values for this row.

Integer error code, set to 0 if successful. 

def PyTrilinos::Epetra::CrsMatrix::ExtractGlobalRowCopy (   self,
  args 
)

ExtractGlobalRowCopy(self, int globalRow) -> (numpy.ndarray,numpy.ndarray)

  Returns a two-tuple of numpy arrays of the same size; the first is
  an array of integers that represent the nonzero columns on the
  matrix; the second is an array of doubles that represent the values
  of the matrix entries.  The input argument is a global row index.

int
Epetra_CrsMatrix::ExtractGlobalRowCopy(int GlobalRow, int Length, int
&NumEntries, double *Values) const

Returns a copy of the specified global row values in user-provided
array.

Parameters:
-----------

GlobalRow:  - (In) Global row to extract.

Length:  - (In) Length of Values.

NumEntries:  - (Out) Number of nonzero entries extracted.

Values:  - (Out) Extracted values for this row.

Integer error code, set to 0 if successful. 

def PyTrilinos::Epetra::CrsMatrix::ExtractMyRowCopy (   self,
  args 
)

ExtractMyRowCopy(self, int myRow) -> (numpy.ndarray,numpy.ndarray)

  Returns a two-tuple of numpy arrays of the same size; the first is
  an array of integers that represent the nonzero columns on the
  matrix; the second is an array of doubles that represent the values
  of the matrix entries.  The input argument is a local row index.

int
Epetra_CrsMatrix::ExtractMyRowCopy(int MyRow, int Length, int
&NumEntries, double *Values) const

Returns a copy of the specified local row values in user-provided
array.

Parameters:
-----------

MyRow:  - (In) Local row to extract.

Length:  - (In) Length of Values.

NumEntries:  - (Out) Number of nonzero entries extracted.

Values:  - (Out) Extracted values for this row.

Integer error code, set to 0 if successful. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::ExtractMyRowCopy (   self,
  args 
)

ExtractMyRowCopy(self, int myRow) -> (numpy.ndarray,numpy.ndarray)

  Returns a two-tuple of numpy arrays of the same size; the first is
  an array of integers that represent the nonzero columns on the
  matrix; the second is an array of doubles that represent the values
  of the matrix entries.  The input argument is a local row index.

int
Epetra_CrsMatrix::ExtractMyRowCopy(int MyRow, int Length, int
&NumEntries, double *Values) const

Returns a copy of the specified local row values in user-provided
array.

Parameters:
-----------

MyRow:  - (In) Local row to extract.

Length:  - (In) Length of Values.

NumEntries:  - (Out) Number of nonzero entries extracted.

Values:  - (Out) Extracted values for this row.

Integer error code, set to 0 if successful. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::FillComplete (   self,
  args 
)

FillComplete(self, bool OptimizeDataStorage = True) -> int
FillComplete(self, Map DomainMap, Map RangeMap, bool OptimizeDataStorage = True) -> int

int
Epetra_CrsMatrix::FillComplete(const Epetra_Map &DomainMap, const
Epetra_Map &RangeMap, bool OptimizeDataStorage=true)

Signal that data entry is complete. Perform transformations to local
index space. 

def PyTrilinos::Epetra::CrsMatrix::FillComplete (   self,
  args 
)

FillComplete(self, bool OptimizeDataStorage = True) -> int
FillComplete(self, Map DomainMap, Map RangeMap, bool OptimizeDataStorage = True) -> int

int
Epetra_CrsMatrix::FillComplete(const Epetra_Map &DomainMap, const
Epetra_Map &RangeMap, bool OptimizeDataStorage=true)

Signal that data entry is complete. Perform transformations to local
index space. 

def PyTrilinos::Epetra::CrsMatrix::Filled (   self,
  args 
)

Filled(self) -> bool

bool
Epetra_CrsMatrix::Filled() const

If FillComplete() has been called, this query returns true, otherwise
it returns false. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::Filled (   self,
  args 
)

Filled(self) -> bool

bool
Epetra_CrsMatrix::Filled() const

If FillComplete() has been called, this query returns true, otherwise
it returns false. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::GCID (   self,
  args 
)

GCID(self, int LCID_in) -> int

int
Epetra_CrsMatrix::GCID(int LCID_in) const

Returns the global column index for give local column index, returns
IndexBase-1 if we don't have this local column.

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsMatrix::GCID (   self,
  args 
)

GCID(self, int LCID_in) -> int

int
Epetra_CrsMatrix::GCID(int LCID_in) const

Returns the global column index for give local column index, returns
IndexBase-1 if we don't have this local column.

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsMatrix::GlobalMaxNumEntries (   self,
  args 
)

GlobalMaxNumEntries(self) -> int

int
Epetra_CrsMatrix::GlobalMaxNumEntries() const

Returns the maximum number of nonzero entries across all rows on all
processors.

Filled()==true 

def PyTrilinos::Epetra::CrsMatrix::GlobalMaxNumEntries (   self,
  args 
)

GlobalMaxNumEntries(self) -> int

int
Epetra_CrsMatrix::GlobalMaxNumEntries() const

Returns the maximum number of nonzero entries across all rows on all
processors.

Filled()==true 

def PyTrilinos::Epetra::CrsMatrix::Graph (   self,
  args 
)

Graph(self) -> CrsGraph

const
Epetra_CrsGraph& Epetra_CrsMatrix::Graph() const

Returns a reference to the Epetra_CrsGraph object associated with this
matrix. 

def PyTrilinos::Epetra::CrsMatrix::Graph (   self,
  args 
)

Graph(self) -> CrsGraph

const
Epetra_CrsGraph& Epetra_CrsMatrix::Graph() const

Returns a reference to the Epetra_CrsGraph object associated with this
matrix. 

def PyTrilinos::Epetra::CrsMatrix::GRID (   self,
  args 
)

GRID(self, int LRID_in) -> int

int
Epetra_CrsMatrix::GRID(int LRID_in) const

Returns the global row index for give local row index, returns
IndexBase-1 if we don't have this local row. 

def PyTrilinos::Epetra::CrsMatrix::GRID (   self,
  args 
)

GRID(self, int LRID_in) -> int

int
Epetra_CrsMatrix::GRID(int LRID_in) const

Returns the global row index for give local row index, returns
IndexBase-1 if we don't have this local row. 

def PyTrilinos::Epetra::CrsMatrix::HasNormInf (   self,
  args 
)

HasNormInf(self) -> bool

bool
Epetra_CrsMatrix::HasNormInf() const

Returns true because this class can compute an Inf-norm. 

Reimplemented from PyTrilinos::Epetra::Operator.

def PyTrilinos::Epetra::CrsMatrix::HasNormInf (   self,
  args 
)

HasNormInf(self) -> bool

bool
Epetra_CrsMatrix::HasNormInf() const

Returns true because this class can compute an Inf-norm. 

Reimplemented from PyTrilinos::Epetra::Operator.

def PyTrilinos::Epetra::CrsMatrix::HaveColMap (   self,
  args 
)

HaveColMap(self) -> bool

bool
Epetra_CrsMatrix::HaveColMap() const

Returns true if we have a well-defined ColMap, and returns false
otherwise.

We have a well-defined ColMap if a) a ColMap was passed in at
construction, or b) the MakeColMap function has been called. (Calling
either of the FillComplete functions will result in MakeColMap being
called.) 

def PyTrilinos::Epetra::CrsMatrix::HaveColMap (   self,
  args 
)

HaveColMap(self) -> bool

bool
Epetra_CrsMatrix::HaveColMap() const

Returns true if we have a well-defined ColMap, and returns false
otherwise.

We have a well-defined ColMap if a) a ColMap was passed in at
construction, or b) the MakeColMap function has been called. (Calling
either of the FillComplete functions will result in MakeColMap being
called.) 

def PyTrilinos::Epetra::CrsMatrix::Importer (   self,
  args 
)

Importer(self) -> Import

const
Epetra_Import* Epetra_CrsMatrix::Importer() const

Returns the Epetra_Import object that contains the import operations
for distributed operations. 

def PyTrilinos::Epetra::CrsMatrix::Importer (   self,
  args 
)

Importer(self) -> Import

const
Epetra_Import* Epetra_CrsMatrix::Importer() const

Returns the Epetra_Import object that contains the import operations
for distributed operations. 

def PyTrilinos::Epetra::CrsMatrix::ImportMap (   self,
  args 
)

ImportMap(self) -> Map

const Epetra_Map&
Epetra_CrsMatrix::ImportMap() const

Use ColMap() instead. 

def PyTrilinos::Epetra::CrsMatrix::ImportMap (   self,
  args 
)

ImportMap(self) -> Map

const Epetra_Map&
Epetra_CrsMatrix::ImportMap() const

Use ColMap() instead. 

def PyTrilinos::Epetra::CrsMatrix::IndexBase (   self,
  args 
)

IndexBase(self) -> int

int
Epetra_CrsMatrix::IndexBase() const

Returns the index base for row and column indices for this graph. 

def PyTrilinos::Epetra::CrsMatrix::IndexBase (   self,
  args 
)

IndexBase(self) -> int

int
Epetra_CrsMatrix::IndexBase() const

Returns the index base for row and column indices for this graph. 

def PyTrilinos::Epetra::CrsMatrix::IndicesAreContiguous (   self,
  args 
)

IndicesAreContiguous(self) -> bool

bool
Epetra_CrsMatrix::IndicesAreContiguous() const

If matrix indices are packed into single array (done in
OptimizeStorage()) return true, otherwise false. 

def PyTrilinos::Epetra::CrsMatrix::IndicesAreContiguous (   self,
  args 
)

IndicesAreContiguous(self) -> bool

bool
Epetra_CrsMatrix::IndicesAreContiguous() const

If matrix indices are packed into single array (done in
OptimizeStorage()) return true, otherwise false. 

def PyTrilinos::Epetra::CrsMatrix::IndicesAreGlobal (   self,
  args 
)

IndicesAreGlobal(self) -> bool

bool
Epetra_CrsMatrix::IndicesAreGlobal() const

If matrix indices has not been transformed to local, this query
returns true, otherwise it returns false. 

def PyTrilinos::Epetra::CrsMatrix::IndicesAreGlobal (   self,
  args 
)

IndicesAreGlobal(self) -> bool

bool
Epetra_CrsMatrix::IndicesAreGlobal() const

If matrix indices has not been transformed to local, this query
returns true, otherwise it returns false. 

def PyTrilinos::Epetra::CrsMatrix::IndicesAreLocal (   self,
  args 
)

IndicesAreLocal(self) -> bool

bool
Epetra_CrsMatrix::IndicesAreLocal() const

If matrix indices has been transformed to local, this query returns
true, otherwise it returns false. 

def PyTrilinos::Epetra::CrsMatrix::IndicesAreLocal (   self,
  args 
)

IndicesAreLocal(self) -> bool

bool
Epetra_CrsMatrix::IndicesAreLocal() const

If matrix indices has been transformed to local, this query returns
true, otherwise it returns false. 

def PyTrilinos::Epetra::CrsMatrix::InsertGlobalValues (   self,
  args 
)

InsertGlobalValues(self, int globalRow, PySequence values, PySequence
    indices) -> int

  Arguments:

    globalRow - global row index
    values    - a sequence of doubles that represent the values to insert
    indices   - a sequence of integers that represent the indices to insert

InsertGlobalValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to insert
    cols    - a sequence of integers that represent the column indices to
      insert
    values  - a sequence of doubles that represent the values to insert


int
Epetra_CrsMatrix::InsertGlobalValues(int GlobalRow, int NumEntries,
double *Values, int *Indices)

Insert a list of elements in a given global row of the matrix.

This method is used to construct a matrix for the first time. It
cannot be used if the matrix structure has already been fixed (via a
call to FillComplete()). If multiple values are inserted for the same
matrix entry, the values are initially stored separately, so memory
use will grow as a result. However, when FillComplete is called the
values will be summed together and the additional memory will be
released.

For example, if the values 2.0, 3.0 and 4.0 are all inserted in Row 1,
Column 2, extra storage is used to store each of the three values
separately. In this way, the insert process does not require any
searching and can be faster. However, when FillComplete() is called,
the values will be summed together to equal 9.0 and only a single
entry will remain in the matrix for Row 1, Column 2.

Parameters:
-----------

GlobalRow:  - (In) Row number (in global coordinates) to put elements.

NumEntries:  - (In) Number of entries.

Values:  - (In) Values to enter.

Indices:  - (In) Global column indices corresponding to values.

Integer error code, set to 0 if successful. Note that if the allocated
length of the row has to be expanded, a positive warning code will be
returned.

WARNING:  This method may not be called once FillComplete() has been
called.

IndicesAreLocal()==false && IndicesAreContiguous()==false 

Reimplemented in PyTrilinos::Epetra::FECrsMatrix, and PyTrilinos::Epetra::FECrsMatrix.

def PyTrilinos::Epetra::CrsMatrix::InsertGlobalValues (   self,
  args 
)

InsertGlobalValues(self, int globalRow, PySequence values, PySequence
    indices) -> int

  Arguments:

    globalRow - global row index
    values    - a sequence of doubles that represent the values to insert
    indices   - a sequence of integers that represent the indices to insert

InsertGlobalValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to insert
    cols    - a sequence of integers that represent the column indices to
      insert
    values  - a sequence of doubles that represent the values to insert


int
Epetra_CrsMatrix::InsertGlobalValues(int GlobalRow, int NumEntries,
double *Values, int *Indices)

Insert a list of elements in a given global row of the matrix.

This method is used to construct a matrix for the first time. It
cannot be used if the matrix structure has already been fixed (via a
call to FillComplete()). If multiple values are inserted for the same
matrix entry, the values are initially stored separately, so memory
use will grow as a result. However, when FillComplete is called the
values will be summed together and the additional memory will be
released.

For example, if the values 2.0, 3.0 and 4.0 are all inserted in Row 1,
Column 2, extra storage is used to store each of the three values
separately. In this way, the insert process does not require any
searching and can be faster. However, when FillComplete() is called,
the values will be summed together to equal 9.0 and only a single
entry will remain in the matrix for Row 1, Column 2.

Parameters:
-----------

GlobalRow:  - (In) Row number (in global coordinates) to put elements.

NumEntries:  - (In) Number of entries.

Values:  - (In) Values to enter.

Indices:  - (In) Global column indices corresponding to values.

Integer error code, set to 0 if successful. Note that if the allocated
length of the row has to be expanded, a positive warning code will be
returned.

WARNING:  This method may not be called once FillComplete() has been
called.

IndicesAreLocal()==false && IndicesAreContiguous()==false 

Reimplemented in PyTrilinos::Epetra::FECrsMatrix, and PyTrilinos::Epetra::FECrsMatrix.

def PyTrilinos::Epetra::CrsMatrix::InsertMyValues (   self,
  args 
)

InsertMyValues(self, int myRow, PySequence values, PySequence indices) -> int

  Arguments:

    myRow     - local row index
    values    - a sequence of doubles that represent the values to insert
    indices   - a sequence of integers that represent the indices to insert

InsertMyValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to insert
    cols    - a sequence of integers that represent the column indices to
      insert
    values  - a sequence of doubles that represent the values to insert


int
Epetra_CrsMatrix::InsertMyValues(int MyRow, int NumEntries, double
*Values, int *Indices)

Insert a list of elements in a given local row of the matrix.

Parameters:
-----------

MyRow:  - (In) Row number (in local coordinates) to put elements.

NumEntries:  - (In) Number of entries.

Values:  - (In) Values to enter.

Indices:  - (In) Local column indices corresponding to values.

Integer error code, set to 0 if successful. Note that if the allocated
length of the row has to be expanded, a positive warning code will be
returned.

IndicesAreGlobal()==false && ( IndicesAreContiguous()==false ||
CV_==View)

The given local row of the matrix has been updated as described above.

def PyTrilinos::Epetra::CrsMatrix::InsertMyValues (   self,
  args 
)

InsertMyValues(self, int myRow, PySequence values, PySequence indices) -> int

  Arguments:

    myRow     - local row index
    values    - a sequence of doubles that represent the values to insert
    indices   - a sequence of integers that represent the indices to insert

InsertMyValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to insert
    cols    - a sequence of integers that represent the column indices to
      insert
    values  - a sequence of doubles that represent the values to insert


int
Epetra_CrsMatrix::InsertMyValues(int MyRow, int NumEntries, double
*Values, int *Indices)

Insert a list of elements in a given local row of the matrix.

Parameters:
-----------

MyRow:  - (In) Row number (in local coordinates) to put elements.

NumEntries:  - (In) Number of entries.

Values:  - (In) Values to enter.

Indices:  - (In) Local column indices corresponding to values.

Integer error code, set to 0 if successful. Note that if the allocated
length of the row has to be expanded, a positive warning code will be
returned.

IndicesAreGlobal()==false && ( IndicesAreContiguous()==false ||
CV_==View)

The given local row of the matrix has been updated as described above.

def PyTrilinos::Epetra::CrsMatrix::InvColMaxs (   self,
  args 
)

InvColMaxs(self, Epetra_Vector x) -> int

int
Epetra_CrsMatrix::InvColMaxs(Epetra_Vector &x) const

Computes the max of absolute values of the columns of the
Epetra_CrsMatrix, results returned in x.

The vector x will return such that x[j] will contain the inverse of
max of the absolute values of the entries in the jth row of the this
matrix. WARNING:  This method will not work when multiple processors
contain partial sums for individual entries.

Parameters:
-----------

x:  - (Out) An Epetra_Vector containing the column maxs of the this
matrix.

WARNING:  When columns are fully replicated on multiple processors, it
is assumed that the distribution of x is the same as the columns (
ColMap()) of this. When each column of this is uniquely owned, the
distribution of x can be that of the ColMap() or the DomainMap().

Integer error code, set to 0 if successful.

Filled()==true

Unchanged. 

def PyTrilinos::Epetra::CrsMatrix::InvColMaxs (   self,
  args 
)

InvColMaxs(self, Epetra_Vector x) -> int

int
Epetra_CrsMatrix::InvColMaxs(Epetra_Vector &x) const

Computes the max of absolute values of the columns of the
Epetra_CrsMatrix, results returned in x.

The vector x will return such that x[j] will contain the inverse of
max of the absolute values of the entries in the jth row of the this
matrix. WARNING:  This method will not work when multiple processors
contain partial sums for individual entries.

Parameters:
-----------

x:  - (Out) An Epetra_Vector containing the column maxs of the this
matrix.

WARNING:  When columns are fully replicated on multiple processors, it
is assumed that the distribution of x is the same as the columns (
ColMap()) of this. When each column of this is uniquely owned, the
distribution of x can be that of the ColMap() or the DomainMap().

Integer error code, set to 0 if successful.

Filled()==true

Unchanged. 

def PyTrilinos::Epetra::CrsMatrix::InvColSums (   self,
  args 
)

InvColSums(self, Epetra_Vector x) -> int

int
Epetra_CrsMatrix::InvColSums(Epetra_Vector &x) const

Computes the inverse of the sum of absolute values of the columns of
the Epetra_CrsMatrix, results returned in x.

The vector x will return such that x[j] will contain the inverse of
the sum of the absolute values of the entries in the jth column of the
this matrix. Using the resulting vector from this function as input to
RightScale() will make the one norm of the resulting matrix exactly 1.
WARNING:  The NormOne() method will not properly calculate the one
norm for a matrix that has entries that are replicated on multiple
processors. In this case, if the columns are fully replicated,
NormOne() will return a value equal to the maximum number of
processors that any individual column of the matrix is repliated on.

Parameters:
-----------

x:  - (Out) An Epetra_Vector containing the column sums of the this
matrix.

WARNING:  When columns are fully replicated on multiple processors, it
is assumed that the distribution of x is the same as the columns (
ColMap()) of this. When multiple processors contain partial sums for
entries, the distribution of x is assumed to be the same as the
DomainMap() of this. When each column of this is uniquely owned, the
distribution of x can be that of the ColMap() or the DomainMap().

Integer error code, set to 0 if successful.

Filled()==true

Unchanged. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::InvColSums (   self,
  args 
)

InvColSums(self, Epetra_Vector x) -> int

int
Epetra_CrsMatrix::InvColSums(Epetra_Vector &x) const

Computes the inverse of the sum of absolute values of the columns of
the Epetra_CrsMatrix, results returned in x.

The vector x will return such that x[j] will contain the inverse of
the sum of the absolute values of the entries in the jth column of the
this matrix. Using the resulting vector from this function as input to
RightScale() will make the one norm of the resulting matrix exactly 1.
WARNING:  The NormOne() method will not properly calculate the one
norm for a matrix that has entries that are replicated on multiple
processors. In this case, if the columns are fully replicated,
NormOne() will return a value equal to the maximum number of
processors that any individual column of the matrix is repliated on.

Parameters:
-----------

x:  - (Out) An Epetra_Vector containing the column sums of the this
matrix.

WARNING:  When columns are fully replicated on multiple processors, it
is assumed that the distribution of x is the same as the columns (
ColMap()) of this. When multiple processors contain partial sums for
entries, the distribution of x is assumed to be the same as the
DomainMap() of this. When each column of this is uniquely owned, the
distribution of x can be that of the ColMap() or the DomainMap().

Integer error code, set to 0 if successful.

Filled()==true

Unchanged. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::InvRowMaxs (   self,
  args 
)

InvRowMaxs(self, Epetra_Vector x) -> int

int
Epetra_CrsMatrix::InvRowMaxs(Epetra_Vector &x) const

Computes the inverse of the max of absolute values of the rows of the
Epetra_CrsMatrix, results returned in x.

The vector x will return such that x[i] will contain the inverse of
max of the absolute values of the entries in the ith row of the this
matrix. WARNING:  This method will not work when multiple processors
contain partial sums for individual entries.

Parameters:
-----------

x:  - (Out) An Epetra_Vector containing the inverse of the row maxs of
the this matrix.

WARNING:  When rows are fully replicated on multiple processors, it is
assumed that the distribution of x is the same as the rows (
RowMap())of this. When each row of this is uniquely owned, the
distribution of x can be that of the RowMap() or the RangeMap().

Integer error code, set to 0 if successful.

Filled()==true

Unchanged. 

def PyTrilinos::Epetra::CrsMatrix::InvRowMaxs (   self,
  args 
)

InvRowMaxs(self, Epetra_Vector x) -> int

int
Epetra_CrsMatrix::InvRowMaxs(Epetra_Vector &x) const

Computes the inverse of the max of absolute values of the rows of the
Epetra_CrsMatrix, results returned in x.

The vector x will return such that x[i] will contain the inverse of
max of the absolute values of the entries in the ith row of the this
matrix. WARNING:  This method will not work when multiple processors
contain partial sums for individual entries.

Parameters:
-----------

x:  - (Out) An Epetra_Vector containing the inverse of the row maxs of
the this matrix.

WARNING:  When rows are fully replicated on multiple processors, it is
assumed that the distribution of x is the same as the rows (
RowMap())of this. When each row of this is uniquely owned, the
distribution of x can be that of the RowMap() or the RangeMap().

Integer error code, set to 0 if successful.

Filled()==true

Unchanged. 

def PyTrilinos::Epetra::CrsMatrix::InvRowSums (   self,
  args 
)

InvRowSums(self, Epetra_Vector x) -> int

int
Epetra_CrsMatrix::InvRowSums(Epetra_Vector &x) const

Computes the inverse of the sum of absolute values of the rows of the
Epetra_CrsMatrix, results returned in x.

The vector x will return such that x[i] will contain the inverse of
the sum of the absolute values of the entries in the ith row of the
this matrix. Using the resulting vector from this function as input to
LeftScale() will make the infinity norm of the resulting matrix
exactly 1. WARNING:  The NormInf() method will not properly calculate
the infinity norm for a matrix that has entries that are replicated on
multiple processors. In this case, if the rows are fully replicated,
NormInf() will return a value equal to the maximum number of
processors that any individual row of the matrix is replicated on.

Parameters:
-----------

x:  - (Out) An Epetra_Vector containing the inverse of the row sums of
the this matrix.

WARNING:  When rows are fully replicated on multiple processors, it is
assumed that the distribution of x is the same as the rows (
RowMap())of this. When multiple processors contain partial sums for
individual entries, the distribution of x is assumed to be the same as
the RangeMap() of this. When each row of this is uniquely owned, the
distribution of x can be that of the RowMap() or the RangeMap().

Integer error code, set to 0 if successful.

Filled()==true

Unchanged. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::InvRowSums (   self,
  args 
)

InvRowSums(self, Epetra_Vector x) -> int

int
Epetra_CrsMatrix::InvRowSums(Epetra_Vector &x) const

Computes the inverse of the sum of absolute values of the rows of the
Epetra_CrsMatrix, results returned in x.

The vector x will return such that x[i] will contain the inverse of
the sum of the absolute values of the entries in the ith row of the
this matrix. Using the resulting vector from this function as input to
LeftScale() will make the infinity norm of the resulting matrix
exactly 1. WARNING:  The NormInf() method will not properly calculate
the infinity norm for a matrix that has entries that are replicated on
multiple processors. In this case, if the rows are fully replicated,
NormInf() will return a value equal to the maximum number of
processors that any individual row of the matrix is replicated on.

Parameters:
-----------

x:  - (Out) An Epetra_Vector containing the inverse of the row sums of
the this matrix.

WARNING:  When rows are fully replicated on multiple processors, it is
assumed that the distribution of x is the same as the rows (
RowMap())of this. When multiple processors contain partial sums for
individual entries, the distribution of x is assumed to be the same as
the RangeMap() of this. When each row of this is uniquely owned, the
distribution of x can be that of the RowMap() or the RangeMap().

Integer error code, set to 0 if successful.

Filled()==true

Unchanged. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::Label (   self,
  args 
)

Label(self) -> char

const char*
Epetra_CrsMatrix::Label() const

Returns a character string describing the operator. 

Reimplemented from PyTrilinos::Epetra::Object.

def PyTrilinos::Epetra::CrsMatrix::Label (   self,
  args 
)

Label(self) -> char

const char*
Epetra_CrsMatrix::Label() const

Returns a character string describing the operator. 

Reimplemented from PyTrilinos::Epetra::Object.

def PyTrilinos::Epetra::CrsMatrix::LCID (   self,
  args 
)

LCID(self, int GCID_in) -> int

int
Epetra_CrsMatrix::LCID(int GCID_in) const

Returns the local column index for given global column index, returns
-1 if no local column for this global column.

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsMatrix::LCID (   self,
  args 
)

LCID(self, int GCID_in) -> int

int
Epetra_CrsMatrix::LCID(int GCID_in) const

Returns the local column index for given global column index, returns
-1 if no local column for this global column.

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsMatrix::LeftScale (   self,
  args 
)

LeftScale(self, Epetra_Vector x) -> int

int
Epetra_CrsMatrix::LeftScale(const Epetra_Vector &x)

Scales the Epetra_CrsMatrix 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 scale with.

Integer error code, set to 0 if successful.

Filled()==true

The matrix will be scaled as described above. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::LeftScale (   self,
  args 
)

LeftScale(self, Epetra_Vector x) -> int

int
Epetra_CrsMatrix::LeftScale(const Epetra_Vector &x)

Scales the Epetra_CrsMatrix 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 scale with.

Integer error code, set to 0 if successful.

Filled()==true

The matrix will be scaled as described above. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::LowerTriangular (   self,
  args 
)

LowerTriangular(self) -> bool

bool
Epetra_CrsMatrix::LowerTriangular() const

If matrix is lower triangular in local index space, this query returns
true, otherwise it returns false. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::LowerTriangular (   self,
  args 
)

LowerTriangular(self) -> bool

bool
Epetra_CrsMatrix::LowerTriangular() const

If matrix is lower triangular in local index space, this query returns
true, otherwise it returns false. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::LRID (   self,
  args 
)

LRID(self, int GRID_in) -> int

int
Epetra_CrsMatrix::LRID(int GRID_in) const

Returns the local row index for given global row index, returns -1 if
no local row for this global row. 

def PyTrilinos::Epetra::CrsMatrix::LRID (   self,
  args 
)

LRID(self, int GRID_in) -> int

int
Epetra_CrsMatrix::LRID(int GRID_in) const

Returns the local row index for given global row index, returns -1 if
no local row for this global row. 

def PyTrilinos::Epetra::CrsMatrix::MakeDataContiguous (   self,
  args 
)

MakeDataContiguous(self) -> int

int
Epetra_CrsMatrix::MakeDataContiguous()

Eliminates memory that is used for construction. Make consecutive row
index sections contiguous. 

def PyTrilinos::Epetra::CrsMatrix::MakeDataContiguous (   self,
  args 
)

MakeDataContiguous(self) -> int

int
Epetra_CrsMatrix::MakeDataContiguous()

Eliminates memory that is used for construction. Make consecutive row
index sections contiguous. 

def PyTrilinos::Epetra::CrsMatrix::MaxNumEntries (   self,
  args 
)

MaxNumEntries(self) -> int

int
Epetra_CrsMatrix::MaxNumEntries() const

Returns the maximum number of nonzero entries across all rows on this
processor.

Filled()==true 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::MaxNumEntries (   self,
  args 
)

MaxNumEntries(self) -> int

int
Epetra_CrsMatrix::MaxNumEntries() const

Returns the maximum number of nonzero entries across all rows on this
processor.

Filled()==true 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::Multiply (   self,
  args 
)

Multiply(self, bool TransA, Epetra_Vector x, Epetra_Vector y) -> int
Multiply(self, bool TransA, Epetra_MultiVector X, Epetra_MultiVector Y) -> int

int
Epetra_CrsMatrix::Multiply(bool TransA, const Epetra_MultiVector &X,
Epetra_MultiVector &Y) const

Returns the result of a Epetra_CrsMatrix multiplied by a
Epetra_MultiVector X in Y.

Parameters:
-----------

TransA:  - (In) If true, multiply by the transpose of matrix,
otherwise just use matrix.

X:  - (In) 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.

Filled()==true

Unchanged. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::Multiply (   self,
  args 
)

Multiply(self, bool TransA, Epetra_Vector x, Epetra_Vector y) -> int
Multiply(self, bool TransA, Epetra_MultiVector X, Epetra_MultiVector Y) -> int

int
Epetra_CrsMatrix::Multiply(bool TransA, const Epetra_MultiVector &X,
Epetra_MultiVector &Y) const

Returns the result of a Epetra_CrsMatrix multiplied by a
Epetra_MultiVector X in Y.

Parameters:
-----------

TransA:  - (In) If true, multiply by the transpose of matrix,
otherwise just use matrix.

X:  - (In) 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.

Filled()==true

Unchanged. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::Multiply1 (   self,
  args 
)

Multiply1(self, bool TransA, Epetra_Vector x, Epetra_Vector y) -> int
Multiply1(self, bool TransA, Epetra_MultiVector X, Epetra_MultiVector Y) -> int

int
Epetra_CrsMatrix::Multiply1(bool TransA, const Epetra_MultiVector &X,
Epetra_MultiVector &Y) const 

def PyTrilinos::Epetra::CrsMatrix::Multiply1 (   self,
  args 
)

Multiply1(self, bool TransA, Epetra_Vector x, Epetra_Vector y) -> int
Multiply1(self, bool TransA, Epetra_MultiVector X, Epetra_MultiVector Y) -> int

int
Epetra_CrsMatrix::Multiply1(bool TransA, const Epetra_MultiVector &X,
Epetra_MultiVector &Y) const 

def PyTrilinos::Epetra::CrsMatrix::MyGCID (   self,
  args 
)

MyGCID(self, int GCID_in) -> bool

bool
Epetra_CrsMatrix::MyGCID(int GCID_in) const

Returns true if the GCID passed in belongs to the calling processor in
this map, otherwise returns false.

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsMatrix::MyGCID (   self,
  args 
)

MyGCID(self, int GCID_in) -> bool

bool
Epetra_CrsMatrix::MyGCID(int GCID_in) const

Returns true if the GCID passed in belongs to the calling processor in
this map, otherwise returns false.

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsMatrix::MyGlobalRow (   self,
  args 
)

MyGlobalRow(self, int GID) -> bool

bool
Epetra_CrsMatrix::MyGlobalRow(int GID) const

Returns true of GID is owned by the calling processor, otherwise it
returns false. 

def PyTrilinos::Epetra::CrsMatrix::MyGlobalRow (   self,
  args 
)

MyGlobalRow(self, int GID) -> bool

bool
Epetra_CrsMatrix::MyGlobalRow(int GID) const

Returns true of GID is owned by the calling processor, otherwise it
returns false. 

def PyTrilinos::Epetra::CrsMatrix::MyGRID (   self,
  args 
)

MyGRID(self, int GRID_in) -> bool

bool
Epetra_CrsMatrix::MyGRID(int GRID_in) const

Returns true if the GRID passed in belongs to the calling processor in
this map, otherwise returns false. 

def PyTrilinos::Epetra::CrsMatrix::MyGRID (   self,
  args 
)

MyGRID(self, int GRID_in) -> bool

bool
Epetra_CrsMatrix::MyGRID(int GRID_in) const

Returns true if the GRID passed in belongs to the calling processor in
this map, otherwise returns false. 

def PyTrilinos::Epetra::CrsMatrix::MyLCID (   self,
  args 
)

MyLCID(self, int LCID_in) -> bool

bool
Epetra_CrsMatrix::MyLCID(int LCID_in) const

Returns true if the LRID passed in belongs to the calling processor in
this map, otherwise returns false.

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsMatrix::MyLCID (   self,
  args 
)

MyLCID(self, int LCID_in) -> bool

bool
Epetra_CrsMatrix::MyLCID(int LCID_in) const

Returns true if the LRID passed in belongs to the calling processor in
this map, otherwise returns false.

HaveColMap()==true (If HaveColMap()==false, returns -1) 

def PyTrilinos::Epetra::CrsMatrix::MyLRID (   self,
  args 
)

MyLRID(self, int LRID_in) -> bool

bool
Epetra_CrsMatrix::MyLRID(int LRID_in) const

Returns true if the LRID passed in belongs to the calling processor in
this map, otherwise returns false. 

def PyTrilinos::Epetra::CrsMatrix::MyLRID (   self,
  args 
)

MyLRID(self, int LRID_in) -> bool

bool
Epetra_CrsMatrix::MyLRID(int LRID_in) const

Returns true if the LRID passed in belongs to the calling processor in
this map, otherwise returns false. 

def PyTrilinos::Epetra::CrsMatrix::NoDiagonal (   self,
  args 
)

NoDiagonal(self) -> bool

bool
Epetra_CrsMatrix::NoDiagonal() const

If matrix has no diagonal entries in global index space, this query
returns true, otherwise it returns false. 

def PyTrilinos::Epetra::CrsMatrix::NoDiagonal (   self,
  args 
)

NoDiagonal(self) -> bool

bool
Epetra_CrsMatrix::NoDiagonal() const

If matrix has no diagonal entries in global index space, this query
returns true, otherwise it returns false. 

def PyTrilinos::Epetra::CrsMatrix::NormFrobenius (   self,
  args 
)

NormFrobenius(self) -> double

double
Epetra_CrsMatrix::NormFrobenius() const

Returns the frobenius norm of the global matrix. 

def PyTrilinos::Epetra::CrsMatrix::NormFrobenius (   self,
  args 
)

NormFrobenius(self) -> double

double
Epetra_CrsMatrix::NormFrobenius() const

Returns the frobenius norm of the global matrix. 

def PyTrilinos::Epetra::CrsMatrix::NormInf (   self,
  args 
)

NormInf(self) -> double

double
Epetra_CrsMatrix::NormInf() const

Returns the infinity norm of the global matrix. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NormInf (   self,
  args 
)

NormInf(self) -> double

double
Epetra_CrsMatrix::NormInf() const

Returns the infinity norm of the global matrix. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NormOne (   self,
  args 
)

NormOne(self) -> double

double
Epetra_CrsMatrix::NormOne() const

Returns the one norm of the global matrix. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NormOne (   self,
  args 
)

NormOne(self) -> double

double
Epetra_CrsMatrix::NormOne() const

Returns the one norm of the global matrix. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumAllocatedGlobalEntries (   self,
  args 
)

NumAllocatedGlobalEntries(self, int Row) -> int

int Epetra_CrsMatrix::NumAllocatedGlobalEntries(int Row) const

Returns the allocated number of nonzero entries in specified global
row on this processor. 

def PyTrilinos::Epetra::CrsMatrix::NumAllocatedGlobalEntries (   self,
  args 
)

NumAllocatedGlobalEntries(self, int Row) -> int

int Epetra_CrsMatrix::NumAllocatedGlobalEntries(int Row) const

Returns the allocated number of nonzero entries in specified global
row on this processor. 

def PyTrilinos::Epetra::CrsMatrix::NumAllocatedMyEntries (   self,
  args 
)

NumAllocatedMyEntries(self, int Row) -> int

int
Epetra_CrsMatrix::NumAllocatedMyEntries(int Row) const

Returns the allocated number of nonzero entries in specified local row
on this processor. 

def PyTrilinos::Epetra::CrsMatrix::NumAllocatedMyEntries (   self,
  args 
)

NumAllocatedMyEntries(self, int Row) -> int

int
Epetra_CrsMatrix::NumAllocatedMyEntries(int Row) const

Returns the allocated number of nonzero entries in specified local row
on this processor. 

def PyTrilinos::Epetra::CrsMatrix::NumGlobalCols (   self,
  args 
)

NumGlobalCols(self) -> int

int
Epetra_CrsMatrix::NumGlobalCols() const

Returns the number of global matrix columns. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumGlobalCols (   self,
  args 
)

NumGlobalCols(self) -> int

int
Epetra_CrsMatrix::NumGlobalCols() const

Returns the number of global matrix columns. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumGlobalDiagonals (   self,
  args 
)

NumGlobalDiagonals(self) -> int

int
Epetra_CrsMatrix::NumGlobalDiagonals() const

Returns the number of global nonzero diagonal entries, based on global
row/column index comparisons. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumGlobalDiagonals (   self,
  args 
)

NumGlobalDiagonals(self) -> int

int
Epetra_CrsMatrix::NumGlobalDiagonals() const

Returns the number of global nonzero diagonal entries, based on global
row/column index comparisons. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumGlobalEntries (   self,
  args 
)

NumGlobalEntries(self, int Row) -> int

int
Epetra_CrsMatrix::NumGlobalEntries(int Row) const

Returns the current number of nonzero entries in specified global row
on this processor. 

def PyTrilinos::Epetra::CrsMatrix::NumGlobalEntries (   self,
  args 
)

NumGlobalEntries(self, int Row) -> int

int
Epetra_CrsMatrix::NumGlobalEntries(int Row) const

Returns the current number of nonzero entries in specified global row
on this processor. 

def PyTrilinos::Epetra::CrsMatrix::NumGlobalNonzeros (   self,
  args 
)

NumGlobalNonzeros(self) -> int

int
Epetra_CrsMatrix::NumGlobalNonzeros() const

Returns the number of nonzero entries in the global matrix. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumGlobalNonzeros (   self,
  args 
)

NumGlobalNonzeros(self) -> int

int
Epetra_CrsMatrix::NumGlobalNonzeros() const

Returns the number of nonzero entries in the global matrix. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumGlobalRows (   self,
  args 
)

NumGlobalRows(self) -> int

int
Epetra_CrsMatrix::NumGlobalRows() const

Returns the number of global matrix rows. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumGlobalRows (   self,
  args 
)

NumGlobalRows(self) -> int

int
Epetra_CrsMatrix::NumGlobalRows() const

Returns the number of global matrix rows. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumMyCols (   self,
  args 
)

NumMyCols(self) -> int

int
Epetra_CrsMatrix::NumMyCols() const

Returns the number of entries in the set of column-indices that appear
on this processor.

The set of column-indices that appear on this processor is the union
of column-indices that appear in all local rows. The size of this set
isn't available until FillComplete() has been called.  Filled()==true

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumMyCols (   self,
  args 
)

NumMyCols(self) -> int

int
Epetra_CrsMatrix::NumMyCols() const

Returns the number of entries in the set of column-indices that appear
on this processor.

The set of column-indices that appear on this processor is the union
of column-indices that appear in all local rows. The size of this set
isn't available until FillComplete() has been called.  Filled()==true

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumMyDiagonals (   self,
  args 
)

NumMyDiagonals(self) -> int

int
Epetra_CrsMatrix::NumMyDiagonals() const

Returns the number of local nonzero diagonal entries, based on global
row/column index comparisons.

Filled()==true 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumMyDiagonals (   self,
  args 
)

NumMyDiagonals(self) -> int

int
Epetra_CrsMatrix::NumMyDiagonals() const

Returns the number of local nonzero diagonal entries, based on global
row/column index comparisons.

Filled()==true 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumMyEntries (   self,
  args 
)

NumMyEntries(self, int Row) -> int

int
Epetra_CrsMatrix::NumMyEntries(int Row) const

Returns the current number of nonzero entries in specified local row
on this processor. 

def PyTrilinos::Epetra::CrsMatrix::NumMyEntries (   self,
  args 
)

NumMyEntries(self, int Row) -> int

int
Epetra_CrsMatrix::NumMyEntries(int Row) const

Returns the current number of nonzero entries in specified local row
on this processor. 

def PyTrilinos::Epetra::CrsMatrix::NumMyNonzeros (   self,
  args 
)

NumMyNonzeros(self) -> int

int
Epetra_CrsMatrix::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::CrsMatrix::NumMyNonzeros (   self,
  args 
)

NumMyNonzeros(self) -> int

int
Epetra_CrsMatrix::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::CrsMatrix::NumMyRowEntries (   self,
  args 
)

NumMyRowEntries(self, int MyRow, int NumEntries) -> int

int
Epetra_CrsMatrix::NumMyRowEntries(int MyRow, int &NumEntries) const

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.

None.

Unchanged. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumMyRowEntries (   self,
  args 
)

NumMyRowEntries(self, int MyRow, int NumEntries) -> int

int
Epetra_CrsMatrix::NumMyRowEntries(int MyRow, int &NumEntries) const

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.

None.

Unchanged. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumMyRows (   self,
  args 
)

NumMyRows(self) -> int

int
Epetra_CrsMatrix::NumMyRows() const

Returns the number of matrix rows owned by the calling processor. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::NumMyRows (   self,
  args 
)

NumMyRows(self) -> int

int
Epetra_CrsMatrix::NumMyRows() const

Returns the number of matrix rows owned by the calling processor. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::OperatorDomainMap (   self,
  args 
)

OperatorDomainMap(self) -> Map

const
Epetra_Map& Epetra_CrsMatrix::OperatorDomainMap() const

Returns the Epetra_Map object associated with the domain of this
matrix operator. 

Reimplemented from PyTrilinos::Epetra::Operator.

def PyTrilinos::Epetra::CrsMatrix::OperatorDomainMap (   self,
  args 
)

OperatorDomainMap(self) -> Map

const
Epetra_Map& Epetra_CrsMatrix::OperatorDomainMap() const

Returns the Epetra_Map object associated with the domain of this
matrix operator. 

Reimplemented from PyTrilinos::Epetra::Operator.

def PyTrilinos::Epetra::CrsMatrix::OperatorRangeMap (   self,
  args 
)

OperatorRangeMap(self) -> Map

const
Epetra_Map& Epetra_CrsMatrix::OperatorRangeMap() const

Returns the Epetra_Map object associated with the range of this matrix
operator. 

Reimplemented from PyTrilinos::Epetra::Operator.

def PyTrilinos::Epetra::CrsMatrix::OperatorRangeMap (   self,
  args 
)

OperatorRangeMap(self) -> Map

const
Epetra_Map& Epetra_CrsMatrix::OperatorRangeMap() const

Returns the Epetra_Map object associated with the range of this matrix
operator. 

Reimplemented from PyTrilinos::Epetra::Operator.

def PyTrilinos::Epetra::CrsMatrix::OptimizeStorage (   self,
  args 
)

OptimizeStorage(self) -> int

int
Epetra_CrsMatrix::OptimizeStorage()

Make consecutive row index sections contiguous, minimize internal
storage used for constructing graph.

After construction and during initialization (when values are being
added), the matrix coefficients for each row are managed as separate
segments of memory. This method moves the values for all rows into one
large contiguous array and eliminates internal storage that is not
needed after matrix construction. Calling this method can have a
significant impact on memory costs and machine performance.

If this object was constructed in View mode then this method can't
make non-contiguous values contiguous and will return a warning code
of 1 if the viewed data isn't already contiguous.

A call to this method will also call the OptimizeStorage method for
the associated Epetra_CrsGraph object. If the storage for this graph
has already been optimized this additional call will have no effect.

Integer error code, set to 0 if successful.

Filled()==true.

If CV=View when the graph was constructed, then this method will be
effective  if the indices of the graph were already contiguous. In
this case, the indices are left untouched and internal storage for the
graph is minimized.

StorageOptimized()==true, if successful.

Graph(). StorageOptimized()==true, if successful. 

def PyTrilinos::Epetra::CrsMatrix::OptimizeStorage (   self,
  args 
)

OptimizeStorage(self) -> int

int
Epetra_CrsMatrix::OptimizeStorage()

Make consecutive row index sections contiguous, minimize internal
storage used for constructing graph.

After construction and during initialization (when values are being
added), the matrix coefficients for each row are managed as separate
segments of memory. This method moves the values for all rows into one
large contiguous array and eliminates internal storage that is not
needed after matrix construction. Calling this method can have a
significant impact on memory costs and machine performance.

If this object was constructed in View mode then this method can't
make non-contiguous values contiguous and will return a warning code
of 1 if the viewed data isn't already contiguous.

A call to this method will also call the OptimizeStorage method for
the associated Epetra_CrsGraph object. If the storage for this graph
has already been optimized this additional call will have no effect.

Integer error code, set to 0 if successful.

Filled()==true.

If CV=View when the graph was constructed, then this method will be
effective  if the indices of the graph were already contiguous. In
this case, the indices are left untouched and internal storage for the
graph is minimized.

StorageOptimized()==true, if successful.

Graph(). StorageOptimized()==true, if successful. 

def PyTrilinos::Epetra::CrsMatrix::PutScalar (   self,
  args 
)

PutScalar(self, double ScalarConstant) -> int

int
Epetra_CrsMatrix::PutScalar(double ScalarConstant)

Initialize all values in the matrix with constant value.

Parameters:
-----------

ScalarConstant:  - (In) Value to use.

Integer error code, set to 0 if successful.

None.

All values in this set to ScalarConstant. 

def PyTrilinos::Epetra::CrsMatrix::PutScalar (   self,
  args 
)

PutScalar(self, double ScalarConstant) -> int

int
Epetra_CrsMatrix::PutScalar(double ScalarConstant)

Initialize all values in the matrix with constant value.

Parameters:
-----------

ScalarConstant:  - (In) Value to use.

Integer error code, set to 0 if successful.

None.

All values in this set to ScalarConstant. 

def PyTrilinos::Epetra::CrsMatrix::RangeMap (   self,
  args 
)

RangeMap(self) -> Map

const Epetra_Map&
Epetra_CrsMatrix::RangeMap() const

Returns the Epetra_Map object associated with the range of this matrix
operator.

Filled()==true 

def PyTrilinos::Epetra::CrsMatrix::RangeMap (   self,
  args 
)

RangeMap(self) -> Map

const Epetra_Map&
Epetra_CrsMatrix::RangeMap() const

Returns the Epetra_Map object associated with the range of this matrix
operator.

Filled()==true 

def PyTrilinos::Epetra::CrsMatrix::ReplaceColMap (   self,
  args 
)

ReplaceColMap(self, BlockMap newmap) -> int

int
Epetra_CrsMatrix::ReplaceColMap(const Epetra_BlockMap &newmap)

Replaces the current ColMap with the user-specified map object.

Replaces the current ColMap with the user-specified map object, but
only if currentmap->PointSameAs(newmap) is true. This is a collective
function. Returns 0 if map is replaced, -1 if not.

ColMap().PointSameAs(newmap)==true 

def PyTrilinos::Epetra::CrsMatrix::ReplaceColMap (   self,
  args 
)

ReplaceColMap(self, BlockMap newmap) -> int

int
Epetra_CrsMatrix::ReplaceColMap(const Epetra_BlockMap &newmap)

Replaces the current ColMap with the user-specified map object.

Replaces the current ColMap with the user-specified map object, but
only if currentmap->PointSameAs(newmap) is true. This is a collective
function. Returns 0 if map is replaced, -1 if not.

ColMap().PointSameAs(newmap)==true 

def PyTrilinos::Epetra::CrsMatrix::ReplaceDiagonalValues (   self,
  args 
)

ReplaceDiagonalValues(self, Epetra_Vector Diagonal) -> int

int
Epetra_CrsMatrix::ReplaceDiagonalValues(const Epetra_Vector &Diagonal)

Replaces diagonal values of the matrix with those in the user-provided
vector.

This routine is meant to allow replacement of { existing} diagonal
values. If a diagonal value does not exist for a given row, the
corresponding value in the input Epetra_Vector will be ignored and the
return code will be set to 1.

The Epetra_Map associated with the input Epetra_Vector must be
compatible with the RowMap of the matrix.

Parameters:
-----------

Diagonal:  - (In) New values to be placed in the main diagonal.

Integer error code, set to 0 if successful, set to 1 on the calling
processor if one or more diagonal entries not present in matrix.

Filled()==true

Diagonal values have been replaced with the values of Diagonal. 

def PyTrilinos::Epetra::CrsMatrix::ReplaceDiagonalValues (   self,
  args 
)

ReplaceDiagonalValues(self, Epetra_Vector Diagonal) -> int

int
Epetra_CrsMatrix::ReplaceDiagonalValues(const Epetra_Vector &Diagonal)

Replaces diagonal values of the matrix with those in the user-provided
vector.

This routine is meant to allow replacement of { existing} diagonal
values. If a diagonal value does not exist for a given row, the
corresponding value in the input Epetra_Vector will be ignored and the
return code will be set to 1.

The Epetra_Map associated with the input Epetra_Vector must be
compatible with the RowMap of the matrix.

Parameters:
-----------

Diagonal:  - (In) New values to be placed in the main diagonal.

Integer error code, set to 0 if successful, set to 1 on the calling
processor if one or more diagonal entries not present in matrix.

Filled()==true

Diagonal values have been replaced with the values of Diagonal. 

def PyTrilinos::Epetra::CrsMatrix::ReplaceGlobalValues (   self,
  args 
)

ReplaceGlobalValues(self, int globalRow, PySequence values, PySequence
    indices) -> int

  Arguments:

    globalRow - global row index
    values    - a sequence of doubles that represent the values to replace
    indices   - a sequence of integers that represent the indices to replace

ReplaceGlobalValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to replace
    cols    - a sequence of integers that represent the column indices to
      replace
    values  - a sequence of doubles that represent the values to replace


int
Epetra_CrsMatrix::ReplaceGlobalValues(int GlobalRow, int NumEntries,
double *Values, int *Indices)

Replace specified existing values with this list of entries for a
given global row of the matrix.

Parameters:
-----------

GlobalRow:  - (In) Row number (in global coordinates) to put elements.

NumEntries:  - (In) Number of entries.

Values:  - (In) Values to enter.

Indices:  - (In) Global column indices corresponding to values.

Integer error code, set to 0 if successful. Note that if a value is
not already present for the specified location in the matrix, the
input value will be ignored and a positive warning code will be
returned.

IndicesAreLocal()==false && IndicesAreContiguous()==false 

def PyTrilinos::Epetra::CrsMatrix::ReplaceGlobalValues (   self,
  args 
)

ReplaceGlobalValues(self, int globalRow, PySequence values, PySequence
    indices) -> int

  Arguments:

    globalRow - global row index
    values    - a sequence of doubles that represent the values to replace
    indices   - a sequence of integers that represent the indices to replace

ReplaceGlobalValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to replace
    cols    - a sequence of integers that represent the column indices to
      replace
    values  - a sequence of doubles that represent the values to replace


int
Epetra_CrsMatrix::ReplaceGlobalValues(int GlobalRow, int NumEntries,
double *Values, int *Indices)

Replace specified existing values with this list of entries for a
given global row of the matrix.

Parameters:
-----------

GlobalRow:  - (In) Row number (in global coordinates) to put elements.

NumEntries:  - (In) Number of entries.

Values:  - (In) Values to enter.

Indices:  - (In) Global column indices corresponding to values.

Integer error code, set to 0 if successful. Note that if a value is
not already present for the specified location in the matrix, the
input value will be ignored and a positive warning code will be
returned.

IndicesAreLocal()==false && IndicesAreContiguous()==false 

def PyTrilinos::Epetra::CrsMatrix::ReplaceMyValues (   self,
  args 
)

ReplaceMyValues(self, int myRow, PySequence values, PySequence indices) -> int

  Arguments:

    myRow     - local row index
    values    - a sequence of doubles that represent the values to replace
    indices   - a sequence of integers that represent the indices to replace

ReplaceMyValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to replace
    cols    - a sequence of integers that represent the column indices to
      replace
    values  - a sequence of doubles that represent the values to replace


int
Epetra_CrsMatrix::ReplaceMyValues(int MyRow, int NumEntries, double
*Values, int *Indices)

Replace current values with this list of entries for a given local row
of the matrix.

Parameters:
-----------

MyRow:  - (In) Row number (in local coordinates) to put elements.

NumEntries:  - (In) Number of entries.

Values:  - (In) Values to enter.

Indices:  - (In) Local column indices corresponding to values.

Integer error code, set to 0 if successful. Note that if a value is
not already present for the specified location in the matrix, the
input value will be ignored and a positive warning code will be
returned.

IndicesAreLocal()==true

MyRow contains the given list of Values at the given Indices. 

def PyTrilinos::Epetra::CrsMatrix::ReplaceMyValues (   self,
  args 
)

ReplaceMyValues(self, int myRow, PySequence values, PySequence indices) -> int

  Arguments:

    myRow     - local row index
    values    - a sequence of doubles that represent the values to replace
    indices   - a sequence of integers that represent the indices to replace

ReplaceMyValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to replace
    cols    - a sequence of integers that represent the column indices to
      replace
    values  - a sequence of doubles that represent the values to replace


int
Epetra_CrsMatrix::ReplaceMyValues(int MyRow, int NumEntries, double
*Values, int *Indices)

Replace current values with this list of entries for a given local row
of the matrix.

Parameters:
-----------

MyRow:  - (In) Row number (in local coordinates) to put elements.

NumEntries:  - (In) Number of entries.

Values:  - (In) Values to enter.

Indices:  - (In) Local column indices corresponding to values.

Integer error code, set to 0 if successful. Note that if a value is
not already present for the specified location in the matrix, the
input value will be ignored and a positive warning code will be
returned.

IndicesAreLocal()==true

MyRow contains the given list of Values at the given Indices. 

def PyTrilinos::Epetra::CrsMatrix::ReplaceRowMap (   self,
  args 
)

ReplaceRowMap(self, BlockMap newmap) -> int

int
Epetra_CrsMatrix::ReplaceRowMap(const Epetra_BlockMap &newmap)

Replaces the current RowMap with the user-specified map object.

Replaces the current RowMap with the user-specified map object, but
only if currentmap->PointSameAs(newmap) is true. This is a collective
function. Returns 0 if map is replaced, -1 if not.

RowMap().PointSameAs(newmap)==true 

def PyTrilinos::Epetra::CrsMatrix::ReplaceRowMap (   self,
  args 
)

ReplaceRowMap(self, BlockMap newmap) -> int

int
Epetra_CrsMatrix::ReplaceRowMap(const Epetra_BlockMap &newmap)

Replaces the current RowMap with the user-specified map object.

Replaces the current RowMap with the user-specified map object, but
only if currentmap->PointSameAs(newmap) is true. This is a collective
function. Returns 0 if map is replaced, -1 if not.

RowMap().PointSameAs(newmap)==true 

def PyTrilinos::Epetra::CrsMatrix::RightScale (   self,
  args 
)

RightScale(self, Epetra_Vector x) -> int

int
Epetra_CrsMatrix::RightScale(const Epetra_Vector &x)

Scales the Epetra_CrsMatrix 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.

Filled()==true

The matrix will be scaled as described above. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::RightScale (   self,
  args 
)

RightScale(self, Epetra_Vector x) -> int

int
Epetra_CrsMatrix::RightScale(const Epetra_Vector &x)

Scales the Epetra_CrsMatrix 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.

Filled()==true

The matrix will be scaled as described above. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::RowMap (   self,
  args 
)

RowMap(self) -> Map

const Epetra_Map&
Epetra_CrsMatrix::RowMap() const

Returns the Epetra_Map object associated with the rows of this matrix.

def PyTrilinos::Epetra::CrsMatrix::RowMap (   self,
  args 
)

RowMap(self) -> Map

const Epetra_Map&
Epetra_CrsMatrix::RowMap() const

Returns the Epetra_Map object associated with the rows of this matrix.

def PyTrilinos::Epetra::CrsMatrix::RowMatrixColMap (   self,
  args 
)

RowMatrixColMap(self) -> Map

const
Epetra_Map& Epetra_CrsMatrix::RowMatrixColMap() const

Returns the Epetra_Map object associated with columns of this matrix.

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::RowMatrixColMap (   self,
  args 
)

RowMatrixColMap(self) -> Map

const
Epetra_Map& Epetra_CrsMatrix::RowMatrixColMap() const

Returns the Epetra_Map object associated with columns of this matrix.

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::RowMatrixImporter (   self,
  args 
)

RowMatrixImporter(self) -> Import

const
Epetra_Import* Epetra_CrsMatrix::RowMatrixImporter() const

Returns the Epetra_Import object that contains the import operations
for distributed operations. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::RowMatrixImporter (   self,
  args 
)

RowMatrixImporter(self) -> Import

const
Epetra_Import* Epetra_CrsMatrix::RowMatrixImporter() const

Returns the Epetra_Import object that contains the import operations
for distributed operations. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::RowMatrixRowMap (   self,
  args 
)

RowMatrixRowMap(self) -> Map

const
Epetra_Map& Epetra_CrsMatrix::RowMatrixRowMap() const

Returns the Epetra_Map object associated with the rows of this matrix.

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::RowMatrixRowMap (   self,
  args 
)

RowMatrixRowMap(self) -> Map

const
Epetra_Map& Epetra_CrsMatrix::RowMatrixRowMap() const

Returns the Epetra_Map object associated with the rows of this matrix.

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::Scale (   self,
  args 
)

Scale(self, double ScalarConstant) -> int

int
Epetra_CrsMatrix::Scale(double ScalarConstant)

Multiply all values in the matrix by a constant value (in place: A <-
ScalarConstant * A).

Parameters:
-----------

ScalarConstant:  - (In) Value to use.

Integer error code, set to 0 if successful.

None.

All values of this have been multiplied by ScalarConstant. 

def PyTrilinos::Epetra::CrsMatrix::Scale (   self,
  args 
)

Scale(self, double ScalarConstant) -> int

int
Epetra_CrsMatrix::Scale(double ScalarConstant)

Multiply all values in the matrix by a constant value (in place: A <-
ScalarConstant * A).

Parameters:
-----------

ScalarConstant:  - (In) Value to use.

Integer error code, set to 0 if successful.

None.

All values of this have been multiplied by ScalarConstant. 

def PyTrilinos::Epetra::CrsMatrix::SetUseTranspose (   self,
  args 
)

SetUseTranspose(self, bool UseTranspose_in) -> int

int
Epetra_CrsMatrix::SetUseTranspose(bool UseTranspose_in)

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:
-----------

UseTranspose:  - (In) If true, multiply by the transpose of operator,
otherwise just use operator.

Always returns 0. 

Reimplemented from PyTrilinos::Epetra::Operator.

def PyTrilinos::Epetra::CrsMatrix::SetUseTranspose (   self,
  args 
)

SetUseTranspose(self, bool UseTranspose_in) -> int

int
Epetra_CrsMatrix::SetUseTranspose(bool UseTranspose_in)

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:
-----------

UseTranspose:  - (In) If true, multiply by the transpose of operator,
otherwise just use operator.

Always returns 0. 

Reimplemented from PyTrilinos::Epetra::Operator.

def PyTrilinos::Epetra::CrsMatrix::Solve (   self,
  args 
)

Solve(self, bool Upper, bool Trans, bool UnitDiagonal, Epetra_Vector x, 
    Epetra_Vector y) -> int
Solve(self, bool Upper, bool Trans, bool UnitDiagonal, Epetra_MultiVector X, 
    Epetra_MultiVector Y) -> int

int
Epetra_CrsMatrix::Solve(bool Upper, bool Trans, bool UnitDiagonal,
const Epetra_MultiVector &X, Epetra_MultiVector &Y) const

Returns the result of a local solve using the Epetra_CrsMatrix a
Epetra_MultiVector X in Y.

This method solves a triangular system of equations asynchronously on
each processor.

Parameters:
-----------

Upper:  - (In) If true, solve Uy = x, otherwise solve Ly = x.

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.

Filled()==true

Unchanged. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::Solve (   self,
  args 
)

Solve(self, bool Upper, bool Trans, bool UnitDiagonal, Epetra_Vector x, 
    Epetra_Vector y) -> int
Solve(self, bool Upper, bool Trans, bool UnitDiagonal, Epetra_MultiVector X, 
    Epetra_MultiVector Y) -> int

int
Epetra_CrsMatrix::Solve(bool Upper, bool Trans, bool UnitDiagonal,
const Epetra_MultiVector &X, Epetra_MultiVector &Y) const

Returns the result of a local solve using the Epetra_CrsMatrix a
Epetra_MultiVector X in Y.

This method solves a triangular system of equations asynchronously on
each processor.

Parameters:
-----------

Upper:  - (In) If true, solve Uy = x, otherwise solve Ly = x.

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.

Filled()==true

Unchanged. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::SortGhostsAssociatedWithEachProcessor (   self,
  args 
)

SortGhostsAssociatedWithEachProcessor(self, bool Flag) -> int

def PyTrilinos::Epetra::CrsMatrix::SortGhostsAssociatedWithEachProcessor (   self,
  args 
)

SortGhostsAssociatedWithEachProcessor(self, bool Flag) -> int

def PyTrilinos::Epetra::CrsMatrix::StaticGraph (   self,
  args 
)

StaticGraph(self) -> bool

bool
Epetra_CrsMatrix::StaticGraph()

Returns true if the graph associated with this matrix was pre-
constructed and therefore not changeable. 

def PyTrilinos::Epetra::CrsMatrix::StaticGraph (   self,
  args 
)

StaticGraph(self) -> bool

bool
Epetra_CrsMatrix::StaticGraph()

Returns true if the graph associated with this matrix was pre-
constructed and therefore not changeable. 

def PyTrilinos::Epetra::CrsMatrix::StorageOptimized (   self,
  args 
)

StorageOptimized(self) -> bool

bool
Epetra_CrsMatrix::StorageOptimized() const

If OptimizeStorage() has been called, this query returns true,
otherwise it returns false. 

def PyTrilinos::Epetra::CrsMatrix::StorageOptimized (   self,
  args 
)

StorageOptimized(self) -> bool

bool
Epetra_CrsMatrix::StorageOptimized() const

If OptimizeStorage() has been called, this query returns true,
otherwise it returns false. 

def PyTrilinos::Epetra::CrsMatrix::SumIntoGlobalValues (   self,
  args 
)

SumIntoGlobalValues(self, int globalRow, PySequence values, PySequence
    indices) -> int

  Arguments:

    globalRow - global row index
    values    - a sequence of doubles that represent the values to sum into
    indices   - a sequence of integers that represent the indices to sum into

SumIntoGlobalValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to sum into
    cols    - a sequence of integers that represent the column indices to
      sum into
    values  - a sequence of doubles that represent the values to sum into


int
Epetra_CrsMatrix::SumIntoGlobalValues(int GlobalRow, int NumEntries,
double *Values, int *Indices)

Add this list of entries to existing values for a given global row of
the matrix.

Parameters:
-----------

GlobalRow:  - (In) Row number (in global coordinates) to put elements.

NumEntries:  - (In) Number of entries.

Values:  - (In) Values to enter.

Indices:  - (In) Global column indices corresponding to values.

Integer error code, set to 0 if successful. Note that if a value is
not already present for the specified location in the matrix, the
input value will be ignored and a positive warning code will be
returned.

IndicesAreLocal()==false && IndicesAreContiguous()==false 

def PyTrilinos::Epetra::CrsMatrix::SumIntoGlobalValues (   self,
  args 
)

SumIntoGlobalValues(self, int globalRow, PySequence values, PySequence
    indices) -> int

  Arguments:

    globalRow - global row index
    values    - a sequence of doubles that represent the values to sum into
    indices   - a sequence of integers that represent the indices to sum into

SumIntoGlobalValues(self, PySequence rows, PySequence cols, PySequence
    values) -> int

  Arguments:

    rows    - a sequence of integers that represent the row indices to sum into
    cols    - a sequence of integers that represent the column indices to
      sum into
    values  - a sequence of doubles that represent the values to sum into


int
Epetra_CrsMatrix::SumIntoGlobalValues(int GlobalRow, int NumEntries,
double *Values, int *Indices)

Add this list of entries to existing values for a given global row of
the matrix.

Parameters:
-----------

GlobalRow:  - (In) Row number (in global coordinates) to put elements.

NumEntries:  - (In) Number of entries.

Values:  - (In) Values to enter.

Indices:  - (In) Global column indices corresponding to values.

Integer error code, set to 0 if successful. Note that if a value is
not already present for the specified location in the matrix, the
input value will be ignored and a positive warning code will be
returned.

IndicesAreLocal()==false && IndicesAreContiguous()==false 

def PyTrilinos::Epetra::CrsMatrix::SumIntoMyValues (   self,
  args 
)

SumIntoMyValues(self, int myRow, PySequence values, PySequence indices) -> int

  Arguments:

    myRow     - local row index
    values    - a sequence of doubles that represent the values to sum into
    indices   - a sequence of integers that represent the indices to sum into

SumIntoMyValues(self, PyObject Rows, PyObject Cols, PyObject Values) -> int

int
Epetra_CrsMatrix::SumIntoMyValues(int MyRow, int NumEntries, double
*Values, int *Indices)

Add this list of entries to existing values for a given local row of
the matrix.

Parameters:
-----------

MyRow:  - (In) Row number (in local coordinates) to put elements.

NumEntries:  - (In) Number of entries.

Values:  - (In) Values to enter.

Indices:  - (In) Local column indices corresponding to values.

Integer error code, set to 0 if successful. Note that if the allocated
length of the row has to be expanded, a positive warning code will be
returned.

IndicesAreLocal()==true

The given Values at the given Indices have been summed into the
entries of MyRow. 

def PyTrilinos::Epetra::CrsMatrix::SumIntoMyValues (   self,
  args 
)

SumIntoMyValues(self, int myRow, PySequence values, PySequence indices) -> int

  Arguments:

    myRow     - local row index
    values    - a sequence of doubles that represent the values to sum into
    indices   - a sequence of integers that represent the indices to sum into

SumIntoMyValues(self, PyObject Rows, PyObject Cols, PyObject Values) -> int

int
Epetra_CrsMatrix::SumIntoMyValues(int MyRow, int NumEntries, double
*Values, int *Indices)

Add this list of entries to existing values for a given local row of
the matrix.

Parameters:
-----------

MyRow:  - (In) Row number (in local coordinates) to put elements.

NumEntries:  - (In) Number of entries.

Values:  - (In) Values to enter.

Indices:  - (In) Local column indices corresponding to values.

Integer error code, set to 0 if successful. Note that if the allocated
length of the row has to be expanded, a positive warning code will be
returned.

IndicesAreLocal()==true

The given Values at the given Indices have been summed into the
entries of MyRow. 

def PyTrilinos::Epetra::CrsMatrix::TransformToLocal (   self,
  args 
)

TransformToLocal(self) -> int
TransformToLocal(self, Map DomainMap, Map RangeMap) -> int

int
Epetra_CrsMatrix::TransformToLocal(const Epetra_Map *DomainMap, const
Epetra_Map *RangeMap)

Use FillComplete(const Epetra_Map& DomainMap, const Epetra_Map&
RangeMap) instead. 

def PyTrilinos::Epetra::CrsMatrix::TransformToLocal (   self,
  args 
)

TransformToLocal(self) -> int
TransformToLocal(self, Map DomainMap, Map RangeMap) -> int

int
Epetra_CrsMatrix::TransformToLocal(const Epetra_Map *DomainMap, const
Epetra_Map *RangeMap)

Use FillComplete(const Epetra_Map& DomainMap, const Epetra_Map&
RangeMap) instead. 

def PyTrilinos::Epetra::CrsMatrix::UpperTriangular (   self,
  args 
)

UpperTriangular(self) -> bool

bool
Epetra_CrsMatrix::UpperTriangular() const

If matrix is upper triangular in local index space, this query returns
true, otherwise it returns false. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::UpperTriangular (   self,
  args 
)

UpperTriangular(self) -> bool

bool
Epetra_CrsMatrix::UpperTriangular() const

If matrix is upper triangular in local index space, this query returns
true, otherwise it returns false. 

Reimplemented from PyTrilinos::Epetra::RowMatrix.

def PyTrilinos::Epetra::CrsMatrix::UseTranspose (   self,
  args 
)

UseTranspose(self) -> bool

bool
Epetra_CrsMatrix::UseTranspose() const

Returns the current UseTranspose setting. 

Reimplemented from PyTrilinos::Epetra::Operator.

def PyTrilinos::Epetra::CrsMatrix::UseTranspose (   self,
  args 
)

UseTranspose(self) -> bool

bool
Epetra_CrsMatrix::UseTranspose() const

Returns the current UseTranspose setting. 

Reimplemented from PyTrilinos::Epetra::Operator.


The documentation for this class was generated from the following files:

Generated on Thu Dec 17 11:00:21 2009 for PyTrilinos by  doxygen 1.5.9