Main Page | Class Hierarchy | Alphabetical List | Class List | File List | Class Members | File Members | Search for 

Komplex_MultiVector Class Reference

Komplex_MultiVector: A class for constructing and using equivalent real formulations of dense complex multivectors, vectors and matrices in parallel. More...

#include <Komplex_MultiVector.hpp>

Inheritance diagram for Komplex_MultiVector:

[legend]
Collaboration diagram for Komplex_MultiVector:
[legend]
List of all members.

Post-construction modification routines.

 with (ScalarValueReal, ScalarValueImag).int ReplaceGlobalValue(int GlobalRow
 Replace current (Real, Imaginary) value at the specified (GlobalRow, VectorIndex) location.
with ScalarValue int ReplaceGlobalValueReal (int GlobalRow, int VectorIndex, double ScalarValue)
 Replace real part of the current value at the specified (GlobalRow, VectorIndex) location.
with ScalarValue int ReplaceGlobalValueImag (int GlobalRow, int VectorIndex, double ScalarValue)
 Replace imaginary part of the current value at the specified (GlobalRow, VectorIndex) location.
location with (ScalarValueReal, ScalarValueImaginary).int ReplaceGlobalValue(int GlobalBlockRow
 Replace current (Real, Imaginary) value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex).
location with ScalarValue int ReplaceGlobalValueReal (int GlobalBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue)
 Replace real part of the current value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex).
location with ScalarValue int ReplaceGlobalValueImag (int GlobalBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue)
 Replace imaginary part of the current value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex).
int SumIntoGlobalValue (int GlobalRow, int VectorIndex, double ScalarValueReal, double ScalarValueImag)
 Adds the given real and imaginary values to existing values at the specified (GlobalRow, VectorIndex) location.
int SumIntoGlobalValueReal (int GlobalRow, int VectorIndex, double ScalarValue)
 Adds the given real value to existing real value at the specified (GlobalRow, VectorIndex) location.
int SumIntoGlobalValueImag (int GlobalRow, int VectorIndex, double ScalarValue)
 Adds the given imaginary value to existing imaginary value at the specified (GlobalRow, VectorIndex) location.
int SumIntoGlobalValue (int GlobalBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValueReal, double ScalarValueImag)
 Adds the given real and imaginary values to existing value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex) location.
int SumIntoGlobalValueReal (int GlobalBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue)
 Adds the given real value to existing real value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex) location.
int SumIntoGlobalValueImag (int GlobalBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue)
 Adds the given imaginary value to existing imaginary value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex) location.
int ReplaceMyValue (int MyRow, int VectorIndex, double ScalarValueReal, double ScalarValueImag)
 Replace current value at the specified (MyRow, VectorIndex) location with (ScalarValueReal, ScalarValueImag).
int ReplaceMyValueReal (int MyRow, int VectorIndex, double ScalarValue)
 Replace current real value at the specified (MyRow, VectorIndex) location with ScalarValue.
int ReplaceMyValueImag (int MyRow, int VectorIndex, double ScalarValue)
 Replace current imaginary value at the specified (MyRow, VectorIndex) location with ScalarValue.
ScalarValueImag int ReplaceMyValue (int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValueReal, double ScalarValueImag)
 Replace current value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location with (ScalarValueReal,.
int ReplaceMyValueReal (int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue)
 Replace current real value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location with ScalarValue.
int ReplaceMyValueImag (int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue)
 Replace current imaginary value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location with ScalarValue.
int SumIntoMyValue (int MyRow, int VectorIndex, double ScalarValueReal, double ScalarValueImag)
 Adds (ScalarValueReal, ScalarValueImag) to existing value at the specified (MyRow, VectorIndex) location.
int SumIntoMyValueReal (int MyRow, int VectorIndex, double ScalarValue)
 Adds ScalarValue to existing real part of the value at the specified (MyRow, VectorIndex) location.
int SumIntoMyValueImag (int MyRow, int VectorIndex, double ScalarValue)
 Adds ScalarValue to existing imaginary part of the value at the specified (MyRow, VectorIndex) location.
int SumIntoMyValue (int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValueReal, double ScalarValueImag)
 Adds (ScalarValueReal, ScalarValueImag) to existing value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location.
int SumIntoMyValueReal (int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue)
 Adds ScalarValue to existing real part of the value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location.
int SumIntoMyValueImag (int MyBlockRow, int BlockRowOffset, int VectorIndex, double ScalarValue)
 Adds ScalarValue to existing imaginary part of the value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location.
int VectorIndex
int double ScalarValueReal
int double double ScalarValueImag
location int BlockRowOffset
location int int VectorIndex
location int int double ScalarValueReal
location int int double double ScalarValueImaginary

Public Member Functions

int ReplaceMap (const Epetra_BlockMap &map)
 Replace map, only if new map has same point-structure as current map.
void PrintReal (ostream &os)
void PrintImag (ostream &os)
int ReplaceMap (const Epetra_BlockMap &Map)
 Replace map, only if new map has same point-structure as current map.
Constructors/destructors.
 Komplex_MultiVector (const Epetra_BlockMap &Map, int NumVectors, bool RHS, bool zeroOut=true, Komplex_KForms KForm=K1)
 Basic Komplex_MultiVector constuctor.
 Komplex_MultiVector (const Komplex_MultiVector &Source)
 Komplex_MultiVector copy constructor.
 Komplex_MultiVector (Epetra_DataAccess CV, const Epetra_BlockMap &Map, double *A, int MyLDA, int NumVectors, bool RHS, Komplex_KForms KForm=K1)
 Set multivector values from two-dimensional array.
 Komplex_MultiVector (Epetra_DataAccess CV, const Epetra_BlockMap &Map, double *Real, double *Imag, int MyLDA, int NumVectors, bool RHS, Komplex_KForms KForm=K1)
 Set multivector values from two two-dimensional arrays.
 Komplex_MultiVector (Epetra_DataAccess CV, const Epetra_BlockMap &Map, double **ArrayOfPointers, int NumVectors, bool RHS, Komplex_KForms KForm=K1)
 Set multivector values from array of pointers.
 Komplex_MultiVector (Epetra_DataAccess CV, const Epetra_BlockMap &Map, double **AOPReal, double **AOPImag, int NumVectors, bool RHS, Komplex_KForms KForm=K1)
 Set multivector values from two arrays of pointers, representing the real and imaginary parts.
 Komplex_MultiVector (Epetra_DataAccess CV, const Epetra_MultiVector &Source, int *Indices, int NumVectors, bool RHS, Komplex_KForms KForm=K1)
 Set multivector values from list of vectors in an existing Epetra_MultiVector.
 Komplex_MultiVector (Epetra_DataAccess CV, const Epetra_MultiVector &Source, int StartIndex, int NumVectors, bool RHS, Komplex_KForms KForm=K1)
 Set multivector values from range of vectors in an existing Epetra_MultiVector.
 Komplex_MultiVector (Epetra_DataAccess CV, const Epetra_MultiVector &Source, bool RHS, Komplex_KForms KForm=K1)
 Set multivector values from an existing Epetra_MultiVector, with the real and imaginary parts interleaved.
 Komplex_MultiVector (Epetra_DataAccess CV, const Epetra_MultiVector &Real, const Epetra_MultiVector &Imag, bool RHS, Komplex_KForms KForm=K1)
 Set multivector values from two Epetra_MultiVectors, one representing the real and the other the imaginary values.
virtual ~Komplex_MultiVector ()
 Komplex_MultiVector destructor.
Post-construction modification routines.
int ReplaceGlobalValue (int GlobalRow, int VectorIndex, double ScalarValue)
 Replace current value at the specified (GlobalRow, VectorIndex) location with ScalarValue.
int SumIntoGlobalValue (int GlobalRow, int VectorIndex, double ScalarValue)
 Add ScalarValue to existing value at the specified (GlobalRow, VectorIndex) location.
int ReplaceMyValue (int MyRow, int VectorIndex, double ScalarValue)
 Replace current value at the specified (MyRow, VectorIndex) location with ScalarValue.
int SumIntoMyValue (int MyRow, int VectorIndex, double ScalarValue)
 Add ScalarValue to existing value at the specified (MyRow, VectorIndex) location.
int PutScalar (double ScalarConstant)
 Initialize all values in a multivector with constant value.
int Random ()
 Set multivector values to random numbers.
void CreateOtherMap ()
 Creates a map one-half or twice the size of the existing map, allowing for return of the real parts, the imaginary parts, or an interleaved multivector when given the opposite in the constructor.
Mathematical methods.
int Dot (const Komplex_MultiVector &A, double *Result) const
 Computes dot product of each corresponding pair of vectors.
int Abs (const Komplex_MultiVector &A)
 Puts element-wise absolute values of input multivector in target.
int Reciprocal (const Komplex_MultiVector &A)
 Puts element-wise reciprocal values of input multivector in target.
int Scale (double ScalarValue)
 Scale the current values of a multivector, this = ScalarValue*this.
int Scale (double ScalarA, const Komplex_MultiVector &A)
 Replace multivector values with scaled values of A, this = ScalarA*A.
int Update (double ScalarA, const Komplex_MultiVector &A, double ScalarThis)
 Update multivector values with scaled values of A, this = ScalarThis*this + ScalarA*A.
int Update (double ScalarA, const Komplex_MultiVector &A, double ScalarB, const Komplex_MultiVector &B, double ScalarThis)
 Update multivector with scaled values of A and B, this = ScalarThis*this + ScalarA*A + ScalarB*B.
int Norm1 (double *Result) const
 Compute the 1-norm of each vector in multivector.
int ComplexNorm1 (double *Result) const
 Compute the 1-norm of each vector, regarded as a complex vector, in multivector.
int Norm2 (double *Result) const
 Compute the 2-norm of each vector in multivector.
int ComplexNorm2 (double *Result) const
 Compute the 2-norm of each vector, regarded as a complex vector, in multivector.
int NormInf (double *Result) const
 Compute the Inf-norm of each vector in multivector.
int ComplexNormInf (double *Result) const
 Compute the Inf-norm of each vector, regarded as a comnplex vector, in multivector.
int NormWeighted (const Epetra_MultiVector &Weights, double *Result) const
 Compute the Weighted 2-norm (RMS Norm) of each vector in multivector.
int MinValue (double *Result) const
 Compute minimum value of each vector in multivector.
int MaxValue (double *Result) const
 Compute maximum value of each vector in multivector.
int MeanValue (double *Result) const
 Compute mean (average) value of each vector in multivector.
Random number utilities
int SetSeed (unsigned int Seed)
 Set seed for Random function.
unsigned int Seed () const
 Get seed from Random function.
Overloaded operators
Komplex_MultiVector & operator= (const Komplex_MultiVector &Source)
 = Operator.
double *& operator[] (int i)
 Vector access function.
double *const & operator[] (int i) const
 Vector access function.
Epetra_MultiVector * EpetraMultiVector () const
 Conversion to Epetra_MultiVector.
Epetra_MultiVector * RealMultiVector () const
 Conversion of real parts to Epetra_MultiVector.
Epetra_MultiVector * ImagMultiVector () const
 Conversion of imaginary parts to Epetra_MultiVector.
Epetra_Vector * EpetraVector (int index) const
 Single vector conversion to Epetra_Vector.
Epetra_Vector * RealVector (int index) const
 Single vector conversion to Epetra_Vector, including only the real values.
Epetra_Vector * ImagVector (int index) const
 Single vector conversion to Epetra_Vector, including only the imaginary values.
double *& RealValues (int i) const
 Vector access function.
double *& ImagValues (int i) const
 Vector access function.
Attribute access functions
int NumVectors () const
 Returns the number of vectors in the multivector.
int MyLength () const
 Returns the local vector length on the calling processor of vectors in the multivector.
int GlobalLength () const
 Returns the global vector length of vectors in the multivector.
Komplex_KForms KForm () const
 Returns the current K form.
bool RHS () const
 Returns true if this is a right-hand side multivector, false otherwise.
int SwitchKForm (Komplex_KForms NewKForm)
 Switches the current K form.
I/O methods
virtual void Print (ostream &os) const
 Print method.
Constructors/destructors.
 Komplex_MultiVector (const Epetra_BlockMap &Map, int NumVectors, bool zeroOut=true)
 Basic Komplex_MultiVector constuctor with one map.
 Komplex_MultiVector (const Epetra_BlockMap &MapReal, const Epetra_BlockMap &MapImag, int NumVectors, bool zeroOut=true)
 Basic Komplex_MultiVector constuctor with two maps.
 Komplex_MultiVector (const Epetra_BlockMap &Map, const Epetra_MultiVector &Br, const Epetra_MultiVector &Bi)
 General Komplex_MultiVector constructor with one map.
 Komplex_MultiVector (const Epetra_BlockMap &MapReal, const Epetra_BlockMap &MapImag, const Epetra_MultiVector &Br, const Epetra_MultiVector &Bi)
 General Komplex_MultiVector constructor with two maps.
 Komplex_MultiVector (const Komplex_MultiVector &Source)
 Komplex_MultiVector copy constructor.
 Komplex_MultiVector (Komplex_DataAccess CV, const Komplex_MultiVector &Source, int *Indices, int NumVectors)
 Set multi-vector values from list of vectors in an existing Komplex_MultiVector.
 Komplex_MultiVector (Komplex_DataAccess CV, const Komplex_MultiVector &Source, int StartIndex, int NumVectors)
 Set multi-vector values from range of vectors in an existing Komplex_MultiVector.
virtual ~Komplex_MultiVector ()
 Komplex_MultiVector destructor.
Mathematical methods.
int Scale (double ScalarValue)
 Scale the current values of a multi-vector, this = ScalarValue*this.
part separately int Scale (double ScalarValueReal, double ScalarValueImag)
 Scale the current values of a multi-vector, scaling the real and the imaginary.
int Scale (double ScalarA, const Komplex_MultiVector &A)
 Replace multi-vector values with scaled values of A, this = ScalarA*A.
parts separately int Scale (double ScalarAReal, double ScalarAImag, const Komplex_MultiVector &A)
 Replace multi-vector values with scaled values of A, scaling the real and the imaginary.
int Norm1 (double *Result) const
 Compute 1-norm of each vector in multi-vector.
int Norm2 (double *Result) const
 Compute 2-norm of each vector in multi-vector.
int NormInf (double *Result) const
 Compute Inf-norm of each vector in multi-vector.
int Multiply (char TransA, char TransB, double ScalarAB, const Komplex_MultiVector &A, const Komplex_MultiVector &B, double ScalarThis)
 Matrix-Matrix multiplication, this = ScalarThis*this + ScalarAB*A*B.
int Multiply (double ScalarAB, const Komplex_MultiVector &A, const Komplex_MultiVector &B, double ScalarThis)
 Multiply a Komplex_MultiVector with another, element-by-element.
Overloaded operators
Komplex_MultiVector & operator= (const Komplex_MultiVector &Source)
 = Operator.
double *& operator[] (int i)
 Vector access function.
double *const & operator[] (int i) const
 Vector access function.
Komplex_Vector *& operator() (int i)
 Vector access function.
const Komplex_Vector *& operator() (int i) const
 Vector access function.
Attribute access functions
int NumVectors () const
 Returns the number of vectors in the multi-vector.
int MyLength () const
 Returns the local vector length on the calling processor of vectors in the multi-vector.
int GlobalLength () const
 Returns the global vector length of vectors in the multi-vector.
int Stride () const
 Returns the stride between vectors in the multi-vector (only meaningful if ConstantStride() is true).
bool ConstantStride () const
 Returns true if this multi-vector has constant stride between vectors.
I/O methods
void Print (ostream &os) const
 Print method.

Protected Member Functions

void CreateHalfMap ()
void CreateDoubleMap ()

Detailed Description

Komplex_MultiVector: A class for constructing and using equivalent real formulations of dense complex multivectors, vectors and matrices in parallel.

The Komplex_MultiVector class enables the construction and use of equivalent real formulations of complex-valued, double-precision dense vectors, multivectors, and matrices in a distributed memory environment. The dimensions and distribution of the dense multivectors is determined by the Komplex_MultiVector object(s) as described below.

There are several concepts that important for understanding the Komplex_MultiVector class:

Constructing Komplex_MultiVectors

Except for the basic constructor and copy constructor, Komplex_MultiVector constructors have two data access modes:

  1. Copy mode - Allocates memory and makes a copy of the user-provided data. In this case, the user data is not needed after construction.
  2. View mode - Creates a "view" of the user data. In this case, the user data is required to remain intact for the life of the multivector.

Warning:
View mode is extremely dangerous from a data hiding perspective. Therefore, we strongly encourage users to develop code using Copy mode first and only use the View mode in a secondary optimization phase.
There are ten different Komplex_MultiVector constructors:

Extracting Data from Komplex_MultiVectors

Once a Komplex_MultiVector is constructed, it is possible to view it as an Epetra_MultiVector.

Vector, Matrix and Utility Functions

Once a Komplex_MultiVector is constructed, a variety of mathematical functions can be applied to the individual vectors. Specifically:

In addition, a matrix-matrix multiply function supports a variety of operations on any viable combination of global distributed and local replicated multivectors using calls to DGEMM, a high performance kernel for matrix operations. In the near future we will add support for calls to other selected BLAS and LAPACK functions.

Counting Floating Point Operations

Each Komplex_MultiVector 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.

Constructor & Destructor Documentation

Komplex_MultiVector::Komplex_MultiVector (  const Epetra_BlockMap &  Map,
int  NumVectors,
bool  RHS,
bool  zeroOut = true,
Komplex_KForms  KForm = K1
) 
 

Basic Komplex_MultiVector constuctor.

Creates a Komplex_MultiVector object and, by default, fills with zero values.

Parameters:
Map (In) A Epetra_LocalMap, Epetra_Map or Epetra_BlockMap.
NumVectors (In) Number of vectors in multivector.
RHS (In) If true, then the multivector will be treated as a right-hand side multivector; if false, as a left-hand side multivector.
zeroOut (In) If true then the allocated memory will be zeroed out initially. If false then this memory will not be touched, which can be significantly faster.
KForm (In) The Komplex_KForms to use for this multivector; by default, it is set to K1.
Returns:
Pointer to a Komplex_MultiVector.
Warning:
Note that, because Epetra_LocalMap derives from Epetra_Map and Epetra_Map derives from Epetra_BlockMap, this constructor works for all three types of Epetra map classes.

Komplex_MultiVector::Komplex_MultiVector (  Epetra_DataAccess  CV,
const Epetra_BlockMap &  Map,
double *  A,
int  MyLDA,
int  NumVectors,
bool  RHS,
Komplex_KForms  KForm = K1
) 
 

Set multivector values from two-dimensional array.

Parameters:
Epetra_DataAccess (In) Enumerated type set to Copy or View.
Map (In) A Epetra_LocalMap, Epetra_Map or Epetra_BlockMap.
A (In) Pointer to an array of double precision numbers. The first vector starts at A. The second vector starts at A+MyLDA, the third at A+2*MyLDA, and so on.
MyLDA (In) The "Leading Dimension" or stride between vectors in memory.
Warning:
This value refers to the stride on the calling processor. Thus it is a local quantity, not a global quantity.
Parameters:
NumVectors (In) Number of vectors in multivector.
RHS (In) If true, then the multivector will be treated as a right-hand side multivector; if false, as a left-hand side multivector.
KForm (In) The Komplex_KForms to use for this multivector; by default, it is set to K1.
Returns:
Integer error code, set to 0 if successful.
See Detailed Description section for further discussion.

Komplex_MultiVector::Komplex_MultiVector (  Epetra_DataAccess  CV,
const Epetra_BlockMap &  Map,
double *  Real,
double *  Imag,
int  MyLDA,
int  NumVectors,
bool  RHS,
Komplex_KForms  KForm = K1
) 
 

Set multivector values from two two-dimensional arrays.

Parameters:
Epetra_DataAccess (In) Enumerated type set to Copy or View.
Map (In) A Epetra_LocalMap, Epetra_Map or Epetra_BlockMap.
Real (In) Pointer to an array of double precision numbers representing the real parts. The first vector starts at Real. The second vector starts at Real+MyLDA, the third at Real+2*MyLDA, and so on.
Imag (In) Pointer to an array of double precision numbers representing the imaginary parts. The first vector starts at Imag. The second vector starts at Imag+MyLDA, the third at Imag+2*MyLDA, and so on.
MyLDA (In) The "Leading Dimension" or stride between vectors in memory.
Warning:
This value refers to the stride on the calling processor. Thus it is a local quantity, not a global quantity.
Parameters:
NumVectors (In) Number of vectors in multivector.
RHS (In) If true, then the multivector will be treated as a right-hand side multivector; if false, as a left-hand side multivector.
KForm (In) The Komplex_KForms to use for this multivector; by default, it is set to K1.
Returns:
Integer error code, set to 0 if successful.
See Detailed Description section for further discussion. (YES OR NO????????)

Komplex_MultiVector::Komplex_MultiVector (  Epetra_DataAccess  CV,
const Epetra_BlockMap &  Map,
double **  ArrayOfPointers,
int  NumVectors,
bool  RHS,
Komplex_KForms  KForm = K1
) 
 

Set multivector values from array of pointers.

Parameters:
Epetra_DataAccess (In) Enumerated type set to Copy or View.
Map (In) A Epetra_LocalMap, Epetra_Map or Epetra_BlockMap.
ArrayOfPointers (In) An array of pointers such that ArrayOfPointers[i] points to the memory location containing the ith vector to be copied.
NumVectors (In) Number of vectors in multivector.
RHS (In) If true, then the multivector will be treated as a right-hand side multivector; if false, as a left-hand side multivector.
KForm (In) The Komplex_KForms to use for this multivector; by default, it is set to K1.
Returns:
Integer error code, set to 0 if successful.
See Detailed Description section for further discussion.

Komplex_MultiVector::Komplex_MultiVector (  Epetra_DataAccess  CV,
const Epetra_BlockMap &  Map,
double **  AOPReal,
double **  AOPImag,
int  NumVectors,
bool  RHS,
Komplex_KForms  KForm = K1
) 
 

Set multivector values from two arrays of pointers, representing the real and imaginary parts.

Parameters:
Epetra_DataAccess (In) Enumerated type set to Copy or View.
Map (In) A Epetra_LocalMap, Epetra_Map or Epetra_BlockMap.
AOPReal (In) An array of pointers such that AOPReal[i] points to the memory location containing the ith real vector to be copied.
AOPImag (In) An array of pointers such that AOPImag[i] points to the memory location containing the ith imaginary vector to be copied.
NumVectors (In) Number of vectors in multivector.
RHS (In) If true, then the multivector will be treated as a right-hand side multivector; if false, as a left-hand side multivector.
KForm (In) The Komplex_KForms to use for this multivector; by default, it is set to K1.
Returns:
Integer error code, set to 0 if successful.
See Detailed Description section for further discussion.

Komplex_MultiVector::Komplex_MultiVector (  Epetra_DataAccess  CV,
const Epetra_MultiVector &  Source,
int *  Indices,
int  NumVectors,
bool  RHS,
Komplex_KForms  KForm = K1
) 
 

Set multivector values from list of vectors in an existing Epetra_MultiVector.

Parameters:
Epetra_DataAccess (In) Enumerated type set to Copy or View.
Source (In) An existing fully constructed Epetra_MultiVector.
Indices (In) Integer list of the vectors to copy.
NumVectors (In) Number of vectors in multivector.
RHS (In) If true, then the multivector will be treated as a right-hand side multivector; if false, as a left-hand side multivector.
KForm (In) The Komplex_KForms to use for this multivector; by default, it is set to K1.
Returns:
Integer error code, set to 0 if successful.
See Detailed Description section for further discussion.

Komplex_MultiVector::Komplex_MultiVector (  Epetra_DataAccess  CV,
const Epetra_MultiVector &  Source,
int  StartIndex,
int  NumVectors,
bool  RHS,
Komplex_KForms  KForm = K1
) 
 

Set multivector values from range of vectors in an existing Epetra_MultiVector.

Parameters:
Epetra_DataAccess (In) Enumerated type set to Copy or View.
Source (In) An existing fully constructed Epetra_MultiVector.
StartIndex (In) First of the vectors to copy.
NumVectors (In) Number of vectors in multivector.
RHS (In) If true, then the multivector will be treated as a right-hand side multivector; if false, as a left-hand side multivector.
KForm (In) The Komplex_KForms to use for this multivector; by default, it is set to K1.
Returns:
Integer error code, set to 0 if successful.
See Detailed Description section for further discussion.

Komplex_MultiVector::Komplex_MultiVector (  Epetra_DataAccess  CV,
const Epetra_MultiVector &  Source,
bool  RHS,
Komplex_KForms  KForm = K1
) 
 

Set multivector values from an existing Epetra_MultiVector, with the real and imaginary parts interleaved.

Parameters:
Epetra_DataAccess (In) Enumerated type set to Copy of View.
Source (In) An existing fully constructed Epetra_MultiVector.
RHS (In) If true, then the multivector will be treated as a right-hand side multivector; if false, as a left-hand side multivector.
KForm (In) The Komplex_KForms to use for this multivector; by default, it is set to K1.
Returns:
Integer error code, set to 0 if successful.
See Detailed Description secton for further discussion.

Komplex_MultiVector::Komplex_MultiVector (  Epetra_DataAccess  CV,
const Epetra_MultiVector &  Real,
const Epetra_MultiVector &  Imag,
bool  RHS,
Komplex_KForms  KForm = K1
) 
 

Set multivector values from two Epetra_MultiVectors, one representing the real and the other the imaginary values.

Parameters:
Epetra_DataAccess (In) Enumerated type set to Copy or View.
Real (In) An existing fully constructed Epetra_MultiVector representing the real values.
Imag (In) An existing fully constructed Epetra_MultiVector representing the imaginary values.
RHS (In) If true, then the multivector will be treated as a right-hand side multivector; if false, as a left-hand side multivector.
KForm (In) The Komplex_KForms to use for this multivector; by default, it is set to K1.
Returns:
Integer error code, set to 0 if successful.
See Detailed Description section for further discussion.

Warning:
Real and Imag must have the same Epetra_Map

Komplex_MultiVector::Komplex_MultiVector (  const Epetra_BlockMap &  Map,
int  NumVectors,
bool  zeroOut = true
) 
 

Basic Komplex_MultiVector constuctor with one map.

Creates a Komplex_MultiVector object and, by default, fills it with zero values.

Parameters:
In Map - A Epetra_LocalMap, Epetra_Map or Epetra_BlockMap for the memory layout of both the real and the imaginary parts.
Warning:
Note that, because Epetra_LocalMap derives from Epetra_Map and Epetra_Map derives from Epetra_BlockMap, this constructor works for all three types of Epetra map classes.
Parameters:
In NumVectors - Number of vectors in multi-vector.
In zeroOut - If true then the allocated memory will be zeroed out initially. If false then this memory will not be touched which can be significantly faster.
Returns:
Pointer to a Komplex_MultiVector.

Komplex_MultiVector::Komplex_MultiVector (  const Epetra_BlockMap &  MapReal,
const Epetra_BlockMap &  MapImag,
int  NumVectors,
bool  zeroOut = true
) 
 

Basic Komplex_MultiVector constuctor with two maps.

Creates a Komplex_MultiVector object and, by default, fills it with zero values.

Parameters:
In MapReal - A Epetra_LocalMap, Epetra_Map or Epetra_BlockMap for the memory layout of the real parts. MapImag - A Epetra_LocalMap, Epetra_Map or Epetra_BlockMap for the memory layout of the imaginary parts.
Warning:
Note that, because Epetra_LocalMap derives from Epetra_Map and Epetra_Map derives from Epetra_BlockMap, this constructor works for all three types of Epetra map classes.
Parameters:
In NumVectors - Number of vectors in multi-vector.
In zeroOut - If true then the allocated memory will be zeroed out initially. If false then this memory will not be touched which can be significantly faster.
Returns:
Pointer to a Komplex_MultiVector.

Komplex_MultiVector::Komplex_MultiVector (  const Epetra_BlockMap &  Map,
const Epetra_MultiVector &  Br,
const Epetra_MultiVector &  Bi
) 
 

General Komplex_MultiVector constructor with one map.

Parameters:
In Map - A Epetra_LocalMap, Epetra_Map, or Epetra_BlockMap for the memory layout of both the real and imaginary parts
In Br - A Epetra_MultiVector containing the real parts of the complex multi-vector
In Bi - A Epetra_MultiVector containing the imaginary parts of the complex multi-vector

Komplex_MultiVector::Komplex_MultiVector (  const Epetra_BlockMap &  MapReal,
const Epetra_BlockMap &  MapImag,
const Epetra_MultiVector &  Br,
const Epetra_MultiVector &  Bi
) 
 

General Komplex_MultiVector constructor with two maps.

Parameters:
In MapReal - A Epetra_LocalMap, Epetra_Map, or Epetra_BlockMap for the memory layout of the real parts
In MapImag - A Epetra_Local Map, Epetra_Map, or Epetra_BlockMap for the memory layout of the imaginary parts
In Br - A Epetra_MultiVector containing the real parts of the complex multi-vector
In Bi - A Epetra_MultiVector containing the imaginary parts of the complex multi-vector

Komplex_MultiVector::Komplex_MultiVector (  Komplex_DataAccess  CV,
const Komplex_MultiVector &  Source,
int *  Indices,
int  NumVectors
) 
 

Set multi-vector values from list of vectors in an existing Komplex_MultiVector.

Parameters:
In Komplex_DataAccess - Enumerated type set to Copy or View.
In Source - An existing fully constructed Komplex_MultiVector.
In Indices - Integer list of the vectors to copy.
In NumVectors - Number of vectors in multi-vector.
Returns:
Integer error code, set to 0 if successful. See Detailed Description section for further discussion.

Komplex_MultiVector::Komplex_MultiVector (  Komplex_DataAccess  CV,
const Komplex_MultiVector &  Source,
int  StartIndex,
int  NumVectors
) 
 

Set multi-vector values from range of vectors in an existing Komplex_MultiVector.

Parameters:
In Komplex_DataAccess - Enumerated type set to Copy or View.
In Source - An existing fully constructed Komplex_MultiVector.
In StartIndex - First of the vectors to copy.
In NumVectors - Number of vectors in multi-vector.
Returns:
Integer error code, set to 0 if successful. See Detailed Description section for further discussion.

Member Function Documentation

int Komplex_MultiVector::Abs (  const Komplex_MultiVector &  A  ) 
 

Puts element-wise absolute values of input multivector in target.

Parameters:
A (In) Input multivector.
Postcondition:
On return, this will contain the absolute values of the entries of A.
Returns:
Integer error code, set to 0 if successful.
Note: It is possible to use the same argument for A and this.

int Komplex_MultiVector::ComplexNorm1 (  double *  Result  )  const
 

Compute the 1-norm of each vector, regarded as a complex vector, in multivector.

Parameters:
Result (Out) Result[i] contains the 1-norm of the ith vector.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::ComplexNorm2 (  double *  Result  )  const
 

Compute the 2-norm of each vector, regarded as a complex vector, in multivector.

Parameters:
Result (Out) Result[i] contains the 2-norm of the ith vector.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::ComplexNormInf (  double *  Result  )  const
 

Compute the Inf-norm of each vector, regarded as a comnplex vector, in multivector.

Parameters:
Result (Out) Result[i] contains the Inf-norm of the ith vector.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::Dot (  const Komplex_MultiVector &  A,
double *  Result
)  const
 

Computes dot product of each corresponding pair of vectors.

Parameters:
A (In) Multivector to be used with the this multivector.
Result (Out) Result[i] will contain the ith dot product result.
Returns:
Integer error code, set to 0 if successful.

Epetra_MultiVector * Komplex_MultiVector::EpetraMultiVector (   )  const
 

Conversion to Epetra_MultiVector.

Returns:
A Epetra_MultiVector pointer to the multivector.

Epetra_Vector * Komplex_MultiVector::EpetraVector (  int  index  )  const
 

Single vector conversion to Epetra_Vector.

Returns:
A Epetra_Vector pointer to the ith vector in the multivector.

Epetra_MultiVector * Komplex_MultiVector::ImagMultiVector (   )  const
 

Conversion of imaginary parts to Epetra_MultiVector.

Returns:
A Epetra_MultiVector with the imaginary parts.

double *& Komplex_MultiVector::ImagValues (  int  i  )  const
 

Vector access function.

Returns:
Pointer to the array of doubles containing the imaginary parts of the local values of the ith vector in the multivector.

Epetra_Vector * Komplex_MultiVector::ImagVector (  int  index  )  const
 

Single vector conversion to Epetra_Vector, including only the imaginary values.

Returns:
A Epetra_Vector containing the imaginary values of the ith vector.

int Komplex_MultiVector::MaxValue (  double *  Result  )  const
 

Compute maximum value of each vector in multivector.

Parameters:
Result (Out) Result[i] contains the maximum value of the ith vector.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::MeanValue (  double *  Result  )  const
 

Compute mean (average) value of each vector in multivector.

Parameters:
Result (Out) Result[i] contains the mean value of the ith vector.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::MinValue (  double *  Result  )  const
 

Compute minimum value of each vector in multivector.

Parameters:
Result (Out) Result[i] contains the minimum value of the ith vector.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::Multiply (  double  ScalarAB,
const Komplex_MultiVector &  A,
const Komplex_MultiVector &  B,
double  ScalarThis
) 
 

Multiply a Komplex_MultiVector with another, element-by-element.

This function supports diagonal matrix multiply. A is usually a single vector while B and this may have one or more columns. Note that B and this must have the same shape. A can be one vector or have the same shape as B. The actual computation is this = ScalarThis * this + ScalarAB * B @ A where @ denotes element-wise multiplication.

int Komplex_MultiVector::Multiply (  char  TransA,
char  TransB,
double  ScalarAB,
const Komplex_MultiVector &  A,
const Komplex_MultiVector &  B,
double  ScalarThis
) 
 

Matrix-Matrix multiplication, this = ScalarThis*this + ScalarAB*A*B.

This function performs a variety of matrix-matrix multiply operations, interpreting the Komplex_MultiVectors (this-aka C , A and B) as 2D matrices. Variations are due to the fact that A, B and C can be local replicated or global distributed Komplex_MultiVectors and that we may or may not operate with the transpose of A and B. Possible cases are: 


    Total of 32 case (2^5).
    Num
    OPERATIONS                             case Notes
    1) C(local) = A^X(local) * B^X(local)  4    (X=Transpose or Not, No comm needed) 
    2) C(local) = A^T(distr) * B  (distr)  1    (2D dot product, replicate C)
    3) C(distr) = A  (distr) * B^X(local)  2    (2D vector update, no comm needed)

    Note that the following operations are not meaningful for 
    1D distributions:

    1) C(local) = A^T(distr) * B^T(distr)  1
    2) C(local) = A  (distr) * B^X(distr)  2
    3) C(distr) = A^X(local) * B^X(local)  4
    4) C(distr) = A^X(local) * B^X(distr)  4
    5) C(distr) = A^T(distr) * B^X(local)  2
    6) C(local) = A^X(distr) * B^X(local)  4
    7) C(distr) = A^X(distr) * B^X(local)  4
    8) C(local) = A^X(local) * B^X(distr)  4

Parameters:
In TransA - Operate with the transpose of A if = 'T', else no transpose if = 'N'.
In TransB - Operate with the transpose of B if = 'T', else no transpose if = 'N'.
In ScalarAB - Scalar to multiply with A*B.
In A - Multi-vector.
In B - Multi-vector.
In ScalarThis - Scalar to multiply with this.
Returns:
Integer error code, set to 0 if successful.
Warning:
{Each multi-vector A, B and this is checked if it has constant stride using the ConstantStride() query function. If it does not have constant stride, a temporary copy is made and used for the computation. This activity is transparent to the user, except that there is memory and computation overhead. All temporary space is deleted prior to exit.}

int Komplex_MultiVector::Norm1 (  double *  Result  )  const
 

Compute 1-norm of each vector in multi-vector.

Parameters:
Out Result - Result[i] contains 1-norm of ith vector.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::Norm1 (  double *  Result  )  const
 

Compute the 1-norm of each vector in multivector.

Parameters:
Result (Out) Result[i] contains the 1-norm of the ith vector.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::Norm2 (  double *  Result  )  const
 

Compute 2-norm of each vector in multi-vector.

Parameters:
Out Result - Result[i] contains 2-norm of ith vector.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::Norm2 (  double *  Result  )  const
 

Compute the 2-norm of each vector in multivector.

Parameters:
Result (Out) Result[i] contains the 2-norm of the ith vector.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::NormInf (  double *  Result  )  const
 

Compute Inf-norm of each vector in multi-vector.

Parameters:
Out Result - Result[i] contains Inf-norm of ith vector.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::NormInf (  double *  Result  )  const
 

Compute the Inf-norm of each vector in multivector.

Parameters:
Result (Out) Result[i] contains the Inf-norm of the ith vector.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::NormWeighted (  const Epetra_MultiVector &  Weights,
double *  Result
)  const
 

Compute the Weighted 2-norm (RMS Norm) of each vector in multivector.

Parameters:
Weights (In) Multivector of weights. If Weights contains a single vector, that vector will be used as the weights for all vectors of this. Otherwise, Weights should have the same number of vectors as this.
Result (Out) Result[i] contains the weighted 2-norm of ith vector. Specifically if we denote the ith vector in the multivector by $x$, and the ith weight vector by $w$ and let j represent the jth entry of each vector, on return Result[i] will contain the following result:

\[\sqrt{(1/n)\sum_{j=1}^n(x_j/w_j)^2}\]

, where $n$ is the global length of the vectors.

Returns:
Integer error code, set to 0 if successful.

const Komplex_Vector* & Komplex_MultiVector::operator() (  int  i  )  const
 

Vector access function.

Returns:
A Komplex_Vector pointer to the ith vector in the multi-vector.

Komplex_Vector*& Komplex_MultiVector::operator() (  int  i  ) 
 

Vector access function.

Returns:
A Komplex_Vector pointer to the ith vector in the multi-vector.

Komplex_MultiVector& Komplex_MultiVector::operator= (  const Komplex_MultiVector &  Source  ) 
 

= Operator.

Parameters:
In A - Komplex_MultiVector to copy.
Returns:
Komplex_MultiVector.

Komplex_MultiVector & Komplex_MultiVector::operator= (  const Komplex_MultiVector &  Source  ) 
 

= Operator.

Parameters:
A (In) Komplex_MultiVector to copy.
Returns:
Komplex_MultiVector.

double* const& Komplex_MultiVector::operator[] (  int  i  )  const
 

Vector access function.

Returns:
Pointer to the array of doubles containing the local values of the ith vector in the multi-vector.

Reimplemented in Komplex_Vector, and Komplex_Vector.

double*& Komplex_MultiVector::operator[] (  int  i  ) 
 

Vector access function.

Returns:
Pointer to the array of doubles containing the local values of the ith vector in the multi-vector.

Reimplemented in Komplex_Vector, and Komplex_Vector.

double *const & Komplex_MultiVector::operator[] (  int  i  )  const
 

Vector access function.

Returns:
Pointer to the array of doubles containing the local values of the ith vector in the multivector.

Reimplemented in Komplex_Vector, and Komplex_Vector.

double *& Komplex_MultiVector::operator[] (  int  i  ) 
 

Vector access function.

Returns:
Pointer to the array of doubles containing the local values of the ith vector in the multivector.

Reimplemented in Komplex_Vector, and Komplex_Vector.

int Komplex_MultiVector::PutScalar (  double  ScalarConstant  ) 
 

Initialize all values in a multivector with constant value.

Parameters:
ScalarConstant (In) Value to use.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::Random (   ) 
 

Set multivector values to random numbers.

This uses the random number generator provided by Epetra_Util. The multivector values will be set to random values on the interval (-1.0, 1.0).

Returns:
Integer error code, set to 0 if successful.

Epetra_MultiVector * Komplex_MultiVector::RealMultiVector (   )  const
 

Conversion of real parts to Epetra_MultiVector.

Returns:
A Epetra_MultiVector with the real parts.

double *& Komplex_MultiVector::RealValues (  int  i  )  const
 

Vector access function.

Returns:
Pointer to the array of doubles containing the real parts of the local values of the ith vector in the multivector.

Epetra_Vector * Komplex_MultiVector::RealVector (  int  index  )  const
 

Single vector conversion to Epetra_Vector, including only the real values.

Returns:
A Epetra_Vector containing the real values of the ith vector.

int Komplex_MultiVector::Reciprocal (  const Komplex_MultiVector &  A  ) 
 

Puts element-wise reciprocal values of input multivector in target.

Parameters:
A (In) Input multivector.
Postcondition:
On return, this will contain the element-wise reciprocal values of the entries of A.
Returns:
Integer error code, set to 0 if successful. Returns 2 if some entry is too small, but not zero. Returns 1 if some entry is zero.
Note: It is possible to use the same argument for A and this. Also, if a given value of A is smaller than Epetra_DoubleMin (defined in Epetra_Epetra.h), but nonzero, then the return code is 2. If an entry is zero, the return code is 1. However, in all cases the reciprocal value is still used, even if a NaN is the result.

int Komplex_MultiVector::ReplaceGlobalValue (  int  GlobalRow,
int  VectorIndex,
double  ScalarValue
) 
 

Replace current value at the specified (GlobalRow, VectorIndex) location with ScalarValue.

Replaces the existing value for a single entry in the multivector. The specified global row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

If the map associated with this multivector is an Epetra_BlockMap, only the first point entry associated with the global row will be modified. To modify a different point entry, use the other version of this method

Parameters:
GlobalRow (In) Row of multivector to modify in global index space.
VectorIndex (In) Vector within multivector to modify.
ScalarValue (In) Value to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if GlobalRow is not associated with calling processor, set to -1 if VectorIndex >= NumVectors().

location with ScalarValue int Komplex_MultiVector::ReplaceGlobalValueImag (  int  GlobalBlockRow,
int  BlockRowOffset,
int  VectorIndex,
double  ScalarValue
) 
 

Replace imaginary part of the current value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex).

Replaces the existing value for a single entry in the multivector. The specified global block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

Parameters:
In GlobalBlockRow - BlockRow of Multivector to modify in global index space.
In BlockRowOffset - Offset into BlockRow of Multivector to modify in global index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Value to replace the existing imaginary part.
Returns:
Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.

with ScalarValue int Komplex_MultiVector::ReplaceGlobalValueImag (  int  GlobalRow,
int  VectorIndex,
double  ScalarValue
) 
 

Replace imaginary part of the current value at the specified (GlobalRow, VectorIndex) location.

Replaces the existing value for a single entry in the multivector. The specified global row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

If the map associated with this multivector is an Epetra_BlockMap, only the first point entry associated with the global row will be modified. To modify a different point entry, use the other version of this method.

Parameters:
In GlobalRow - Row of Multivector to modify in global index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Value to replace the existing imaginary part.
Returns:
Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors().

location with ScalarValue int Komplex_MultiVector::ReplaceGlobalValueReal (  int  GlobalBlockRow,
int  BlockRowOffset,
int  VectorIndex,
double  ScalarValue
) 
 

Replace real part of the current value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex).

Replaces the existing value for a single entry in the multivector. The specified global block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

Parameters:
In GlobalBlockRow - BlockRow of Multivector to modify in global index space.
In BlockRowOffset - Offset into BlockRow of Multivector to modify in global index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Value to replace the existing real part.
Returns:
Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.

with ScalarValue int Komplex_MultiVector::ReplaceGlobalValueReal (  int  GlobalRow,
int  VectorIndex,
double  ScalarValue
) 
 

Replace real part of the current value at the specified (GlobalRow, VectorIndex) location.

Replaces the existing value for a single entry in the multivector. The specified global row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

If the map associated with this multivector is an Epetra_BlockMap, only the first point entry associated with the global row will be modified. To modify a different point entry, use the other version of this method.

Parameters:
In GlobalRow - Row of Multivector to modify in global index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Value to replace the existing real part.
Returns:
Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors().

int Komplex_MultiVector::ReplaceMap (  const Epetra_BlockMap &  map  ) 
 

Replace map, only if new map has same point-structure as current map.

Returns:
0 if map is replaced, -1 if not.

Reimplemented in Komplex_Vector, and Komplex_Vector.

ScalarValueImag int Komplex_MultiVector::ReplaceMyValue (  int  MyBlockRow,
int  BlockRowOffset,
int  VectorIndex,
double  ScalarValueReal,
double  ScalarValueImag
) 
 

Replace current value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location with (ScalarValueReal,.

Replaces the existing value for a single entry in the multivector. The specified local block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

Parameters:
In MyBlockRow - BlockRow of Multivector to modify in local index space.
In BlockRowOffset - Offset into BlockRow of Multivector to modify in local index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValueReal - Real part to replace the existing value.
In ScalarValueImag - Imaginary part to replace the existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.

int Komplex_MultiVector::ReplaceMyValue (  int  MyRow,
int  VectorIndex,
double  ScalarValueReal,
double  ScalarValueImag
) 
 

Replace current value at the specified (MyRow, VectorIndex) location with (ScalarValueReal, ScalarValueImag).

Replaces the existing value for a single entry in the multivector. The specified local row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

This method is intended for use with vectors based on an Epetra_Map. If used on a vector based on a non-trivial Epetra_BlockMap, this will update only block row 0, i.e.

Komplex_MultiVector::ReplaceMyValue ( MyRow, VectorIndex, ScalarValueReal, ScalarValueImag ) is equivalent to: Komplex_MultiVector::ReplaceMyValue ( 0, MyRow, VectorIndex, ScalarValueReal, ScalarValueImag )

Parameters:
In MyRow - Row of Multivector to modify in local index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValueReal - Real part to replace the existing value.
In ScalarValueImag - Imaginary part to replace the existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors().

int Komplex_MultiVector::ReplaceMyValue (  int  MyRow,
int  VectorIndex,
double  ScalarValue
) 
 

Replace current value at the specified (MyRow, VectorIndex) location with ScalarValue.

Replaces the existing value for a single entry in the multivector. The specified local row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

This method is intended for use with vectors based on an Epetra_Map. If used on a vector based on a non-trivial Epetra_BlockMap, this will update only block row 0, i.e.

Komplex_MultiVector::ReplaceMyValue (MyRow, VectorIndex, ScalarValue) is equivalent to: Komplex_MultiVector::ReplaceMyValue (0, MyRow, VectorIndex, ScalarValue)

Parameters:
MyRow (In) Row of multivector to modify in local index space.
VectorIndex (In) Vector within multivector to modify.
ScalarValue (In) Value to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if MyRow is not associated with calling processor, set to -1 if VectorIndex >= NumVectors().

int Komplex_MultiVector::ReplaceMyValueImag (  int  MyBlockRow,
int  BlockRowOffset,
int  VectorIndex,
double  ScalarValue
) 
 

Replace current imaginary value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location with ScalarValue.

Replaces the existing value for a single entry in the multivector. The specified local block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

Parameters:
In MyBlockRow - BlockRow of Multivector to modify in local index space.
In BlockRowOffset - Offset into BlockRow of Multivector to modify in local index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Imaginary part to replace the existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.

int Komplex_MultiVector::ReplaceMyValueImag (  int  MyRow,
int  VectorIndex,
double  ScalarValue
) 
 

Replace current imaginary value at the specified (MyRow, VectorIndex) location with ScalarValue.

Replaces the existing value for a single entry in the multivector. The specified local row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

This method is intended for use with vectors based on an Epetra_Map. If used on a vector based on a non-trivial Epetra_BlockMap, this will update only block row 0, i.e.

Komplex_MultiVector::ReplaceMyValueImag ( MyRow, VectorIndex, ScalarValue ) is equivalent to: Komplex_MultiVector::ReplaceMyValueImag ( 0, MyRow, VectorIndex, ScalarValue )

Parameters:
In MyRow - Row of Multivector to modify in local index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Imaginary part to replace the existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors().

int Komplex_MultiVector::ReplaceMyValueReal (  int  MyBlockRow,
int  BlockRowOffset,
int  VectorIndex,
double  ScalarValue
) 
 

Replace current real value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location with ScalarValue.

Replaces the existing value for a single entry in the multivector. The specified local block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

Parameters:
In MyBlockRow - BlockRow of Multivector to modify in local index space.
In BlockRowOffset - Offset into BlockRow of Multivector to modify in local index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Real part to replace the existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.

int Komplex_MultiVector::ReplaceMyValueReal (  int  MyRow,
int  VectorIndex,
double  ScalarValue
) 
 

Replace current real value at the specified (MyRow, VectorIndex) location with ScalarValue.

Replaces the existing value for a single entry in the multivector. The specified local row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

This method is intended for use with vectors based on an Epetra_Map. If used on a vector based on a non-trivial Epetra_BlockMap, this will update only block row 0, i.e.

Komplex_MultiVector::ReplaceMyValueReal ( MyRow, VectorIndex, ScalarValue ) is equivalent to: Komplex_MultiVector::ReplaceMyValueReal ( 0, MyRow, VectorIndex, ScalarValue )

Parameters:
In MyRow - Row of Multivector to modify in local index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Real part to replace the existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors().

parts separately int Komplex_MultiVector::Scale (  double  ScalarAReal,
double  ScalarAImag,
const Komplex_MultiVector &  A
) 
 

Replace multi-vector values with scaled values of A, scaling the real and the imaginary.

Parameters:
In ScalarAReal - Scale value for the real parts.
In ScalarAImag - Scale value for the imaginary parts.
In A - Multi-vector to copy.
Out This - Multi-vector with values overwritten by scaled values of A.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::Scale (  double  ScalarA,
const Komplex_MultiVector &  A
) 
 

Replace multi-vector values with scaled values of A, this = ScalarA*A.

Parameters:
In ScalarA - Scale value.
In A - Multi-vector to copy.
Out This - Multi-vector with values overwritten by scaled values of A.
Returns:
Integer error code, set to 0 if successful.

part separately int Komplex_MultiVector::Scale (  double  ScalarValueReal,
double  ScalarValueImag
) 
 

Scale the current values of a multi-vector, scaling the real and the imaginary.

Parameters:
In ScalarValueReal - Scale value for the real parts.
In ScalarValueImag - Scale value for the imaginary parts.
Out This - Multi-vector with scaled values.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::Scale (  double  ScalarValue  ) 
 

Scale the current values of a multi-vector, this = ScalarValue*this.

Parameters:
In ScalarValue - Scale value.
Out This - Multi-vector with scaled values.
Returns:
Integer error code, set to 0 if successful.

Reimplemented in Komplex_Vector, and Komplex_Vector.

int Komplex_MultiVector::Scale (  double  ScalarA,
const Komplex_MultiVector &  A
) 
 

Replace multivector values with scaled values of A, this = ScalarA*A.

Parameters:
ScalarA (In) Scale value.
A (In) Multivector to copy.
Postcondition:
On return, this will contain the scaled values of A.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::Scale (  double  ScalarValue  ) 
 

Scale the current values of a multivector, this = ScalarValue*this.

Parameters:
ScalarValue (In) Scale value.
Postcondition:
On return, this will contain the scaled values.
Returns:
Integer error code, set to 0 if successful.

Reimplemented in Komplex_Vector, and Komplex_Vector.

unsigned int Komplex_MultiVector::Seed (   )  const
 

Get seed from Random function.

Returns:
Current random number seed.

int Komplex_MultiVector::SetSeed (  unsigned int  Seed  ) 
 

Set seed for Random function.

Parameters:
Seed (In) Should be an integer on the interval (0, 2^31-1).
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::SumIntoGlobalValue (  int  GlobalBlockRow,
int  BlockRowOffset,
int  VectorIndex,
double  ScalarValueReal,
double  ScalarValueImag
) 
 

Adds the given real and imaginary values to existing value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex) location.

Sums the given (real, imaginary) value into the existing value for a single entry in the multivector. The specified global block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

Parameters:
In GlobalBlockRow - BlockRow of Multivector to modify in global index space.
In BlockRowOffset - Offset into BlockRow of Multivector to modify in global index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValueReal - Real part to add to existing value.
In ScalarValueImag - Imaginary part to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.

int Komplex_MultiVector::SumIntoGlobalValue (  int  GlobalRow,
int  VectorIndex,
double  ScalarValueReal,
double  ScalarValueImag
) 
 

Adds the given real and imaginary values to existing values at the specified (GlobalRow, VectorIndex) location.

Sums the given (real, imaginary) value into the existing value for a single entry in the multivector. The specified global row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

If the map associated with this multivector is an Epetra_BlockMap, only the first point entry associated with the global row will be modified. To modify a different point entry, use the other version of this method.

Parameters:
In GlobalRow - Row of Multivector to modify in global index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValueReal - Real part to add to existing value.
In ScalarValueImag - Imaginary part to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors().

int Komplex_MultiVector::SumIntoGlobalValue (  int  GlobalRow,
int  VectorIndex,
double  ScalarValue
) 
 

Add ScalarValue to existing value at the specified (GlobalRow, VectorIndex) location.

Sums the given value into the existing value for a single entry in the multivector. The specified global row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

If the map associated with this multivector is an Epetra_BlockMap, only the first point entry associated with the global row will be modified. To modify a different point entry, use the other version of this method

Parameters:
GlobalRow (In) Row of multivector to modify in global index space.
VectorIndex (In) Vector within multivector to modify.
ScalarValue (In) Value to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if GlobalRow is not associated with calling processor, set to -1 if VectorIndex >= NumVectors().

int Komplex_MultiVector::SumIntoGlobalValueImag (  int  GlobalBlockRow,
int  BlockRowOffset,
int  VectorIndex,
double  ScalarValue
) 
 

Adds the given imaginary value to existing imaginary value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex) location.

Sums the given imaginary value into the existing value for a single entry in the multivector. The specified global block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

Parameters:
In GlobalBlockRow - BlockRow of Multivector to modify in global index space.
In BlockRowOffset - Offset into BlockRow of Multivector to modify in global index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Imaginary part to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.

int Komplex_MultiVector::SumIntoGlobalValueImag (  int  GlobalRow,
int  VectorIndex,
double  ScalarValue
) 
 

Adds the given imaginary value to existing imaginary value at the specified (GlobalRow, VectorIndex) location.

Sums the given imaginary ScalarValue into the existing value for a single entry in the multivector. The specified global row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

If the map associated with this multivector is an Epetra_BlockMap, only the first point entry associated with the global row will be modified. To modify a different point entry, use the other version of this method.

Parameters:
In GlobalRow - Row of Multivector to modify in global index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Imaginary part to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors().

int Komplex_MultiVector::SumIntoGlobalValueReal (  int  GlobalBlockRow,
int  BlockRowOffset,
int  VectorIndex,
double  ScalarValue
) 
 

Adds the given real value to existing real value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex) location.

Sums the given real value into the existing value for a single entry in the multivector. The specified global block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

Parameters:
In GlobalBlockRow - BlockRow of Multivector to modify in global index space.
In BlockRowOffset - Offset into BlockRow of Multivector to modify in global index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Real part to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.

int Komplex_MultiVector::SumIntoGlobalValueReal (  int  GlobalRow,
int  VectorIndex,
double  ScalarValue
) 
 

Adds the given real value to existing real value at the specified (GlobalRow, VectorIndex) location.

Sums the given real ScalarValue into the existing value for a single entry in the multivector. The specified global row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

If the map associated with this multivector is an Epetra_BlockMap, only the first point entry associated with the global row will be modified. To modify a different point entry, use the other version of this method.

Parameters:
In GlobalRow - Row of Multivector to modify in global index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Real part to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors().

int Komplex_MultiVector::SumIntoMyValue (  int  MyBlockRow,
int  BlockRowOffset,
int  VectorIndex,
double  ScalarValueReal,
double  ScalarValueImag
) 
 

Adds (ScalarValueReal, ScalarValueImag) to existing value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location.

Sums the given value into the existing value for a single entry in the multivector. The specified local block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

Parameters:
In MyBlockRow - BlockRow of Multivector to modify in local index space.
In BlockRowOffset - Offset into BlockRow of Multivector to modify in local index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValueReal - Real part to add to existing value.
In ScalarValueImag - Imaginary part to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.

int Komplex_MultiVector::SumIntoMyValue (  int  MyRow,
int  VectorIndex,
double  ScalarValueReal,
double  ScalarValueImag
) 
 

Adds (ScalarValueReal, ScalarValueImag) to existing value at the specified (MyRow, VectorIndex) location.

Sums the given value into the existing value for a single entry in the multivector. The specified local row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

If the map associated with this multivector is an Epetra_BlockMap, only the first point entry associated with the local row will be modified. To modify a different point entry, use the other version of this method.

Parameters:
In MyRow - Row of Multivector to modify in local index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValueReal - Real part to add to existing value.
In ScalarValueImag - Imaginary part to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors().

int Komplex_MultiVector::SumIntoMyValue (  int  MyRow,
int  VectorIndex,
double  ScalarValue
) 
 

Add ScalarValue to existing value at the specified (MyRow, VectorIndex) location.

Sums the given value into the existing value for a single entry in the multivector. The specified local row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

If the map associated with this multivector is an Epetra_BlockMap, only the first point entry associated with the local row will be modified. To modify a different point entry, use the other version of this method

Parameters:
MyRow (In) Row of multivector to modify in local index space.
VectorIndex (In) Vector within multivector to modify.
ScalarValue (In) Value to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if MyRow is not associated with calling processor, set to -1 if VectorIndex >= NumVectors().

int Komplex_MultiVector::SumIntoMyValueImag (  int  MyBlockRow,
int  BlockRowOffset,
int  VectorIndex,
double  ScalarValue
) 
 

Adds ScalarValue to existing imaginary part of the value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location.

Sums the given value into the existing value for a single entry in the multivector. The specified local block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

Parameters:
In MyBlockRow - BlockRow of Multivector to modify in local index space.
In BlockRowOffset - Offset into BlockRow of Multivector to modify in local index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Imaginary part to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.

int Komplex_MultiVector::SumIntoMyValueImag (  int  MyRow,
int  VectorIndex,
double  ScalarValue
) 
 

Adds ScalarValue to existing imaginary part of the value at the specified (MyRow, VectorIndex) location.

Sums the given value into the existing value for a single entry in the multivector. The specified local row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

If the map associated with this multivector is an Epetra_BlockMap, only the first point entry associated with the local row will be modified. To modify a different point entry, use the other version of this method.

Parameters:
In MyRow - Row of Multivector to modify in local index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Imaginary part to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors().

int Komplex_MultiVector::SumIntoMyValueReal (  int  MyBlockRow,
int  BlockRowOffset,
int  VectorIndex,
double  ScalarValue
) 
 

Adds ScalarValue to existing real part of the value at the specified (MyBlockRow, BlockRowOffset, VectorIndex) location.

Sums the given value into the existing value for a single entry in the multivector. The specified local block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

Parameters:
In MyBlockRow - BlockRow of Multivector to modify in local index space.
In BlockRowOffset - Offset into BlockRow of Multivector to modify in local index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Real part to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.

int Komplex_MultiVector::SumIntoMyValueReal (  int  MyRow,
int  VectorIndex,
double  ScalarValue
) 
 

Adds ScalarValue to existing real part of the value at the specified (MyRow, VectorIndex) location.

Sums the given value into the existing value for a single entry in the multivector. The specified local row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

If the map associated with this multivector is an Epetra_BlockMap, only the first point entry associated with the local row will be modified. To modify a different point entry, use the other version of this method.

Parameters:
In MyRow - Row of Multivector to modify in local index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValue - Real part to add to existing value.
Returns:
Integer error code, set to 0 if successful, set to 1 if MyRow not associated with calling processor set to -1 if VectorIndex >= NumVectors().

int Komplex_MultiVector::SwitchKForm (  Komplex_KForms  NewKForm  ) 
 

Switches the current K form.

Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::Update (  double  ScalarA,
const Komplex_MultiVector &  A,
double  ScalarB,
const Komplex_MultiVector &  B,
double  ScalarThis
) 
 

Update multivector with scaled values of A and B, this = ScalarThis*this + ScalarA*A + ScalarB*B.

Parameters:
ScalarA (In) Scale value for A.
A (In) Multivector to add.
ScalarB (In) Scale value for B.
B (In) Multivector to add.
ScalarThis (In) Scale value for this.
Postcondition:
On return, this will contain the updated values.
Returns:
Integer error code, set to 0 if successful.

int Komplex_MultiVector::Update (  double  ScalarA,
const Komplex_MultiVector &  A,
double  ScalarThis
) 
 

Update multivector values with scaled values of A, this = ScalarThis*this + ScalarA*A.

Parameters:
ScalarA (In) Scale value for A.
A (In) Multivector to add.
ScalarThis (In) Scale value for this.
Postcondition:
On return, this will contain the updated values.
Returns:
Integer error code, set to 0 if successful.

location Komplex_MultiVector::with (  ScalarValueReal  ,
ScalarValueImaginary 
) 
 

Replace current (Real, Imaginary) value at the specified (GlobalBlockRow, BlockRowOffset, VectorIndex).

Replaces the existing value for a single entry in the multivector. The specified global block row and block row offset must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

Parameters:
In GlobalBlockRow - BlockRow of Multivector to modify in global index space.
In BlockRowOffset - Offset into BlockRow of Multivector to modify in global index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValueReal - Value to replace the existing real part.
In ScalarValueImag - Value to replace the existing imaginary part.
Returns:
Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors(), set to -2 if BlockRowOffset is out-of-range.

Komplex_MultiVector::with (  ScalarValueReal  ,
ScalarValueImag 
) 
 

Replace current (Real, Imaginary) value at the specified (GlobalRow, VectorIndex) location.

Replaces the existing value for a single entry in the multivector. The specified global row must correspond to a GID owned by the map of the multivector on the calling processor. In other words, this method does not perform cross-processor communication.

If the map associated with this multivector is an Epetra_BlockMap, only the first point entry associated with the global row will be modified. To modify a different point entry, use the other version of this method.

Parameters:
In GlobalRow - Row of Multivector to modify in global index space.
In VectorIndex - Vector within MultiVector to modify.
In ScalarValueReal - Value to replace the existing real part.
In ScalarValueImag - Value to replace the existing imaginary part.
Returns:
Integer error code, set to 0 if successful, set to 1 if GlobalRow not associated with calling processor set to -1 if VectorIndex >= NumVectors().

The documentation for this class was generated from the following files:
Generated on Thu Sep 18 12:38:11 2008 for Komplex by doxygen 1.3.9.1