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