Inheritance diagram for PyTrilinos.NOX.Abstract.Vector:

Collaboration diagram for PyTrilinos.NOX.Abstract.Vector:

Public Member Functions
def	__init__
def	init
def	random
def	abs
def	reciprocal
def	scale
def	update
def	clone
def	createMultiVector
def	norm
def	innerProduct
def	length
Static Public Attributes
	TwoNorm = _Abstract.Vector_TwoNorm
	OneNorm = _Abstract.Vector_OneNorm
	MaxNorm = _Abstract.Vector_MaxNorm

Detailed Description

NOX's pure abstract vector interface for vectors that are used by the
nonlinear solver.

This class is a member of the namespace NOX::Abstract.

The user should implement their own concrete implementation of this
class or use one of the implementations provided by us.

Tammy Kolda (SNL 8950), Roger Pawlowski (SNL 9233)

C++ includes: NOX_Abstract_Vector.H

Member Function Documentation

def PyTrilinos.NOX.Abstract.Vector.abs	(	self,
		args
	)

abs(Vector self, Vector y) -> Vector

virtual
NOX::Abstract::Vector& NOX::Abstract::Vector::abs(const
NOX::Abstract::Vector &y)=0

Put element-wise absolute values of source vector y into this vector.

Here x represents this vector, and we update it as \\[ x_i = | y_i |
\\quad \\mbox{for } i=1,\\dots,n \\]

Reference to this object

Reimplemented in PyTrilinos.NOX.Epetra.Vector.

def PyTrilinos.NOX.Abstract.Vector.clone	(	self,
		args
	)

clone(Vector self, NOX::CopyType type=DeepCopy) -> Teuchos::RCP< NOX::Abstract::Vector >

virtual
Teuchos::RCP<NOX::Abstract::Vector>
NOX::Abstract::Vector::clone(NOX::CopyType type=NOX::DeepCopy) const
=0

Create a new Vector of the same underlying type by cloning "this",
and return a pointer to the new vector.

If type is NOX::DeepCopy, then we need to create an exact replica of
"this". Otherwise, if type is NOX::ShapeCopy, we need only replicate
the shape of "this" (the memory is allocated for the objects, but
the current values are not copied into the vector). Note that there is
no assumption that a vector created by ShapeCopy is initialized to
zeros.

Pointer to newly created vector or NULL if clone is not supported.

Reimplemented in PyTrilinos.NOX.Epetra.Vector.

def PyTrilinos.NOX.Abstract.Vector.createMultiVector	(	self,
		args
	)

createMultiVector(Vector self, NOX::Abstract::Vector const *const * vecs, int numVecs, NOX::CopyType type=DeepCopy) -> Teuchos::RCP< NOX::Abstract::MultiVector >
createMultiVector(Vector self, int numVecs, NOX::CopyType type=DeepCopy) -> Teuchos::RCP< NOX::Abstract::MultiVector >

Teuchos::RCP< NOX::Abstract::MultiVector >
NOX::Abstract::Vector::createMultiVector(int numVecs, NOX::CopyType
type=NOX::DeepCopy) const

Create a MultiVector with numVecs columns.

The default implementation creates a generic NOX::MultiVector with
either Shape or Deep copies of the supplied vector.

Reimplemented in PyTrilinos.NOX.Epetra.Vector.

def PyTrilinos.NOX.Abstract.Vector.init	(	self,
		args
	)

init(Vector self, double gamma) -> Vector

virtual
NOX::Abstract::Vector& NOX::Abstract::Vector::init(double gamma)=0

Initialize every element of this vector with gamma.

Here x represents this vector, and we update it as \\[ x_i =
\\gamma \\quad \\mbox{for } i=1,\\dots,n \\] Reference to
this object

Reimplemented in PyTrilinos.NOX.Epetra.Vector.

def PyTrilinos.NOX.Abstract.Vector.innerProduct	(	self,
		args
	)

innerProduct(Vector self, Vector y) -> double

virtual
double NOX::Abstract::Vector::innerProduct(const NOX::Abstract::Vector
&y) const =0

Inner product with y.

Here x represents this vector, and we compute its inner product with y
as follows: \\[ \\langle x,y \\rangle = \\sum_{i=1}^n x_i y_i
\\]  $\\langle x,y \\rangle$

Reimplemented in PyTrilinos.NOX.Epetra.Vector.

def PyTrilinos.NOX.Abstract.Vector.length	(	self,
		args
	)

length(Vector self) -> int

virtual int
NOX::Abstract::Vector::length() const =0

Return the length of vector.

The length of this vector

Even if the vector is distributed across processors, this should
return the  global length of the vector.

Reimplemented in PyTrilinos.NOX.Epetra.Vector.

def PyTrilinos.NOX.Abstract.Vector.norm	(	self,
		args
	)

norm(Vector self, NOX::Abstract::Vector::NormType type=TwoNorm) -> double
norm(Vector self, Vector weights) -> double

virtual double
NOX::Abstract::Vector::norm(const NOX::Abstract::Vector &weights)
const =0

Weighted 2-Norm.

Here x represents this vector, and we compute its weighted norm as
follows: \\[ \\|x\\|_w = \\sqrt{\\sum_{i=1}^{n} w_i \\;
x_i^2} \\]  $ \\|x\\|_w $

Reimplemented in PyTrilinos.NOX.Epetra.Vector.

def PyTrilinos.NOX.Abstract.Vector.random	(	self,
		args
	)

random(Vector self, bool useSeed=False, int seed=1) -> Vector

NOX::Abstract::Vector & NOX::Abstract::Vector::random(bool
useSeed=false, int seed=1)

Initialize each element of this vector with a random value.

If useSeed is true, uses the value of seed to seed the random number
generator before filling the entries of this vector. So, if two calls
are made where useSeed is true and seed is the same, then the vectors
returned should be the same.

Default implementation throw an error. Only referenced by LOCA
methods.

Reference to this object

Reimplemented in PyTrilinos.NOX.Epetra.Vector.

def PyTrilinos.NOX.Abstract.Vector.reciprocal	(	self,
		args
	)

reciprocal(Vector self, Vector y) -> Vector

virtual
NOX::Abstract::Vector& NOX::Abstract::Vector::reciprocal(const
NOX::Abstract::Vector &y)=0

Put element-wise reciprocal of source vector y into this vector.

Here x represents this vector, and we update it as \\[ x_i =
\\frac{1}{y_i} \\quad \\mbox{for } i=1,\\dots,n \\]

Reference to this object

Reimplemented in PyTrilinos.NOX.Epetra.Vector.

def PyTrilinos.NOX.Abstract.Vector.scale	(	self,
		args
	)

scale(Vector self, double gamma) -> Vector
scale(Vector self, Vector a) -> Vector

virtual
NOX::Abstract::Vector& NOX::Abstract::Vector::scale(const
NOX::Abstract::Vector &a)=0

Scale this vector element-by-element by the vector a.

Here x represents this vector, and we update it as \\[ x_i = x_i
\\cdot a_i \\quad \\mbox{for } i=1,\\dots,n \\]

Reference to this object

Reimplemented in PyTrilinos.NOX.Epetra.Vector.

def PyTrilinos.NOX.Abstract.Vector.update	(	self,
		args
	)

update(Vector self, double alpha, Vector a, double gamma=0.0) -> Vector
update(Vector self, double alpha, Vector a, double beta, Vector b, double gamma=0.0) -> Vector

virtual
NOX::Abstract::Vector& NOX::Abstract::Vector::update(double alpha,
const NOX::Abstract::Vector &a, double beta, const
NOX::Abstract::Vector &b, double gamma=0.0)=0

Compute x = (alpha * a) + (beta * b) + (gamma * x) where x is this
vector.

Here x represents this vector, and we update it as \\[ x_i =
\\alpha \\; a_i + \\beta \\; b_i + \\gamma \\; x_i
\\quad \\mbox{for } i=1,\\dots,n \\]

Reference to this object

Reimplemented in PyTrilinos.NOX.Epetra.Vector.

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

Abstract.py

Public Member Functions

Static Public Attributes

Detailed Description

Member Function Documentation