| CArray< T > | Safe arrays of arbitrary types.Class Array provides safe arrays of arbitrary type. Array elements are accessed just like ordinary C++ array elements by means of the index operator[](). Safety is provided by |
| CArray< DSVectorBase< Real > > | |
| CArray< soplex::UnitVectorBase > | |
| CSoPlex::Settings::BoolParam | |
| CSPxBoundFlippingRT::Breakpoint | |
| CSPxBoundFlippingRT::BreakpointCompare | |
| CClassArray< T > | Safe arrays of class objects.Class ClassArray provides safe arrays of general C++ objects (in contrast to data objects). The elements of an instance of ClassArray can be accessed just like ordinary C++ array elements by means of the index operator[](). Safety is provided by |
| ►CClassArray< Nonzero< R > > | |
| ►CSVSetBase< R > | Sparse vector set.Class SVSetBase provides a set of sparse vectors SVectorBase. All SVectorBases in an SVSetBase share one big memory block for their nonzeros. This memory is referred to as the nonzero memory. The SVectorBases themselves are saved in another memory block referred to as the vector memory. Both memory blocks will grow automatically if required, when adding more SVectorBases to the set or enlarging SVectorBases within the set. For controlling memory consumption, methods are provided to inquire and reset the size of the memory blocks used for vectors and nonzeros |
| ►CLPColSetBase< R > | Set of LP columns.Class LPColSetBase implements a set of LPColBase%s. Unless for memory limitations, any number of LPColBases may be added to an LPColSetBase. Single or multiple LPColBases may be added to an LPColSetBase, where each method add() comes with two different signatures. One with and one without a parameter, used for returning the DataKeys assigned to the new LPColBases by the set. See DataKey for a more detailed description of the concept of keys. For the concept of renumbering LPColBases within an LPColSetBase after removal of some LPColBases, see DataSet |
| ►CSPxLPBase< R > | Saving LPs in a form suitable for SoPlex.Class SPxLPBase provides the data structures required for saving a linear program in the form
\[ \begin{array}{rl} \hbox{max} & c^T x \\ \hbox{s.t.} & l_r \le Ax \le u_r \\ & l_c \le x \le u_c \end{array} \]
suitable for solving with SoPlex. This includes: |
| CSPxSolver | Sequential object-oriented SimPlex.SPxSolver is an LP solver class using the revised Simplex algorithm. It provides two basis representations, namely a column basis and a row basis (see Representation). For both representations, a primal and dual algorithm is available (see Type) |
| CSPxLPBase< Real > | |
| ►CLPRowSetBase< R > | Set of LP rows.Class LPRowSetBase implements a set of LPRowBase%s. Unless for memory limitations, any number of LPRowBases may be added to an LPRowSetBase. Single or multiple LPRowBases may be added to an LPRowSetBase, where each method add() comes with two different signatures. One with and one without a parameter, used for returning the Keys assigned to the new LPRowBases by the set. See DataKey for a more detailed description of the concept of keys. For the concept of renumbering LPRowBases within an LPRowSetBase after removal of some LPRows see DataSet |
| CSPxLPBase< R > | Saving LPs in a form suitable for SoPlex.Class SPxLPBase provides the data structures required for saving a linear program in the form
\[ \begin{array}{rl} \hbox{max} & c^T x \\ \hbox{s.t.} & l_r \le Ax \le u_r \\ & l_c \le x \le u_c \end{array} \]
suitable for solving with SoPlex. This includes: |
| ►CClassArray< Nonzero< Rational > > | |
| ►CSVSetBase< Rational > | |
| CLPColSetBase< Rational > | |
| ►CClassArray< Nonzero< Real > > | |
| ►CSVSetBase< Real > | |
| ►CLPRowSetBase< Real > | |
| CSPxLPBase< Real > | |
| ►CCLUFactor | Implementation of sparse LU factorization.This class implements a sparse LU factorization with either FOREST-TOMLIN or ETA updates, using dynamic Markowitz pivoting |
| CSLUFactor | Implementation of Sparse Linear Solver.This class implements a SLinSolver interface by using the sparse LU factorization implemented in CLUFactor |
| ►CCLUFactorRational | Implementation of sparse LU factorization with Rational precision.This class implements a sparse LU factorization with either FOREST-TOMLIN or ETA updates, using dynamic Markowitz pivoting |
| CSLUFactorRational | Implementation of Sparse Linear Solver with Rational precision.This class implements a SLinSolverRational interface by using the sparse LU factorization implemented in CLUFactorRational |
| CCLUFactorRational::U::Col | |
| CCLUFactor::U::Col | |
| CCompare | Compare class for row weights, used for sorting |
| CDataArray< T > | Safe arrays of data objects.Class DataArray provides safe arrays of Data Objects. For general C++ objects (in contrast to data objects) class Array is provided which manages memory in a C++ compliant way |
| CDataArray< bool > | |
| CDataArray< const soplex::SVectorBase * > | |
| CDataArray< IdxElement > | |
| CDataArray< int > | |
| CDataArray< RangeType > | |
| CDataArray< Real > | |
| CDataArray< soplex::DataHashTable::Element > | |
| CDataArray< soplex::SPxBoundFlippingRT::Breakpoint > | |
| CDataArray< soplex::SPxColId > | |
| CDataArray< soplex::SPxId > | |
| CDataArray< soplex::SPxMainSM::PostStep *> | |
| CDataArray< soplex::SPxParMultPR::SPxParMultPr_Tmp > | |
| CDataArray< soplex::SPxRowId > | |
| CDataArray< soplex::UnitVectorBase * > | |
| CDataArray< SPxSolver::VarStatus > | |
| CDataArray< Status > | |
| CDataHashTable< HashItem, Info > | Generic hash table for data objects.Class DataHashTable provides a generic hash table for Data Objects, i.e., a map that maps arguments called HashItems to values called Infos. HashItem and Info types are passed as template arguments. HashItems must provide a comparison operator==(). Furthermore, both the HashItem and Info must be data objects in the sense that the assignment operator is equivalent to a memcpy() of the structure and no destructor is required |
| CDataHashTable< soplex::NameSet::Name, soplex::DataKey > | |
| ►CDataKey | Entry identifier class for items of a DataSet.Every item in a DataSet is assigned a DataKey by which it can be accessed (using DataSet::operator[]()). A DataKey consists of an integer member idx, which is a positive number for any valid DataKey. No idx of an element in a DataSet may exceed the sets max(). This property may be used to build arrays with additional information to the elements of a DataSet |
| CSPxColId | Ids for LP columns.Class SPxColId provides DataKeys for the column indices of an SPxLP |
| CSPxId | Generic Ids for LP rows or columns.Both SPxColIds and SPxRowIds may be treated uniformly as SPxIds: |
| CSPxRowId | Ids for LP rows.Class SPxRowId provides DataKeys for the row indices of an SPxLP |
| CDataSet< DATA > | Set of data objects.Class DataSet manages of sets of data objects of a template type DATA. For constructing a DataSet the maximum number of entries must be given. The current maximum number may be inquired with method max() |
| CDataSet< int > | |
| CDataSet< soplex::SVSetBase::DLPSV > | |
| CSPxBasis::Desc | Basis descriptor |
| CCLUFactor::Dring | |
| CCLUFactorRational::Dring | |
| CDataHashTable< HashItem, Info >::Element< ElemHashItem, ElemInfo > | Template class for elements stored in the hash table |
| CSPxMainSM::ElementCompare | Comparator for class SVector::Element: compare nonzeros according to value |
| CSPxMainSM::IdxCompare | Comparator for class SVector::Element: compare nonzeros according to index |
| CSPxPricer::IdxCompare | Compare class to sort idx/val pairs, used for hypersparse pricing leaving |
| CSPxPricer::IdxElement | |
| ►CIdxSet | Set of indices.Class IdxSet provides a set of indices. At construction it must be given an array of int where to store the indice and its length. The array will from then on be managed by the IdxSet |
| CDIdxSet | Dynamic index set.Class DIdxSet provides dynamic IdxSet in the sense, that no restrictions are posed on the use of methods add(). However, method indexMem() has been moved to the private members. This is because DIdxSet adds its own memory management to class IdxSet and the user must not interfere with it |
| CSSVectorBase< R > | Semi sparse vector.This class implements semi-sparse vectors. Such are DVectorBases where the indices of its nonzero elements can be stored in an extra IdxSet. Only elements with absolute value > epsilon are considered to be nonzero. Since really storing the nonzeros is not always convenient, an SSVectorBase provides two different stati: setup and not setup. An SSVectorBase being setup means that the nonzero indices are available, otherwise an SSVectorBase is just an ordinary DVectorBase with an empty IdxSet. Note that due to arithmetic operation, zeros can slip in, i.e., it is only guaranteed that at least every non-zero is in the IdxSet |
| CSSVectorBase< Rational > | |
| CSSVectorBase< Real > | |
| CSoPlex::Settings::IntParam | |
| ►CIsList< T > | Generic single linked list.Class IsList implements an intrusive single linked list of elements of a template class T. As an intrusive list, the objects of type T must provide methods next() for setting and inquiring a pointer to the next element in a list. The user is responsible for not modifying the next() pointer of elements currently residing in a list, which may destroy the lists integrity. For this, class IsList provides enough methods for modifying a list in a save way. See the method list for a description |
| CIdList< T > | Generic Real linked list.Class IdList implements an intrusive Real linked list as a template class. As such, the list elements must provide the links themselfs. For conveniance, we also provide class IdElement that adds both links to an arbitrary class as template parameter |
| ►CIsList< soplex::SVSetBase::DLPSV > | |
| CIdList< soplex::SVSetBase::DLPSV > | |
| CDataSet< DATA >::Item | |
| CCLUFactor::L | Data structures for saving the working matrix and L factor |
| CCLUFactorRational::L | Data structures for saving the working matrix and L factor |
| CLPColBase< R > | LP column.Class LPColBase provides a datatype for storing the column of an LP a the form similar to
\[ \begin{array}{rl} \hbox{max} & c^T x \\ \hbox{s.t.} & Ax \le b \\ & l \le x \le u \end{array} \]
Hence, an LPColBase consists of an objective value, a column DSVector and an upper and lower bound to the corresponding variable, which may include \(\pm\infty\). However, it depends on the LP code to use, what values are actually treated as \(\infty\) |
| CLPRowBase< R > | (In)equality for LPs.Class LPRowBase provides constraints for linear programs in the form
\[ l \le a^Tx \le r, \]
where a is a DSVector. l is referred to as left hand side, r as right hand side and a as row vector or the constraint vector. l and r may also take values \(\pm\) infinity. This static member is predefined, but may be overridden to meet the needs of the LP solver to be used |
| CMPSInput | |
| CNameSet::Name | Handles of names in a NameSet.Class Name provides the handles (i.e., char*s) of names in a NameSet |
| CNameSet | Set of strings.Class NameSet implements a symbol or name table. It allows to store or remove names (i.e., char*), but does not provide means for manipulating stored names |
| CNonzero< R > | Sparse vector nonzero element |
| CNonzero< Rational > | |
| CNonzero< Real > | |
| CParam | |
| CCLUFactorRational::Perm | Data structures for saving the row and column permutations |
| CCLUFactor::Perm | Data structures for saving the row and column permutations |
| ►CSPxMainSM::PostStep | Base class for postsolving operations.Class PostStep is an abstract base class providing the interface for operations in the postsolving process |
| CSPxMainSM::AggregationPS | Postsolves aggregation |
| CSPxMainSM::DoubletonEquationPS | Postsolves doubleton equations combined with a column singleton |
| CSPxMainSM::DuplicateColsPS | Postsolves duplicate columns |
| CSPxMainSM::DuplicateRowsPS | Postsolves duplicate rows |
| CSPxMainSM::EmptyConstraintPS | Postsolves empty constraints |
| CSPxMainSM::FixBoundsPS | Postsolves variable bound fixing |
| CSPxMainSM::FixVariablePS | Postsolves variable fixing |
| CSPxMainSM::ForceConstraintPS | Postsolves forcing constraints |
| CSPxMainSM::FreeColSingletonPS | Postsolves free column singletons |
| CSPxMainSM::FreeConstraintPS | Postsolves unconstraint constraints |
| CSPxMainSM::FreeZeroObjVariablePS | Postsolves the case when constraints are removed due to a variable with zero objective that is free in one direction |
| CSPxMainSM::MultiAggregationPS | Postsolves multi aggregation |
| CSPxMainSM::RowObjPS | Postsolves row objectives |
| CSPxMainSM::RowSingletonPS | Postsolves row singletons |
| CSPxMainSM::TightenBoundsPS | Postsolves variable bound tightening from pseudo objective propagation |
| CSPxMainSM::ZeroObjColSingletonPS | Postsolves column singletons with zero objective |
| CCLUFactor::Pring | Pivot Ring |
| CCLUFactorRational::Pring | Pivot Ring |
| CRational::Private | Defines the "Pimpl"-class Private |
| CRandom | Random numbers.Class Random provides random Real variables, i.e. a value variable that gives another value each time it is accessed. It may be used just like an ordinary Real by means of an overloaded cast operator Real()% |
| CRational | Wrapper for GMP type mpq_class.We wrap mpq_class so that we can replace it by a double type if GMP is not available |
| CSoPlex::Settings::RealParam | |
| CCLUFactorRational::U::Row | |
| CCLUFactor::U::Row | |
| CSoPlex::RowViolation | |
| CSoPlex::RowViolationCompare | |
| CSoPlex::Settings | Class of parameter settings |
| ►CSLinSolver | Sparse Linear Solver virtual base class.Class SLinSolver provides a class for solving sparse linear systems with a matrix \(A\) and arbitrary right-hand side vectors. For doing so, the matrix must be first loaded to an SLinSolver object as an array of pointers to the column SVectors of this matrix |
| CSLUFactor | Implementation of Sparse Linear Solver.This class implements a SLinSolver interface by using the sparse LU factorization implemented in CLUFactor |
| ►CSLinSolverRational | Sparse Linear Solver virtual base class with Rational precision.Class SLinSolverRational provides a class for solving sparse linear systems with a matrix \(A\) and arbitrary right-hand side vectors. For doing so, the matrix must be first loaded to an SLinSolverRational object as an array of pointers to the column SVectorsRational of this matrix |
| CSLUFactorRational | Implementation of Sparse Linear Solver with Rational precision.This class implements a SLinSolverRational interface by using the sparse LU factorization implemented in CLUFactorRational |
| CSolBase< R > | Class for storing a primal-dual solution with basis information |
| CSolBase< Rational > | |
| CSolBase< Real > | |
| CSoPlex | Preconfigured SoPlex LP-solver |
| ►CSPxBasis | Simplex basis.Consider the linear program as provided from class SPxLP:
\[ \begin{array}{rl} \hbox{max} & c^T x \\ \hbox{s.t.} & l_r \le Ax \le u_r \\ & l_c \le x \le u_c \end{array} \]
where \(c, l_c, u_c, x \in {\bf R}^n\), \(l_r, u_r \in {\bf R}^m\) and \(A \in {\bf R}^{m \times n}\). Solving this LP with the simplex algorithm requires the definition of a basis. Such can be defined as a set of column vectors or a set of row vectors building a non-singular matrix. We will refer to the first case as the columnwise representation and the latter case will be called the rowwise representation. In both cases, a basis is a set of vectors forming a non-singular matrix. The dimension of the vectors is referred to as the basis' dimension, whereas the number of vectors belonging to the LP is called the basis' codimension |
| CSPxSolver | Sequential object-oriented SimPlex.SPxSolver is an LP solver class using the revised Simplex algorithm. It provides two basis representations, namely a column basis and a row basis (see Representation). For both representations, a primal and dual algorithm is available (see Type) |
| ►CSPxException | Exception base class.This class implements a base class for our SoPlex exceptions We provide a what() function which returns the exception message |
| CSPxInterfaceException | Exception class for incorrect usage of interface methods |
| CSPxInternalCodeException | Exception class for things that should NEVER happen.This class is derived from the SoPlex exception base class. It does not provide any new functionality. Most often it is used to replace assert(false) terms in earlier code |
| CSPxMemoryException | Exception class for out of memory exceptions.This class is derived from the SoPlex exception base class. It does not provide any new functionality |
| CSPxStatusException | Exception class for status exceptions during the computationsThis class is derived from the SoPlex exception base class. It does not provide any new functionality |
| CSPxOut | Wrapper for several output streams. A verbosity level is used to decide which stream to use and whether to really print a given message. Regardless of whether the verbosity level is set via a manipulator or via the member function, it is persistent until a new value is set |
| CSPxParMultPR::SPxParMultPr_Tmp | Helper structure |
| ►CSPxPricer | Abstract pricer base class.Class SPxPricer is a pure virtual class defining the interface for pricer classes to be used by SoPlex. The pricer's task is to select a vector to enter or leave the simplex basis, depending on the chosen simplex type |
| CSPxAutoPR | Auto pricer.This pricer switches between Devex and Steepest edge pricer based on the difficulty of the problem which is determined by the number of iterations |
| CSPxDantzigPR | Dantzig pricer.Class SPxDantzigPR is an implementation class of an SPxPricer implementing Dantzig's default pricing strategy, i.e., maximal/minimal reduced cost or maximally violated constraint |
| CSPxDevexPR | Devex pricer.The Devex Pricer for SoPlex implements an approximate steepest edge pricing, that does without solving an extra linear system and computing the scalar products |
| CSPxHybridPR | Hybrid pricer.The hybrid pricer for SoPlex tries to guess the best pricing strategy to use for pricing the loaded LP with the loaded algorithm type and basis representation. Currently it does so by switching between SPxSteepPR, SPxDevexPR and SPxParMultPR |
| CSPxParMultPR | Partial multiple pricing.Class SPxParMultPr is an implementation class for SPxPricer implementing Dantzig's default pricing strategy with partial multiple pricing. Partial multiple pricing applies to the entering Simplex only. A set of partialSize eligible pivot indices is selected (partial pricing). In the following Simplex iterations pricing is restricted to these indices (multiple pricing) until no more eliiable pivots are available. Partial multiple pricing significantly reduces the computation time for computing the matrix-vector-product in the Simplex algorithm |
| ►CSPxSteepPR | Steepest edge pricer.Class SPxSteepPR implements a steepest edge pricer to be used with SoPlex |
| CSPxSteepExPR | Steepest edge pricer.Class SPxSteepExPR implements a steepest edge pricer to be used with SoPlex. Exact initialization of weights is used |
| CSPxWeightPR | Weighted pricing.Class SPxWeightPR is an implemantation class of SPxPricer that uses weights for columns and rows for selecting the Simplex pivots. The weights are computed by methods computeCP() and computeRP() which may be overridden by derived classes |
| ►CSPxRatioTester | Abstract ratio test base class.Class SPxRatioTester is the virtual base class for computing the ratio test within the Simplex algorithm driven by SoPlex. After a SoPlex solver has been load()ed to an SPxRatioTester, the solver calls selectLeave() for computing the ratio test for the entering simplex and selectEnter() for computing the ratio test in leaving simplex |
| CSPxDefaultRT | Textbook ratio test for SoPlex.Class SPxDefaultRT provides an implementation of the textbook ratio test as a derived class of SPxRatioTester. This class is not intended for reliably solving LPs (even though it does the job for ``numerically simple'' LPs). Instead, it should serve as a demonstration of how to write ratio tester classes |
| ►CSPxFastRT | Fast shifting ratio test.Class SPxFastRT is an implementation class of SPxRatioTester providing fast and stable ratio test. Stability is achieved by allowing some infeasibility to ensure numerical stability such as the Harris procedure. Performance is achieved by skipping the second phase if the first phase already shows a stable enough pivot |
| CSPxBoundFlippingRT | Bound flipping ratio test ("long step dual") for SoPlex.Class SPxBoundFlippingRT provides an implementation of the bound flipping ratio test as a derived class of SPxRatioTester. Dual step length is increased beyond some breakpoints and corresponding primal nonbasic variables are set to their other bound to handle the resulting dual infeasibility |
| CSPxHarrisRT | Harris pricing with shifting.Class SPxHarrisRT is a stable implementation of a SPxRatioTester class along the lines of Harris' two phase algorithm. Additionally it uses shifting of bounds in order to avoid cycling |
| ►CSPxScaler | LP scaler abstract base class.Instances of classes derived from SPxScaler may be loaded to SoPlex in order to scale LPs before solving them. SoPlex will load() itself to the SPxScaler and then call scale(). Generally any SPxLP can be loaded to a SPxScaler for scale()ing it. The scaling can be undone by calling unscale() |
| CSPxEquiliSC | Equilibrium row/column scaling.This SPxScaler implementation performs equilibrium scaling of the LPs rows and columns |
| CSPxGeometSC | Geometric mean row/column scaling.This SPxScaler implementation performs geometric mean scaling of the LPs rows and columns |
| CSPxLeastSqSC | Least squares scaling.This SPxScaler implementation performs least squares scaling as suggested by Curtis and Reid in: On the Automatic Scaling of Matrices for Gaussian Elimination (1972) |
| ►CSPxSimplifier | LP simplification abstract base class.Instances of classes derived from SPxSimplifier may be loaded to SoPlex in order to simplify LPs before solving them. SoPlex will call simplify() on itself. Generally any SPxLP can be given to a SPxSimplifier for simplify()ing it. The simplification cannot be undone, but given an primal/dual solution for the simplified SPxLP, the simplifier can reconstruct the primal/dual solution of the unsimplified LP |
| CSPxMainSM | LP simplifier for removing uneccessary row/columns.This SPxSimplifier is mainly based on the paper "Presolving in
linear programming" by E. Andersen and K. Andersen (Mathematical Programming, 1995). It implements all proposed methods and some other preprocessing techniques for removing redundant rows and columns and bounds. Also infeasibility and unboundedness may be detected |
| ►CSPxStarter | SoPlex start basis generation base class.SPxStarter is the virtual base class for classes generating a starter basis for the Simplex solver SoPlex. When a SPxStarter object has been loaded to a SoPlex solver, the latter will call method generate() in order to have a start basis generated. Implementations of method generate() must terminate by loading the generated basis to SoPlex. Loaded bases must be nonsingular |
| ►CSPxWeightST | Weighted start basis.Class SPxWeightST is an implementation of a SPxStarter for generating a Simplex starting basis. Using method setupWeights() it sets up arrays weight and coWeight, or equivalently rowWeight and colWeight. (rowWeight and colWeight are just pointers initialized to weight and coWeight according to the representation of SoPlex base passed to method generate().) |
| ►CSPxVectorST | Solution vector based start basis.This version of SPxWeightST can be used to construct a starting basis for an LP to be solved with SoPlex if an approximate solution vector or dual vector (possibly optained by a heuristic) is available. This is done by setting up weights for the SPxWeightST it is derived from |
| CSPxSumST | Simple heuristic SPxStarter.Testing version of an SPxVectorST using a very simplistic heuristic to build up an approximated solution vector |
| CStableSum< T > | |
| CStableSum< double > | |
| CStatistics | Class for collecting statistical information |
| CSoPlex::Statistics | |
| CSPxOut::struct_Verbosity | Helper struct for the output operator |
| ►CSVectorBase< R > | Sparse vectors.Class SVectorBase provides packed sparse vectors. Such are a sparse vectors, with a storage scheme that keeps all data in one contiguous block of memory. This is best suited for using them for parallel computing on a distributed memory multiprocessor |
| CDSVectorBase< R > | Dynamic sparse vectors.Class DSVectorBase implements dynamic sparse vectors, i.e. SVectorBases with an automatic memory management. This allows the user to freely add() as many nonzeros to a DSVectorBase as desired, without any precautions. For saving memory method setMax() allows to reduce memory consumption to the amount really required |
| CSVSetBase< R >::DLPSV | SVectorBase with prev/next pointers |
| CUnitVectorBase< R > | Sparse vector \(e_i\).A UnitVectorBase is an SVectorBase that can take only one nonzero value with value 1 but arbitrary index |
| ►CSVectorBase< Rational > | |
| CDSVectorBase< Rational > | |
| ►CSVectorBase< Real > | |
| CDSVectorBase< Real > | |
| ►CT | |
| CIdElement< T > | Elements for IdLists.IdElements are derived from the template parameter class T and can hence be used as such. The additional methods next() and prev() provide access to the links for the list. They may freely be used by the programmer as long as an IdElement is not member of a IdList. In this case, the IdList controls members next() and prev(). However, IdList should provide enough functionality for the user not to require any modification to these members |
| CIsElement< T > | Elements for IsLists.Class IsElement allows to easily construct list elements for an intrusive single linked list IsList out of a template class T. It adds a next pointer to each element. An instance of IdElement<T> a can be used just like an instance of T itself, except that method next() has been added (thereby overriding any method next() defined in T) |
| CCLUFactorRational::Temp | Temporary data structures |
| CCLUFactor::Temp | Temporary data structures |
| ►CTimer | Wrapper for the system time query methods |
| CNoTimer | |
| CUserTimer | |
| CWallclockTimer | |
| CTimerFactory | Class to create new timers and to switch types of exiting ones |
| CCLUFactorRational::U | Data structures for saving the working matrix and U factor |
| CCLUFactor::U | Data structures for saving the working matrix and U factor |
| CValidation | |
| ►CVectorBase< R > | Dense vector.Class VectorBase provides dense linear algebra vectors. It does not provide memory management for the array of values. Instead, the constructor requires a pointer to a memory block large enough to fit the desired dimension of Real or Rational values |
| ►CDVectorBase< R > | Dynamic dense vectors.Class DVectorBase is a derived class of VectorBase adding automatic memory management to such objects. This allows to implement maths operations operator+() and operator-(). Further, it is possible to reset the dimension of a DVectorBase via method reDim(). However, this may render all references to values of a reDim()ed DVectorBase invalid |
| CSSVectorBase< R > | Semi sparse vector.This class implements semi-sparse vectors. Such are DVectorBases where the indices of its nonzero elements can be stored in an extra IdxSet. Only elements with absolute value > epsilon are considered to be nonzero. Since really storing the nonzeros is not always convenient, an SSVectorBase provides two different stati: setup and not setup. An SSVectorBase being setup means that the nonzero indices are available, otherwise an SSVectorBase is just an ordinary DVectorBase with an empty IdxSet. Note that due to arithmetic operation, zeros can slip in, i.e., it is only guaranteed that at least every non-zero is in the IdxSet |
| ►CVectorBase< Rational > | |
| ►CDVectorBase< Rational > | |
| CSSVectorBase< Rational > | |
| ►CVectorBase< Real > | |
| ►CDVectorBase< Real > | |
| CUpdateVector | Dense vector with semi-sparse vector for updatesIn many algorithms vectors are updated in every iteration, by adding a multiple of another vector to it, i.e., given a vector x, a scalar \(\alpha\) and another vector \(\delta\), the update to x constists of substituting it by \(x \leftarrow x + \alpha\cdot\delta\) |
| CSSVectorBase< Real > | |
