PyTrilinos.Epetra.MultiVector Class Reference

Inheritance diagram for PyTrilinos.Epetra.MultiVector:

Collaboration diagram for PyTrilinos.Epetra.MultiVector:

List of all members.

Public Member Functions
def	__init__
def	__init__
def	__initArray__
def	__expand_index__
def	__getitem__
def	__getslice__
def	__str__
def	__lt__
def	__le__
def	__eq__
def	__ne__
def	__gt__
def	__ge__
def	__getattr__
def	__setattr__
Public Attributes
	this

---

Detailed Description

Proxy of C++ MultiVector class

Epetra.MultiVector: A class for constructing and using dense multi- vectors,
vectors and matrices in parallel.

The Epetra.MultiVector class enables the construction and use of real-
valued, double- precision dense vectors, multi-vectors, and matrices in a
distributed memory environment. The dimensions and distribution of the dense
multi-vectors is determined in part by a Epetra.Comm object, a Epetra.Map
(or Epetra.LocalMap or Epetra.BlockMap) and the number of vectors passed to
the constructors described below.

There are several concepts that important for understanding the
Epetra.MultiVector class:

Multi-vectors, Vectors and Matrices. Vector - A list of real-valued,
double-precision numbers. Also a multi-vector with one vector.

Multi-Vector - A collection of one or more vectors, all having the same
length and distribution.

(Dense) Matrix - A special form of multi-vector such that stride in memory
between any two consecutive vectors in the multi-vector is the same for all
vectors. This is identical to a two-dimensional array in Fortran and plays
an important part in high performance computations.

Distributed Global vs. Replicated Local. Distributed Global Multi- vectors -
In most instances, a multi-vector will be partitioned across multiple memory
images associated with multiple processors. In this case, there is a unique
copy of each element and elements are spread across all processors specified
by the Epetra.Comm communicator.

Replicated Local Multi-vectors - Some algorithms use multi-vectors that are
too small to be distributed across all processors, the Hessenberg matrix in
a GMRES computation. In other cases, such as with block iterative methods,
block dot product functions produce small dense matrices that are required
by all processors. Replicated local multi-vectors handle these types of
situation.

Multi-vector Functions vs. Dense Matrix Functions. Multi-vector functions -
These functions operate simultaneously but independently on each vector in
the multi-vector and produce individual results for each vector.

Dense matrix functions - These functions operate on the multi-vector as a
matrix, providing access to selected dense BLAS and LAPACK operations.

In the python implementation, the MultiVector stores an underlying numpy
array, with which it shares the data buffer.  This underlying numpy array
has at least two dimensions, and the first dimension corresponds to the
number of vectors.  Also, almost all numpy array methods and operators are
supported.

---

Constructor & Destructor Documentation

def PyTrilinos.Epetra.MultiVector.__init__	(		self,
			args
	)

__init__(MultiVector self) -> MultiVector

Reimplemented from PyTrilinos.Epetra.NumPyMultiVector.

def PyTrilinos.Epetra.MultiVector.__init__	(		self,
			args
	)

__init__(self, BlockMap map, int numVectors,
     bool zeroOut=True) -> MultiVector
__init__(self, MultiVector source) -> MultiVector
__init__(self, BlockMap map, PyObject array) -> MultiVector
__init__(self, DataAccess CV, MultiVector source) -> MultiVector
__init__(self, DataAccess CV, MultiVector source,
     PyObject range) -> MultiVector
__init__(self, PyObject array) -> MultiVector

Arguments:
    map         - BlockMap describing domain decomposition
    numVectors  - Number of vectors
    zeroOut     - Flag controlling whether to initialize MultiVector to
          zero
    source      - Source MultiVector for copy constructors
    array       - Python sequence that can be converted to a numpy array
          of doubles for initialization
    CV          - Epetra.Copy or Epetra.View
    range       - Python sequence specifying range of vector indexes

Reimplemented from PyTrilinos.Epetra.NumPyMultiVector.

---

Member Function Documentation

def PyTrilinos.Epetra.MultiVector.__eq__	(		self,
			other
	)

__eq__(self, other) -> bool

Equal operator (==).

def PyTrilinos.Epetra.MultiVector.__ge__	(		self,
			other
	)

__ge__(self, other) -> bool

Greater-than or equal operator (>=).

def PyTrilinos.Epetra.MultiVector.__getitem__	(		self,
			index
	)

x.__getitem__(y) <==> x[y]

def PyTrilinos.Epetra.MultiVector.__getslice__	(		self,
			i,
			j
	)

x.__getslice__(i,j) <==> x[i:j]

def PyTrilinos.Epetra.MultiVector.__gt__	(		self,
			other
	)

__gt__(self, other) -> bool

Greater-than operator (>).

def PyTrilinos.Epetra.MultiVector.__initArray__

(

self

)

__initArray__(self)

Initialize the underlying numpy array.

def PyTrilinos.Epetra.MultiVector.__le__	(		self,
			other
	)

__le__(self, other) -> bool

Less-than-or-equal operator (<=).

def PyTrilinos.Epetra.MultiVector.__lt__	(		self,
			other
	)

__lt__(self, other) -> bool

Less-than operator (<).

def PyTrilinos.Epetra.MultiVector.__ne__	(		self,
			other
	)

__ne__(self, other) -> bool

Not-equal operator (!=).

def PyTrilinos.Epetra.MultiVector.__str__

(

self

)

__str__(self) -> string

Return the numpy-style string representation of the MultiVector.

---

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

• Epetra.py