Rodin namespace

Namespaces

namespace Assembly

Module for performing the assembly of linear algebra objects from variational expressions.

namespace Context

Module for serial, multi-threaded, distributed, and/or parallel computation.

namespace External

Third-party library integrations with Rodin.

namespace FormLanguage

Module for writing high level abstract expressions.

namespace Geometry

Module for dealing with geometries.

namespace IO

Module for dealing with I/O functionality.

namespace Math

Module for general mathematical operations.

namespace Models

Module which provides implementation of various variational models.

namespace Plot

Module for visualization tools.

namespace QF

Module for defining quadrature formulae.

namespace Solver

Module for linear algebra systems.

namespace Test

Module containing various utilities and classes for writing tests.

namespace Tests

Tests of the Rodin library

namespace Threads

Module containing various tools for working with threads.

namespace Traits

Module containing metaprogramming facilities.

namespace Utility

Module containing general purpose and language support utility classes.

namespace Variational

Module which provides the necessary tools for constructing variational problems.

Classes

struct IndexArrayEquality

Functor for comparing two index arrays for equality.

struct IndexArrayHash

Functor for computing a hash value for an index array.

struct IndexArraySymmetricEquality

Functor for comparing two index arrays for symmetric equality.

struct IndexArraySymmetricHash

Functor for computing a symmetric hash value for an index array.

struct IndexSetEquality

Functor for comparing two IndexSet objects for equality.

struct IndexSetHash

Functor for computing a hash value for an IndexSet.

template<class L, class R>

class Pair

A Pair class representing a tuple with two elements.

template<class T, class ... Ts>

class Tuple<T, Ts...>

A tuple class that extends std::tuple with additional functionality.

template<>

class Tuple<>

Specialization of Tuple for an empty parameter pack.

Typedefs

template<class ScalarType>

using Array = Eigen::ArrayX<ScalarType>

Alias for a dynamically sized array.

using IndexArray = Array<Index>

Alias for an index array.

using Integer = int

Standard type for representing integer values.

using Boolean = bool

Standard type for representing boolean values.

using Float = float

Standard type for representing (32 bit) floating-point values.

using Double = double

Standard type for representing double precision (64 bit) floating-point values.

using Index = std::size_t

Standard type for representing indices.

using Real = Double

Standard type for representing scalar values.

using Complex = std::complex<Real>

Standard type for representing complex values.

template<class T>

using List = boost::container::list<T>

Standard type for representing lists.

template<class T>

using Deque = boost::container::deque<T>

Standard type for representing deques.

template<class T, class Container = Deque<T>>

using Stack = std::stack<T, Container>

Standard type for representing stacks.

template<class T>

using FlatSet = boost::container::flat_set<T>

Standard flat set type.

template<class T>

using UnorderedSet = boost::unordered_set<T>

Standard unordered set type.

template<class K, class T>

using Map = boost::container::map<K, T>

Standard ordered map type.

template<class ... Params>

using UnorderedMap = boost::unordered_map<Params...>

Standard unordered map type.

template<class K, class T>

using FlatMap = boost::container::flat_map<K, T>

Standard flat map type.

using IndexSet = FlatSet<Index>

Standard set of indices.

template<class T>

using IndexMap = FlatMap<Index, T>

Standard map of indices.

Functions

template<class L, class R>

Pair(L, R) -> Pair< L, R >

Deduction guide for the Pair class.

template<Index First, Index Last>

static auto IndexTuple() -> auto constexpr

Generates a tuple of indices.

Typedef documentation

Function documentation