Vector.h

Note

The documentation on this page was automatically extracted from the DOLFIN C++ code and may need to be edited or expanded.

class Vector

Parent class(es)

• GenericVector

This class provides the default DOLFIN vector class, based on the default DOLFIN linear algebra backend.

Vector()

Create empty vector

Vector(MPI_Comm comm, std::size_t N)

Create vector of size N

Vector(const Vector& x)

Copy constructor

Vector(const GenericVector& x)

Create a Vector from a GenericVector

std::shared_ptr<GenericVector> copy() const

Return copy of vector

void zero()

Set all entries to zero and keep any sparse structure

void apply(std::string mode)

Finalize assembly of tensor

MPI_Comm mpi_comm() const

Return MPI communicator

std::string str(bool verbose) const

Return informal string representation (pretty-print)

void init(MPI_Comm comm, std::size_t N)

Initialize vector to size N

void init(MPI_Comm comm, std::pair<std::size_t, std::size_t> range)

Initialize vector with given ownership range

void init(MPI_Comm comm, std::pair<std::size_t, std::size_t> range, const std::vector<std::size_t>& local_to_global_map, const std::vector<la_index>& ghost_indices)

Initialize vector with given ownership range and with ghost values

bool empty() const

Return true if vector is empty

std::size_t size() const

Return size of vector

std::size_t local_size() const

Return local size of vector

std::pair<std::size_t, std::size_t> local_range() const

Return local ownership range of a vector

bool owns_index(std::size_t i) const

Determine whether global vector index is owned by this process

void get(double* block, std::size_t m, const dolfin::la_index* rows) const

Get block of values using global indices (values must all live on the local process, ghosts are no accessible)

void get_local(double* block, std::size_t m, const dolfin::la_index* rows) const

Get block of values using local indices (values must all live on the local process)

void set(const double* block, std::size_t m, const dolfin::la_index* rows)

Set block of values using global indices

void set_local(const double* block, std::size_t m, const dolfin::la_index* rows)

Set block of values using local indices

void add(const double* block, std::size_t m, const dolfin::la_index* rows)

Add block of values using global indices

void add_local(const double* block, std::size_t m, const dolfin::la_index* rows)

Add block of values using local indices

void get_local(std::vector<double>& values) const

Get all values on local process

void set_local(const std::vector<double>& values)

Set all values on local process

void add_local(const Array<double>& values)

Add values to each entry on local process

void gather(GenericVector& x, const std::vector<dolfin::la_index>& indices) const

Gather entries into local vector x

void gather(std::vector<double>& x, const std::vector<dolfin::la_index>& indices) const

Gather entries into x

void gather_on_zero(std::vector<double>& x) const

Gather all entries into x on process 0

void axpy(double a, const GenericVector& x)

Add multiple of given vector (AXPY operation)

void abs()

Replace all entries in the vector by their absolute values

double inner(const GenericVector& x) const

Return inner product with given vector

double norm(std::string norm_type) const

Return norm of vector

double min() const

Return minimum value of vector

double max() const

Return maximum value of vector

double sum() const

Return sum of values of vector

const Vector& operator*=(double a)

Multiply vector by given number

const Vector& operator*=(const GenericVector& x)

Multiply vector by another vector pointwise

const Vector& operator/=(double a)

Divide vector by given number

const Vector& operator+=(const GenericVector& x)

Add given vector

const GenericVector& operator+=(double a)

Add number to all components of a vector

const Vector& operator-=(const GenericVector& x)

Subtract given vector

const GenericVector& operator-=(double a)

Subtract number from all components of a vector

const GenericVector& operator=(const GenericVector& x)

Assignment operator

const Vector& operator=(double a)

Assignment operator

GenericLinearAlgebraFactory& factory() const

Return linear algebra backend factory

const GenericVector* instance() const

Return concrete instance / unwrap (const version)

GenericVector* instance()

Return concrete instance / unwrap (non-const version)

const Vector& operator=(const Vector& x)

Assignment operator