RVL Class List

Here are the classes, structs, unions and interfaces with brief descriptions:
RVL::AdjLinearOp< Scalar >AdjLinearOp creates the adjoint operator of an LinearOp as a linear operator in its own right
RVL::ANLOperator< Scalar >ANLOperator creates a nonlinear op from an affine operator
RVL::BlockFunctionObjectBlockFOs are arrays of FOs, which can be evaluated block-diagonal fashion on ProductDCs
RVL::BlockLinearOp< Scalar >Linear Operator defined with product range
RVL::BlockLinearOpBlock< Scalar >I,j block of BlockLinearOp, as LinearOp
RVL::BlockOperator< Scalar >Operator defined with product domain and range
RVL::CartesianPowerSpace< Scalar >This space implements the Cartesian power of a space
RVL::ColumnLinearOp< Scalar >Linear Operator defined with product range
RVL::CompLinearOp< Scalar >Composition of linear operators $ Op_1, Op_2 \mapsto Op_2 \circ Op_1 $ (so subscripts indicate order of evaluation - that's how the constructor is organized)
RVL::CompLOVOp< Scalar >Composition in the first component of LinOpValOp with arbitrary op - could be accomplished with DiagonalOp, this construction introduced for efficiency's sake
RVL::Components< Scalar >Provides indexed access to components (factors) of a Vector in ProductSpace
RVL::ConstLinOpValOp< Scalar >Given a linear operator F on x1, ConstLinOpValOp provides a LinOpValOp where F is considered constant wrt x0
RVL::DataContainerDataContainer is the principal RVL abstraction for types encapsulating data structures
RVL::DataContainerFactoryFactory class for DataContainers
RVL::Deriv2Evaluation< Scalar >Implements the 2nd derivative by delegating the implementation of the apply methods to the Operator class, by way of the Evaluation
RVL::DerivEvaluation< Scalar >Implements the derivative by delegating the implementation of the apply methods to the Operator class, by way of the Evaluation
RVL::DiagonalFunctionObjectProduces diagonal ("scalar") app of single FO to all components of ProductDC
RVL::DiagOp< Scalar >Explicit BlockOp construction for 2x2 diagonal
RVL::EuclideanForm< Scalar >This functional is the standard Euclidean Form $f(x) = 0.5 |x|^{2}$
RVL::Factory< T >Standard factory interface - really a policy
RVL::FcnlOpComp< Scalar >This handle class creates the composite of a functional and an operator $f(G(x))$, using the protected services of Operator and Functional
RVL::Functional< Scalar >Interface for scalar-valued vector functions
RVL::FunctionalEvaluation< Scalar >Evaluation is a pair of a (clone of a) Functional and an evaluation point Vector, stored by reference
RVL::FunctionalProductDomain< Scalar >A specialization of Functional which also has partial derivatives
RVL::FunctionalProductDomainEvaluation< Scalar >A specialization of FunctionalEvaluation which accesses the additional partial derivatives of the FunctionalProductDomain class
RVL::FunctionObjectThe FunctionObject / DataContainer hiearchy follows the Acyclic Visitor design pattern (see Martin 2002 for more on this)
RVL::FunctionObjectConstEvalMembership
RVL::FunctionObjectScalarRedn< ValType >Function object with const eval and scalar reduction attributes
RVL::HessianEvaluation< Scalar >The Hessian Evaluation is a lightweight implementation of the LinearOp interface which refers back to a FunctionalEvaluation to implement all methods
RVL::IdentityOp< Scalar >IdentityOp is a concrete class implementing identity operator
RVL::InjectOp< Scalar >Affine Injection operator
RVL::Invertible< Scalar >Invertible is a mixin interface for operators which can compute inverses
RVL::InvertibleDerivEvaluation< Scalar >Evaluation of derivative supplied with inverse mappings
RVL::LeastSquaresFcnlGN< Scalar >LeastSquaresFcnlGN creates a least squares objective function from an operator
RVL::LinCombFunctional< Scalar >LinCombFunctional is a concrete class implementing a linear combination of two or more Functional instances
RVL::LinCombLinearOp< Scalar >LinCombLinearOp is a concrete class implementing a linear combination with weights $ w_1, w_2 $ of two linear operators $ Op_1 $ and $ Op_2 $, that is, $w_1 Op_1 + w_2 Op_2$
RVL::LinCombObject< Scalar >LinCombObject is an subtype FunctionObject offering a method to set two mutable scalars a and b, intended to be coefficients in a linear combination
RVL::LinCombOperator< Scalar >LinCombOperator is a concrete class implementing a linear combination of two or more Operator instances
RVL::LinCompLOVOp< Scalar >Composition in the second component of LinOpValOp with arbitrary lop - could be accomplished with DiagonalOp, this construction introduced for efficiency's sake
RVL::LinearAlgebraPackage< Scalar >Interface to function objects defining the basic ops of linear algebra in Hilbert space: linear combination, assignment to the zero vector, and inner product
RVL::LinearBilinearOp< Scalar >LinearOp crreated by fixing the first argument in a bilinear op
RVL::LinearOp< Scalar >Principal RVL interface for Linear Operators
RVL::LinearOpAdjEvaluation< Scalar >Another convenience handle class used in formulation of linear combination, composition algorithms to avoid unnecessary temporary storage and computation, which would result from using OperatorEvaluation in the same settings
RVL::LinearOpEvaluation< Scalar >Convenience class used in formulation of linear combination, composition algorithms to avoid unnecessary temporary storage and computation, which would result from using OperatorEvaluation in the same settings
RVL::LinearOpFO< Scalar >Standard construction of a LinearOp, given spaces for domain and range and FunctionObjects implementing the forward and adjoint apply
RVL::LinearOpWithInverse< Scalar >Linear operator with inverse mapping supplied as a class method
RVL::LinearRestrictOp< Scalar >Create linear op by restricting the nonlinear variable in LinOpValOp
RVL::LinOpValOp< Scalar >Operator with product domain presumed to be linear in last component, from which a linear operator may be conveniently extracted by restriction
RVL::LNLOperator< Scalar >LNLOperator creates a nonlinear op from a linear operator
RVL::NormalLinearOp< Scalar >NormalLinearOp creates the normal operator $ A^*A $ of a LinearOp $ A $ as a linear operator in its own right
RVL::NullFunctional< Scalar >Null-functional
RVL::OpComp< Scalar >OpComp is a concrete class implementing composition of any number of Operator and/or LinearOp instancess
RVL::Operator< Scalar >Interface for vector-valued vector functions
RVL::OperatorEvaluation< Scalar >OperatorEvaluation pairs a reference to a Vector with an independent, dynamically-allocated instance of an Operator
RVL::OperatorProductDomain< Scalar >Operator defined on product space
RVL::OperatorProductDomainEvaluation< Scalar >Evaluation for product domain case, provided only for type-safety
RVL::OperatorWithInvertibleDeriv< Scalar >Operators whose derivatives are supplied with inverse mappings
RVL::OpFO< Scalar >Standard construction of an op, given spaces for domain and range and several FunctionObject instances implementing the various apply operations: in the notation of the main constructor OpFO::OpFO, the first FunctionObject argument (f) is used to implement OpFO::apply, the second (dff) to implement OpFO::applyDeriv, and the third (dfa) to implement OpFO::applyAdjDeriv
RVL::Oracle< T >Generic oracle interface
RVL::PartialDerivEvaluation< Scalar >Similar in structure to DerivEvaluation
RVL::Product< T >Simple Cartesian product mixin
RVL::ProductDataContainerProductDataContainers are DataContainers equipped with an indexing operator[], which returns a reference to a DataContainer when supplied with an in-range int index
RVL::ProductSpace< Scalar >Abstract base class expressing behaviour of Cartesian products of vector spaces
RVL::QuadraticForm< Scalar >QuadraticForm creates a function of the form $ x \mapsto \frac{1}{2} |A x|^2 $ in which A is a linear operator
RVL::ResidualOperator< Scalar >Given an input vector d, and an operator G, this operator implements $F(x) = G(x)-d$
RVL::RestrictFcnl< Scalar >Restriction operator - currently only for two-component domains
RVL::RestrictOp< Scalar >Restriction, or partial evaluation, of an operator on a product space
RVL::ROProduct< T >Simple Cartesian product mixin - read-only access to factors
RVL::RVLExceptionAn implementation of the std::exception interface, with additional methods so it can be used more like a output stream
RVL::ScalarFieldTraits< Scalar >A traits class to extend the capabilities of numeric_limits without duplicating such capabilities
RVL::ScalarFieldTraits< bool >
RVL::ScalarFieldTraits< double >
RVL::ScalarFieldTraits< float >
RVL::ScalarFieldTraits< int >
RVL::ScalarFieldTraits< long >
RVL::ScalarFieldTraits< std::complex< T > >
RVL::ScalarFieldTraits< unsigned int >
RVL::ScalarFieldTraits< unsigned long >
RVL::ScalarRedn< Scalar >Mixin class for types that store, update, and return "small" objects, meaning effectively those with usable copy semantics
RVL::ScaleOpFwd< Scalar >ScaleOpFwd implementing the linear operator $ x\mapsto ax $ where a is a scalar
RVL::ScaleOpInv< Scalar >ScaleOpInv implementing the linear operator $ x\mapsto \frac{1}{a}x $ where $ a $ is a scalar
RVL::ShiftedQuadraticForm< Scalar >ShiftedQuadraticForm creates a function of the form $ x \mapsto \frac{1}{2} |A x - b|^2 $ in which A is a linear operator, b a vector
RVL::ShiftOperator< Scalar >Given an input vector d, this operator implements $F(x) = x-d$
RVL::Space< Scalar >RVL abstract base class for Hilbert Spaces
RVL::SpaceDCF< Scalar >A converse to StdSpace: takes any space and makes manifest its inner DataContainerFactory
RVL::StdFOFunctional< Scalar, DataType >This class implements the Functional interface by combining the operation of three FunctionObjects and a domain Space
RVL::StdLeastSquaresFcnlGN< Scalar >StdLeastSquaresFcnlGN creates a least squares objective function from an operator and a data vector
RVL::StdProductDataContainerStandard implementation of ProductDataContainer
RVL::StdProductSpace< Scalar >Standard construction of product spaces, via an (STL) vector of dynamically allocated Spaces
RVL::StdSpace< Scalar, DataType >Standard modular RVL space class
RVL::SymmetricBilinearOp< Scalar >For the moment, a standalone class
RVL::TangentMap< Scalar >Standard example of LinOpValOp: $ (x,dx) \mapsto DF(x)dx$
RVL::TensorLinearOp< Scalar >Explicit ColumnLinearOp construction for two range components Y.H
RVL::TensorOp< Scalar >Explicit BlockOp construction for two range components
RVL::Vector< Scalar >RVL Vector class
RVL::WatchedVecRef< Scalar >This class references a vector and will store a version number
RVL::WriteableMixin interface to mandate write-to-ostream method, and derive write-to-exception method from it
Generated on 5 Jan 2017 for RVL by  doxygen 1.4.7