Public Member Functions | |
def | __init__ |
def | getEpetraVector |
def | init |
def | random |
def | abs |
def | reciprocal |
def | scale |
def | update |
def | clone |
def | createMultiVector |
def | norm |
def | innerProduct |
def | length |
def | getVectorSpace |
def | __init__ |
def | getEpetraVector |
def | init |
def | random |
def | abs |
def | reciprocal |
def | scale |
def | update |
def | clone |
def | createMultiVector |
def | norm |
def | innerProduct |
def | length |
def | getVectorSpace |
Public Attributes | |
this | |
Static Public Attributes | |
CreateView = ___init__.Vector_CreateView | |
CreateCopy = ___init__.Vector_CreateCopy |
Implementation of NOX::Abstract::Vector for Epetra vectors. C++ includes: NOX_Epetra_Vector.H
def PyTrilinos::NOX::Epetra::Vector::__init__ | ( | self, | ||
args | ||||
) |
__init__(self, Teuchos::RCP<(Epetra_Vector)> source, MemoryType memoryType = CreateCopy, CopyType type = DeepCopy, Teuchos::RCP<(NOX::Epetra::VectorSpace)> vs = Teuchos::null) -> Vector __init__(self, Epetra_Vector source, CopyType type = DeepCopy, Teuchos::RCP<(NOX::Epetra::VectorSpace)> vs = Teuchos::null) -> Vector __init__(self, Vector source, CopyType type = DeepCopy) -> Vector NOX::Epetra::Vector::Vector(const NOX::Epetra::Vector &source, NOX::CopyType type=NOX::DeepCopy) Copy constructor.
def PyTrilinos::NOX::Epetra::Vector::__init__ | ( | self, | ||
args | ||||
) |
__init__(self, Teuchos::RCP<(Epetra_Vector)> source, MemoryType memoryType = CreateCopy, CopyType type = DeepCopy, Teuchos::RCP<(NOX::Epetra::VectorSpace)> vs = Teuchos::null) -> Vector __init__(self, Epetra_Vector source, CopyType type = DeepCopy, Teuchos::RCP<(NOX::Epetra::VectorSpace)> vs = Teuchos::null) -> Vector __init__(self, Vector source, CopyType type = DeepCopy) -> Vector NOX::Epetra::Vector::Vector(const NOX::Epetra::Vector &source, NOX::CopyType type=NOX::DeepCopy) Copy constructor.
def PyTrilinos::NOX::Epetra::Vector::abs | ( | self, | ||
args | ||||
) |
abs(self, Vector y) -> Vector abs(self, Vector y) -> Vector NOX::Abstract::Vector & NOX::Epetra::Vector::abs(const NOX::Abstract::Vector &y) 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
def PyTrilinos::NOX::Epetra::Vector::abs | ( | self, | ||
args | ||||
) |
abs(self, Vector y) -> Vector abs(self, Vector y) -> Vector NOX::Abstract::Vector & NOX::Epetra::Vector::abs(const NOX::Abstract::Vector &y) 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
def PyTrilinos::NOX::Epetra::Vector::clone | ( | self, | ||
args | ||||
) |
clone(self, CopyType type = DeepCopy) -> Teuchos::RCP<(NOX::Abstract::Vector)> Teuchos::RCP< NOX::Abstract::Vector > NOX::Epetra::Vector::clone(CopyType type=DeepCopy) const 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.
def PyTrilinos::NOX::Epetra::Vector::clone | ( | self, | ||
args | ||||
) |
clone(self, CopyType type = DeepCopy) -> Teuchos::RCP<(NOX::Abstract::Vector)> Teuchos::RCP< NOX::Abstract::Vector > NOX::Epetra::Vector::clone(CopyType type=DeepCopy) const 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.
def PyTrilinos::NOX::Epetra::Vector::createMultiVector | ( | self, | ||
args | ||||
) |
createMultiVector(self, Vector vecs, int numVecs, CopyType type = DeepCopy) -> Teuchos::RCP<(NOX::Abstract::MultiVector)> createMultiVector(self, int numVecs, CopyType type = DeepCopy) -> Teuchos::RCP<(NOX::Abstract::MultiVector)> Teuchos::RCP< NOX::Abstract::MultiVector > NOX::Epetra::Vector::createMultiVector(int numVecs, NOX::CopyType type=NOX::DeepCopy) const Create a MultiVector with numVecs columns. The implementation here creates a NOX::Epetra::MultiVector with either Shape or Deep copies of the supplied vector.
def PyTrilinos::NOX::Epetra::Vector::createMultiVector | ( | self, | ||
args | ||||
) |
createMultiVector(self, Vector vecs, int numVecs, CopyType type = DeepCopy) -> Teuchos::RCP<(NOX::Abstract::MultiVector)> createMultiVector(self, int numVecs, CopyType type = DeepCopy) -> Teuchos::RCP<(NOX::Abstract::MultiVector)> Teuchos::RCP< NOX::Abstract::MultiVector > NOX::Epetra::Vector::createMultiVector(int numVecs, NOX::CopyType type=NOX::DeepCopy) const Create a MultiVector with numVecs columns. The implementation here creates a NOX::Epetra::MultiVector with either Shape or Deep copies of the supplied vector.
def PyTrilinos::NOX::Epetra::Vector::getEpetraVector | ( | self, | ||
args | ||||
) |
getEpetraVector(self) -> Epetra_Vector const Epetra_Vector & NOX::Epetra::Vector::getEpetraVector() const Get const reference to underlying Epetra vector.
def PyTrilinos::NOX::Epetra::Vector::getEpetraVector | ( | self, | ||
args | ||||
) |
getEpetraVector(self) -> Epetra_Vector const Epetra_Vector & NOX::Epetra::Vector::getEpetraVector() const Get const reference to underlying Epetra vector.
def PyTrilinos::NOX::Epetra::Vector::getVectorSpace | ( | self, | ||
args | ||||
) |
getVectorSpace(self) -> Teuchos::RCP<(NOX::Epetra::VectorSpace)> Teuchos::RCP< NOX::Epetra::VectorSpace > NOX::Epetra::Vector::getVectorSpace() const Returns the NOX::Epetra::VectorSpace associated with this vector.
def PyTrilinos::NOX::Epetra::Vector::getVectorSpace | ( | self, | ||
args | ||||
) |
getVectorSpace(self) -> Teuchos::RCP<(NOX::Epetra::VectorSpace)> Teuchos::RCP< NOX::Epetra::VectorSpace > NOX::Epetra::Vector::getVectorSpace() const Returns the NOX::Epetra::VectorSpace associated with this vector.
def PyTrilinos::NOX::Epetra::Vector::init | ( | self, | ||
args | ||||
) |
init(self, double gamma) -> Vector NOX::Abstract::Vector & NOX::Epetra::Vector::init(double gamma) 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
def PyTrilinos::NOX::Epetra::Vector::init | ( | self, | ||
args | ||||
) |
init(self, double gamma) -> Vector NOX::Abstract::Vector & NOX::Epetra::Vector::init(double gamma) 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
def PyTrilinos::NOX::Epetra::Vector::innerProduct | ( | self, | ||
args | ||||
) |
innerProduct(self, Vector y) -> double innerProduct(self, Vector y) -> double double NOX::Epetra::Vector::innerProduct(const NOX::Abstract::Vector &y) const 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$
def PyTrilinos::NOX::Epetra::Vector::innerProduct | ( | self, | ||
args | ||||
) |
innerProduct(self, Vector y) -> double innerProduct(self, Vector y) -> double double NOX::Epetra::Vector::innerProduct(const NOX::Abstract::Vector &y) const 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$
def PyTrilinos::NOX::Epetra::Vector::length | ( | self, | ||
args | ||||
) |
length(self) -> int int NOX::Epetra::Vector::length() const 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.
def PyTrilinos::NOX::Epetra::Vector::length | ( | self, | ||
args | ||||
) |
length(self) -> int int NOX::Epetra::Vector::length() const 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.
def PyTrilinos::NOX::Epetra::Vector::norm | ( | self, | ||
args | ||||
) |
norm(self, NormType type = TwoNorm) -> double norm(self, Vector weights) -> double norm(self, Vector weights) -> double double NOX::Epetra::Vector::norm(const NOX::Abstract::Vector &weights) const 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 $
def PyTrilinos::NOX::Epetra::Vector::norm | ( | self, | ||
args | ||||
) |
norm(self, NormType type = TwoNorm) -> double norm(self, Vector weights) -> double norm(self, Vector weights) -> double double NOX::Epetra::Vector::norm(const NOX::Abstract::Vector &weights) const 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 $
def PyTrilinos::NOX::Epetra::Vector::random | ( | self, | ||
args | ||||
) |
random(self, bool useSeed = False, int seed = 1) -> Vector NOX::Abstract::Vector & NOX::Epetra::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
def PyTrilinos::NOX::Epetra::Vector::random | ( | self, | ||
args | ||||
) |
random(self, bool useSeed = False, int seed = 1) -> Vector NOX::Abstract::Vector & NOX::Epetra::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
def PyTrilinos::NOX::Epetra::Vector::reciprocal | ( | self, | ||
args | ||||
) |
reciprocal(self, Vector y) -> Vector reciprocal(self, Vector y) -> Vector NOX::Abstract::Vector & NOX::Epetra::Vector::reciprocal(const NOX::Abstract::Vector &y) 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
def PyTrilinos::NOX::Epetra::Vector::reciprocal | ( | self, | ||
args | ||||
) |
reciprocal(self, Vector y) -> Vector reciprocal(self, Vector y) -> Vector NOX::Abstract::Vector & NOX::Epetra::Vector::reciprocal(const NOX::Abstract::Vector &y) 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
def PyTrilinos::NOX::Epetra::Vector::scale | ( | self, | ||
args | ||||
) |
scale(self, double gamma) -> Vector scale(self, Vector a) -> Vector scale(self, Vector a) -> Vector NOX::Abstract::Vector & NOX::Epetra::Vector::scale(const NOX::Abstract::Vector &a) 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
def PyTrilinos::NOX::Epetra::Vector::scale | ( | self, | ||
args | ||||
) |
scale(self, double gamma) -> Vector scale(self, Vector a) -> Vector scale(self, Vector a) -> Vector NOX::Abstract::Vector & NOX::Epetra::Vector::scale(const NOX::Abstract::Vector &a) 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
def PyTrilinos::NOX::Epetra::Vector::update | ( | self, | ||
args | ||||
) |
update(self, double alpha, Vector a, double gamma = 0.0) -> Vector update(self, double alpha, Vector a, double gamma = 0.0) -> Vector update(self, double alpha, Vector a, double beta, Vector b, double gamma = 0.0) -> Vector update(self, double alpha, Vector a, double beta, Vector b, double gamma = 0.0) -> Vector NOX::Abstract::Vector & NOX::Epetra::Vector::update(double alpha, const NOX::Abstract::Vector &a, double beta, const NOX::Abstract::Vector &b, double gamma=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
def PyTrilinos::NOX::Epetra::Vector::update | ( | self, | ||
args | ||||
) |
update(self, double alpha, Vector a, double gamma = 0.0) -> Vector update(self, double alpha, Vector a, double gamma = 0.0) -> Vector update(self, double alpha, Vector a, double beta, Vector b, double gamma = 0.0) -> Vector update(self, double alpha, Vector a, double beta, Vector b, double gamma = 0.0) -> Vector NOX::Abstract::Vector & NOX::Epetra::Vector::update(double alpha, const NOX::Abstract::Vector &a, double beta, const NOX::Abstract::Vector &b, double gamma=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