| ▼NCDPL | The namespace of the Chemical Data Processing Library |
| ►NBase | Contains core framework classes and functions |
| CAny | Safe, type checked container for arbitrary data of variable type |
| CControlParameterContainer | Base class providing methods for the storage and lookup of control-parameter values |
| CControlParameterList | Data structure for the storage and lookup of control-parameter values |
| CDataFormat | Provides meta-information about a particular data storage format |
| CDataInputHandler | Factory interface providing methods for the creation of Base::DataReader instances handling a particular object type and storage format |
| CDataIOBase | Provides infrastructure for the registration of I/O callback functions |
| CDataIOManager | Singleton class that serves as a global registry for Base::DataInputHandler and Base::DataOutputHandler implementation instances |
| CDataOutputHandler | Factory interface providing methods for the creation of Base::DataWriter instances handling a particular object type and storage format |
| CDataReader | Interface for reading data objects of a given type from an arbitrary data source |
| CDataWriter | Interface for writing data objects of a given type to an arbitrary data sink |
| CException | The root of the CDPL exception hierarchy |
| CValueError | Thrown to indicate errors caused by some invalid value |
| CNullPointerException | Thrown when an operation requires or expects a valid pointer but a null pointer was provided |
| CRangeError | Thrown to indicate that a value is out of range |
| CSizeError | Thrown to indicate that the size of a (multidimensional) array is not correct |
| CIndexError | Thrown to indicate that an index is out of range |
| CItemNotFound | Thrown to indicate that some requested data item could not be found |
| CBadCast | Thrown to indicate that a cast or conversion from a given source type to a requested target type is not possible |
| COperationFailed | Thrown to indicate that some requested operation has failed (e.g. due to unfulfilled preconditions or other errors) |
| CCalculationFailed | Thrown to indicate that some requested calculation has failed |
| CIOError | Thrown to indicate that an I/O operation has failed because of physical (e.g. broken pipe) or logical (e.g. invalid file format) errors |
| ►CLookupKey | Unique lookup key for control-parameter and property values |
| CHashFunc | Functor class implementing the generation of hash codes for LookupKey instances |
| CPropertyContainer | Base class providing methods for the storage and lookup of object properties |
| ►NBiomol | Contains classes and functions related to biological macromolecules |
| NAtomProperty | Provides keys for built-in Chem::Atom properties |
| NAtomPropertyDefault | Provides default values for built-in Chem::Atom properties |
| NAtomPropertyFlag | Provides flags for the specification of basic Chem::Atom properties |
| NControlParameter | Provides keys for built-in control-parameters |
| NControlParameterDefault | Provides default values for built-in control-parameters |
| NDataFormat | Provides preinitialized Base::DataFormat objects for all supported biopolymer data formats |
| NMolecularGraphProperty | Provides keys for built-in Chem::MolecularGraph properties |
| NMolecularGraphPropertyDefault | Provides default values for built-in Chem::MolecularGraph properties |
| NPDBFormatVersion | Provides constants for the specification of the Brookhaven Protein Data Bank (PDB) [PDB] format version |
| NResidueType | Provides constants for the specification of the type of a chemical component (residue) |
| CHierarchyView | Data structure providing a hierarchical view on biological macromolecules |
| CHierarchyViewChain | Data structure for the representation of biological macromolecule chains |
| CHierarchyViewFragment | Data structure for the representation of a single contiguous fragment of a biological macromolecule chain |
| CHierarchyViewModel | Data structure for the representation of individual biological macromolecule models |
| CHierarchyViewNode | Abstract base class for nodes of the Biomol::HierarchyView tree (models, chains, residues) |
| ►CMMCIFData | Data structure for the storage of imported MMCIF data (see [MMCIF]) |
| CCategory | A single mmCIF data category, holding an ordered list of data items (columns) |
| CItem | A single data item (column) of an mmCIF category, holding an ordered list of string values |
| CMMCIFMolecularGraphWriter | Writer for molecular graph data in the Macromolecular Crystallographic Information File (mmCIF) [MMCIF] format |
| CMMCIFMoleculeReader | Reader for molecule data in the Macromolecular Crystallographic Information File (mmCIF) [MMCIF] format |
| CMMTFMolecularGraphWriter | Writer for molecular graph data in the Macromolecular Transmission Format (MMTF) [MMTF] |
| CMMTFMoleculeReader | Reader for molecule data in the Macromolecular Transmission Format (MMTF) [MMTF] |
| CPDBData | Data structure for the storage of data records found in PDB formatted data [PDB] |
| CPDBMolecularGraphWriter | Writer for molecular graph data in the Brookhaven Protein Data Bank (PDB) [PDB] format |
| CPDBMoleculeReader | Reader for molecule data in the Brookhaven Protein Data Bank (PDB) [PDB] format |
| ►CResidueDictionary | Global dictionary for the lookup of meta-data associated with the residues in biological macromolecules |
| CEntry | A single residue dictionary entry |
| CResidueList | Data structure for the storage of residues extracted from biological macromolecules |
| ►NChem | Contains classes and functions related to chemistry |
| NAtomConfiguration | Provides constants that are used to specify the configuration of stereogenic atoms |
| NAtomMatchConstraint | Provides numerical identifiers for built-in Chem::Atom matching constraints |
| NAtomProperty | Provides keys for built-in Chem::Atom properties |
| NAtomPropertyDefault | Provides default values for built-in Chem::Atom properties |
| NAtomPropertyFlag | Provides flags for the specification of basic Chem::Atom properties |
| NAtomType | Provides constants for the specification of the chemical element or generic type of an atom |
| NBondConfiguration | Provides constants that are used to specify the cis/trans configuration of bonds |
| NBondDirection | Provides constants for the specification of directional bonds in Daylight SMILES and SMARTS strings |
| NBondMatchConstraint | Provides numerical identifiers for built-in Chem::Bond matching constraints and flags for the specification of bond orders |
| NBondProperty | Provides keys for built-in Chem::Bond properties |
| NBondPropertyDefault | Provides default values for built-in Chem::Bond properties |
| NBondPropertyFlag | Provides flags for the specification of basic Chem::Bond properties |
| NBondStereoFlag | Provides constants for the specification of stereo bonds in 2D depictions of chemical structures |
| NBRICSAtomLabel | Provides constants for the labeling of atoms of bonds matched by a BRICS fragmentation rule |
| NBRICSRuleID | Provides constants for the identification of BRICS fragmentation rules |
| NCIPDescriptor | Provides constants for the specification of stereogenic atom/bond configurations determined by the Cahn-Ingold-Prelog (CIP) sequence rules |
| NControlParameter | Provides keys for built-in control-parameters |
| NControlParameterDefault | Provides default values for built-in control-parameters |
| NDataFormat | Provides preinitialized Base::DataFormat objects for all supported chemical data formats |
| NEntity3DProperty | Provides keys for built-in Chem::Entity3D properties |
| NHybridizationState | Provides constants for the specification of atom hybridization states |
| NINCHIReturnCode | Provides constants that are used to describe the status of an InChI [INCHI] output or input operation |
| NMDLDataFormatVersion | Provides constants that are used to specify the connection table (CTAB) and Rxn-File version for the I/O of molecular graphs and reactions in an MDL CTFile based data format |
| NMDLParity | Provides constants that are used to specify the MDL stereo parity of atoms |
| NMOL2ChargeType | Provides constants for the specification of the atom charge type in Sybyl MOL2 files |
| NMOL2MoleculeType | Provides constants for the specification of the molecule type in Sybyl MOL2 files |
| NMolecularGraphMatchConstraint | Provides numerical identifiers for built-in Chem::MolecularGraph matching constraints |
| NMolecularGraphProperty | Provides keys for built-in Chem::MolecularGraph properties |
| NMolecularGraphPropertyDefault | Provides default values for built-in Chem::MolecularGraph properties |
| NRadicalType | Provides constants that are used to specify the degeneracy of the electronic state of radical atoms |
| NReactionCenterStatus | Provides flags that are used to describe state changes of atoms and bonds in a reaction center |
| NReactionMatchConstraint | Provides numerical identifiers for built-in Chem::Reaction matching constraints |
| NReactionProperty | Provides keys for built-in Chem::Reaction properties |
| NReactionPropertyDefault | Provides default values for built-in Chem::Reaction properties |
| NReactionRole | Provides constants that are used to specify the role of molecules (components) in a chemical reaction |
| NRECAPAtomLabel | Provides constants for the labeling of atoms of bonds matched by a RECAP fragmentation rule |
| NRECAPRuleID | Provides constants for the identification of RECAP fragmentation rules |
| NSybylAtomType | Provides constants for the specification of the Tripos Sybyl atom type |
| NSybylBondType | Provides constants for the specification of the Tripos Sybyl bond type |
| NTautomerizationType | Provides constants serving as identifiers for built-in Chem::TautomerizationRule implementations |
| CAmideImidicAcidTautomerization | Implementation of the amide ↔ imidic-acid tautomerization rule |
| CANDMatchExpressionList | Chem::MatchExpressionList specialization that evaluates the stored expressions as a logical conjunction (AND) |
| CANDMatchExpressionList< ObjType, void > | Chem::MatchExpressionList specialization (single-object form) that evaluates the stored expressions as a logical conjunction (AND) |
| CAromaticRingSet | Implements the perception of aromatic rings in a molecular graph |
| CAromaticSSSRSubset | Implements the extraction of the aromatic rings in the SSSR of a molecular graph |
| CAromaticSubstructure | Implements the perception of aromatic atoms and bonds in a molecular graph |
| CAtom | Abstract base class representing a chemical atom and its bonded neighborhood |
| CAtom2DCoordinatesCalculator | Generates 2D coordinates for the atoms of a molecular graph using a layout algorithm that combines ring-system templates, chain extension, and substituent placement |
| CAtom3DCoordinatesFunctor | Helper-functor for retrieving the 3D coordinates of an atom (via the Chem::AtomProperty::COORDINATES_3D property) |
| CAtomArray3DCoordinatesFunctor | Helper-functor for retrieving the 3D coordinates of an atom from a separately-stored coordinates array, indexed by the atom's position in the underlying molecular graph |
| CAtomBondMapping | Data structure for the common storage of related atom to atom and bond to bond mappings |
| CAtomConfigurationMatchExpression | Chem::MatchExpression that constrains target atoms by their stereo configuration relative to a query atom |
| CAtomConformer3DCoordinatesFunctor | Helper-functor for retrieving the 3D coordinates of an atom for a specific conformer (via the Chem::AtomProperty::CONFORMER_COORDINATES_3D conformer-array property) |
| CAtomContainer | Common interface for data structures that support a random access to stored Chem::Atom instances |
| ►CAtomDictionary | A global dictionary for the lookup of data associated with the atom types defined in namespace Chem::AtomType |
| CEntry | A single dictionary entry describing the properties of an (atom type, isotope) pair |
| CAtomEnvironmentMatchExpression | Chem::MatchExpression that constrains target atoms by the structural environment encoded as a SMARTS substructure pattern |
| CAtomMapping | Data type for the storage and lookup of arbitrary atom to atom mappings |
| CAtomSSSRRingSizeMatchExpression | Chem::MatchExpression that constrains target atoms by the size of the SSSR ring(s) containing them |
| CAtomTypeMatchExpression | MatchExpression that checks the atom type of a target atom against a query atom type |
| CAutomorphismGroupSearch | Enumerates the atom/bond automorphisms of a molecular graph |
| CBasicAtom | Concrete Chem::Atom implementation used as the atom type of Chem::BasicMolecule |
| CBasicBond | Default implementation of the Chem::Bond interface |
| CBasicMolecule | Concrete Chem::Molecule implementation that owns Chem::BasicAtom and Chem::BasicBond instances |
| CBasicReaction | Default concrete implementation of the Chem::Reaction abstract interface |
| CBemisMurckoAnalyzer | Decomposes a molecular graph into its Bemis-Murcko framework, ring systems, linkers and side chains |
| CBond | Abstract base class representing a chemical bond between two Chem::Atom instances |
| CBondConfigurationMatchExpression | Chem::MatchExpression that constrains target bonds by their stereo configuration relative to a query bond |
| CBondContainer | Common interface for data structures that support a random access to stored Chem::Bond instances |
| CBondDirectionMatchExpression | Chem::MatchExpression that constrains target bonds by their SMILES/SMARTS bond direction |
| CBondMapping | Data type for the storage and lookup of arbitrary bond to bond mappings |
| CBondOrderCalculator | Perceives bond orders of a molecular graph from its 3D structure and atom connectivity |
| CBondReactionCenterStatusMatchExpression | Chem::MatchExpression that constrains target bonds by their reaction-center status (see Chem::ReactionCenterStatus) |
| CBondStereoFlagCalculator | Calculator that derives 2D wedge/hash bond stereo flags from atom 2D coordinates and stereochemical descriptors of a molecular graph |
| CBondSubstituentDirectionMatchExpression | Chem::MatchExpression that constrains target double bond geometry via the per-substituent bond-direction annotations carried by the query (in the style of Daylight SMARTS [SMARTS] cis/trans patterns) |
| CBRICSFragmentGenerator | Chem::FragmentGenerator preconfigured with the 16 BRICS bond-cleavage rules and the associated exclude patterns for combinatorial fragmentation of organic molecules |
| CCanonicalNumberingCalculator | Calculation of canonical atom numberings for molecular graphs using McKay's algorithm |
| CCDFMolecularGraphWriter | Writer for molecular graph data in the native I/O format of the CDPL |
| CCDFMoleculeReader | Reader for molecule data in the native I/O format of the CDPL |
| CCDFReactionReader | Reader for reaction data in the native I/O format of the CDPL |
| CCDFReactionWriter | Writer for reaction data in the native I/O format of the CDPL |
| CChEMBLStandardizer | Implementation of the ChEMBL structure preprocessing pipeline |
| CCIPConfigurationLabeler | Assigns Cahn-Ingold-Prelog (CIP) configuration labels to stereogenic atoms and bonds of a molecular graph |
| CCIPPriorityCalculator | Computes a topological approximation of CIP (Cahn-Ingold-Prelog) priorities for the atoms of a molecular graph |
| CCMLMolecularGraphWriter | Writer for molecular graph data in the Chemical Markup Language [CML] format |
| CCMLMoleculeReader | Reader for molecule data in the Chemical Markup Language [CML] format |
| CCommonConnectedSubstructureSearch | Enumerates all maximal common connected substructures shared between a query and a target molecular graph |
| CCompleteRingSet | Implements the exhaustive perception of rings in a molecular graph |
| CComponentSet | Implements the perception of molecular graph components |
| CConjugatedRingBondPatternSwitching | Chem::TautomerizationRule implementation that enumerates tautomers obtained by switching the single/double bond pattern of conjugated rings (e.g. the two Kekulé forms of benzene) |
| CConnectedSubstructureSet | Enumerates the connected substructures of a molecular graph of a specified bond count |
| CCyclicSubstructure | Implements the perception of ring atoms and bonds in a molecular graph |
| CDefaultMultiConfMoleculeInputProcessor | Default Chem::MultiConfMoleculeInputProcessor implementation that detects multi-conformer input by comparing atom and bond properties (and optionally molecule names) between successive input molecules |
| CDefaultTautomerGenerator | Chem::TautomerGenerator preconfigured with the standard CDPKit tautomerization rules |
| CElectronSystem | Describes an electron system of a molecule in terms of involved atoms and their electron contributions |
| CElectronSystemList | Data type for the storage of Chem::ElectronSystem objects |
| CEntity3D | Base class for objects that have a position in 3D space (e.g. Chem::Atom and Chem::Feature) |
| CEntity3DContainer | Common interface for data structures that support a random access to stored Chem::Entity3D instances |
| CEntity3DCoordinatesFunctor | Helper-functor for retrieving the 3D coordinates of an Chem::Entity3D object (via the Chem::Entity3DProperty::COORDINATES_3D property) |
| CEntity3DMapping | Data type for the storage and lookup of arbitrary entity to entity mappings |
| CExtendedSSSR | Implements the perception of the Extended Smallest Set of Smallest Rings (ESSSR) of a molecular graph |
| CFragment | Concrete Chem::MolecularGraph implementation that stores references to a selectable subset of atoms and bonds (typically of a parent Chem::Molecule) |
| ►CFragmentGenerator | Generic rule-based molecule fragmentation engine that splits a molecular graph along bonds matching user-defined fragmentation rules |
| CExcludePattern | A pattern descriptor specifying bonds that shall not be cleaved |
| CFragmentationRule | A single fragmentation rule, consisting of a bond substructure match pattern and a numeric rule ID |
| CFragmentLink | Records the connectivity between two fragments produced by a single bond cleavage |
| CFragmentList | Data type for the storage of Chem::Fragment objects |
| CGenericHydrogen13ShiftTautomerization | Chem::TautomerizationRule implementation that enumerates tautomers obtained by a generic 1,3-hydrogen shift (a proton migrates between atoms separated by two bonds, with the corresponding single/double bond pattern flipping) |
| CGenericHydrogen15ShiftTautomerization | Chem::TautomerizationRule implementation that enumerates tautomers obtained by a generic 1,5-hydrogen shift (a proton migrates between atoms separated by four bonds along a conjugated path, with the corresponding single/double bond pattern flipping) |
| ►CHashCodeCalculator | Computes a 64-bit hash code that identifies a molecular graph up to a configurable set of atom and bond properties |
| CDefAtomHashSeedFunctor | The default functor for the generation of atom hash seeds |
| CDefBondHashSeedFunctor | The default functor for the generation of bond hash seeds |
| CHydrogen3DCoordinatesCalculator | Generates 3D coordinates for the hydrogen atoms of a molecular graph from the existing positions of their heavy atom neighbors |
| CImineEnamineTautomerization | Chem::TautomerizationRule implementation that enumerates the imine/enamine tautomers of an \( R_2C=N{-}CHR_2 \rightleftharpoons R_2CH{-}N=CR_2 \) system |
| CINCHIMolecularGraphWriter | Writer for molecular graph data in the IUPAC International Chemical Identifier (InChI) [INCHI] format |
| CINCHIMoleculeReader | Reader for molecule data in the IUPAC International Chemical Identifier (InChI) [INCHI] format |
| CJMEMolecularGraphWriter | Writer for molecular graph data in the native I/O format of the JME Molecular Editor [JME] java applet |
| CJMEMoleculeReader | Reader for molecule data in the native I/O format of the JME Molecular Editor [JME] java applet |
| CJMEReactionReader | Reader for reaction data in the native I/O format of the JME Molecular Editor [JME] java applet |
| CJMEReactionWriter | Writer for reaction data in the native I/O format of the JME Molecular Editor [JME] java applet |
| CKekuleStructureCalculator | Assigns an alternating single/double bond pattern (Kekulé structure) to the previously undefined bonds of a molecular graph (typically used to convert aromatic-bond annotations into explicit single/double bonds) |
| CKeteneYnolTautomerization | Chem::PatternBasedTautomerizationRule implementation that enumerates ketene/ynol tautomers (Chem::TautomerizationType::KETENE_YNOL) |
| CKetoEnolTautomerization | Chem::TautomerizationRule implementation that enumerates the keto/enol tautomers of an \( R_2C{-}C(=O)R' \rightleftharpoons RC=C(OH)R' \) system |
| CLactamLactimTautomerization | Chem::TautomerizationRule implementation that enumerates the lactam/lactim tautomers of a cyclic amide \( {-}NH{-}C(=O){-} \rightleftharpoons {-}N=C(OH){-} \) system |
| CMatchConstraint | Describes a single attribute-comparison constraint between a query and a target object used by molecular graph matching algorithms |
| CMatchConstraintList | List of Chem::MatchConstraint instances combined with a logical Type (AND_LIST, NOT_AND_LIST, OR_LIST, or NOT_OR_LIST) that controls how the contained constraints are aggregated during query/target evaluation |
| CMatchExpression | Generic boolean expression interface for the implementation of query/target object equivalence tests in molecular graph matching algorithms |
| CMatchExpression< ObjType, void > | Generic boolean expression interface for the implementation of query/target object equivalence tests in molecular graph matching algorithms |
| CMatchExpressionList | Container for the storage and evaluation of logical match expression lists |
| CMaxCommonAtomSubstructureSearch | Computes the maximum common atom substructure between a query and a target molecular graph by reducing the problem to maximum-clique enumeration on an association (modular product) graph |
| CMaxCommonBondSubstructureSearch | Computes the maximum common bond substructure between a query and a target molecular graph by reducing the problem to maximum-clique enumeration on a bond-based association graph |
| CMOL2MolecularGraphWriter | Writer for molecular graph data in the Sybyl MOL2 format |
| CMOL2MoleculeReader | Reader for molecule data in the Sybyl MOL2 format |
| CMolecularGraph | Abstract base class for representations of a chemical structure as a graph of bonded atoms |
| CMolecularGraphComponentGroupingMatchExpression | Chem::MatchExpression that constrains the substructure mapping by the query's component-level groupings (typically derived from the parenthesization of a Daylight SMARTS [SMARTS] pattern) |
| CMolecule | Abstract base class representing a mutable molecular graph that owns its atoms and bonds |
| CMOLMolecularGraphWriter | Writer for molecular graph data in the MDL Mol-File [CTFILE] format |
| CMOLMoleculeReader | Reader for molecule data in the MDL Mol-File [CTFILE] format |
| CMorganNumberingCalculator | Computes a canonical atom numbering of a molecular graph using a modified Morgan algorithm |
| CMultiConfMoleculeInputProcessor | Abstract base interface for processors that detect and assemble multi-conformer molecules from a stream of successive single-conformer input molecules |
| CMultiSubstructureSearch | Evaluates a boolean expression over multiple substructure queries against a target molecular graph |
| CNitroAciTautomerization | Implementation of the nitro ↔ aci-nitro tautomerization rule |
| CNitrosoOximeTautomerization | Chem::PatternBasedTautomerizationRule implementation that enumerates nitroso/oxime tautomers (Chem::TautomerizationType::NITROSO_OXIME) |
| CNOTMatchExpression | Chem::MatchExpression decorator that negates the result of a wrapped Chem::MatchExpression instance |
| CNOTMatchExpression< ObjType, void > | Chem::MatchExpression decorator that negates the result of a wrapped Chem::MatchExpression instance |
| CORMatchExpressionList | Chem::MatchExpressionList specialization that evaluates the stored expressions as a logical disjunction (OR) |
| CORMatchExpressionList< ObjType, void > | Chem::MatchExpressionList specialization that evaluates the stored expressions as a logical disjunction (OR) |
| ►CPatternAtomTyper | Assigns numeric labels to specific atoms of a molecular graph that are described by substructure patterns |
| CPattern | Stores a single substructure query molecular graph, its atom label value, its priority and match-handling flags |
| ►CPatternBasedTautomerizationRule | Match pattern-based implementation of the Chem::TautomerizationRule interface |
| CBondOrderChange | Encodes a single bond order change between two pattern atoms applied when the parent transformation pattern matches |
| CPhosphinicAcidTautomerization | Chem::PatternBasedTautomerizationRule implementation that enumerates phosphinic-acid tautomers (Chem::TautomerizationType::PHOSPHINIC_ACID) |
| CPiElectronSystemList | Implements the perception of all π-electron systems present in a molecule |
| CPropertyMatchExpression | Generic Chem::MatchExpression specialisation that evaluates a binary comparison between a query- and a target-derived property value retrieved through a user-supplied accessor function |
| CPropertyMatchExpression< ValueType, MatchFunc, ObjType, void > | Single-object specialisation of Chem::PropertyMatchExpression for query/target equivalence tests on a single attribute retrieved from a single object via the user-supplied accessor |
| CProtonationStateStandardizer | Adjusts the protonation state of a molecule (atom formal charges and bonded hydrogen counts) according to one of several pre-defined objectives |
| CRDFReactionReader | Reader for reaction data in the MDL RD-File [CTFILE] format |
| CRDFReactionWriter | Writer for reaction data in the MDL RD-File [CTFILE] format |
| CReaction | Abstract base class for chemical reactions composed of role-tagged Chem::Molecule components |
| CReactionAtomMappingMatchExpression | Chem::MatchExpression that constrains reaction substructure matches by a required reactant-to-product atom mapping |
| CReactionComponentGroupingMatchExpression | Chem::MatchExpression that constrains reaction substructure matches by the query's component-level groupings (typically derived from the parenthesization of a Daylight SMARTS [SMARTS] pattern) |
| CReactionSubstructureSearch | Reaction-level analogue of Chem::SubstructureSearch that locates atom/bond mappings of a query reaction pattern in a target reaction |
| CReactor | Applies a Chem::Reaction template to the reactant components of a target Chem::Reaction to generate the corresponding product molecules |
| CRECAPFragmentGenerator | Chem::FragmentGenerator implementation applying the RECAP [RECAP] cleavage rules (see Chem::RECAPRuleID) to produce a set of fragment building blocks from a molecular graph |
| ►CResonanceStructureGenerator | Enumerates the resonance structures of a molecular graph by redistributing π-electrons across the resonance-active bonds |
| CStructureData | Holds the per-atom formal charges and per-bond orders that define a single resonance structure |
| CRXNReactionReader | Reader for reaction data in the MDL Rxn-File [CTFILE] format |
| CRXNReactionWriter | Writer for reaction data in the MDL Rxn-File [CTFILE] format |
| CSDFMolecularGraphWriter | Writer for molecular graph data in the MDL SD-File [CTFILE] format |
| CSDFMoleculeReader | Reader for molecule data in the MDL SD-File [CTFILE] format |
| CSmallestSetOfSmallestRings | Implements the perception of the Smallest Set of Smallest Rings (SSSR) of a molecular graphs |
| CSMARTSMolecularGraphWriter | Writer for molecular graph data in the Daylight SMARTS [SMARTS] format |
| CSMARTSMoleculeReader | Reader for molecule data in the Daylight SMARTS [SMARTS] format |
| CSMARTSReactionReader | Reader for reaction data in the Daylight SMARTS [SMARTS] format |
| CSMARTSReactionWriter | Writer for reaction data in the Daylight SMARTS [SMARTS] format |
| CSMILESMolecularGraphWriter | Writer for molecular graph data in the Daylight SMILES [SMILES] format |
| CSMILESMoleculeReader | Reader for molecule data in the Daylight SMILES [SMILES] format |
| CSMILESReactionReader | Reader for reaction data in the Daylight SMILES [SMILES] format |
| CSMILESReactionWriter | Writer for reaction data in the Daylight SMILES [SMILES] format |
| CSpatialEntityAlignment | Computes a spatial alignment between two sets of entities (with 3D coordinates) by composing topological entity matching with Kabsch-style 3D superposition |
| CStereoDescriptor | Data structure for the storage and retrieval of stereochemical information about atoms and bonds |
| CStereoisomerGenerator | Enumerates the stereoisomers of a molecular graph by flipping the configurations of selected atom and bond stereocenters |
| CStringDataBlockEntry | Represents a data item consisting of a header and a data payload |
| CStringDataBlock | Array of Chem::StringDataBlockEntry objects |
| CSubstructureEditor | Pattern-driven editor that rewrites matched substructures of a Chem::Molecule using a result template, with optional exclude patterns guarding sites that must not be touched |
| ►CSubstructureHistogramCalculator | Counts occurrences of registered substructure patterns in a molecular graph, emitting the per-pattern hit counts into a user-supplied histogram container |
| CPattern | Stores a single substructure query molecular graph, its histogram ID, its priority and match-handling flags |
| CSubstructureSearch | Subgraph-isomorphism search of a query molecular graph against a target molecular graph, implemented after the VF2 algorithm |
| CSulfenicAcidTautomerization | Chem::TautomerizationRule implementation that enumerates the sulfenic-acid tautomers of an \( R{-}S{-}OH \rightleftharpoons R{-}S(=O)H \) system |
| CSurfaceAtomExtractor | Extracts the solvent-accessible surface atoms of a set of atoms |
| CSymmetryClassCalculator | Perceives topological-symmetry classes of the atoms in a molecular graph |
| CTautomerGenerator | Enumerates the tautomers of a molecular graph by iteratively applying a configurable set of Chem::TautomerizationRule instances and reporting each accepted tautomer to a user-supplied callback |
| CTautomerizationRule | Abstract base class for all tautomerization rule implementations used by the Chem::TautomerGenerator |
| CTautomerScore | Functor for the calculation of a heuristic stability score of a tautomeric form represented as a molecular graph |
| CTopologicalEntityAlignment | Computes a topological alignment between two sets of entities by reducing the alignment problem to a maximum-common-subgraph search on a compatibility graph |
| CXYZMolecularGraphWriter | Writer for molecular graph data in XYZ format to an output stream |
| CXYZMoleculeReader | Reader for molecule data in XYZ format from an input stream |
| ►NConfGen | Contains classes and functions related to conformer ensemble generation |
| NConformerSamplingMode | Provides constants used to specify the employed conformer sampling method |
| NControlParameter | Provides keys for built-in control-parameters |
| NControlParameterDefault | Provides default values for built-in control-parameters |
| NDataFormat | Provides preinitialized Base::DataFormat objects for all supported data formats |
| NForceFieldType | Provides constants used to specify the forcefield that shall be used for 3D coordinates refinement and energy calculations |
| NFragmentType | Provides constants that are used to describe the nature of fragments used to build-up molecule 3D models |
| NNitrogenEnumerationMode | Provides constants for specifying the mode of invertible nitrogen enumeration |
| NReturnCode | Provides constants that are used to describe the result of operations related to conformer generation |
| NStructureGenerationMode | Provides constants used to specify the 3D structure generation method that shall be employed |
| CCanonicalFragment | Data structure representing a canonicalized molecular fragment |
| CCFLMoleculeReader | Reader for molecule fragment data stored in the CDPL Conformer Generator Fragment Library (CFL) format |
| CConformerData | Container for the 3D coordinates of a generated conformer plus its associated energy value |
| CConformerGenerator | High-level driver for the generation of low-energy conformer ensembles of molecular graphs |
| CConformerGeneratorSettings | Bundle of configuration parameters for conformer ensemble generation via class ConfGen::ConformerGenerator |
| CDGConstraintGenerator | Constructs geometric constraints (distance, planarity, volume) for distance-geometry-based 3D structure generation |
| CDGConstraintGeneratorSettings | Bundle of configuration parameters for distance-geometry constraint generation via class ConfGen::DGConstraintGenerator |
| CDGStructureGenerator | Distance-geometry-based generation of raw 3D structures for molecular graphs |
| CDGStructureGeneratorSettings | Bundle of configuration parameters for raw coordinates generation via class ConfGen::DGStructureGenerator |
| CFragmentAssembler | Driver for the fragment-based generation of 3D starting conformers |
| CFragmentAssemblerSettings | Bundle of configuration parameters for fragment conformer assembly via class ConfGen::FragmentAssembler |
| CFragmentConformerGenerator | Driver for the generation of low-energy conformer ensembles for single molecular fragments (chain, small ring system or macrocycle) |
| ►CFragmentConformerGeneratorSettings | Bundle of configuration parameters for fragment conformer ensemble generation via class ConfGen::FragmentConformerGenerator |
| CFragmentSettings | Per-fragment-class settings (separate parameters for chain, small ring system and macrocycle fragments) |
| CFragmentLibrary | Data structure representing a library of pre-generated molecular fragment conformer ensembles |
| CFragmentLibraryEntry | Data structure representing a single entry of a conformer generation fragment library |
| CFragmentLibraryGenerator | Driver for populating a ConfGen::FragmentLibrary with conformers of canonicalized molecular fragments |
| CRMSDConformerSelector | Greedy RMSD-based conformer-diversity filter |
| CStructureGenerator | High-level driver for the generation of a single low-energy 3D structure from a molecular graph |
| CStructureGeneratorSettings | Bundle of configuration parameters for single 3D structure generation via class ConfGen::StructureGenerator |
| CTorsionCategory | Represents a node of a hierarchical torsion library |
| CTorsionDriver | Driver for the systematic enumeration of conformers obtained by rotating around rotatable bonds of a molecular graph, using preferred torsion angles taken from configured ConfGen::TorsionLibrary instances |
| CTorsionDriverSettings | Bundle of configuration parameters for systematic conformer enumeration via class ConfGen::TorsionDriver |
| CTorsionLibrary | Data structure representing a hierarchical library of torsion rules organized into categories |
| ►CTorsionRule | Data structure for the representation of single torsion library rules |
| CAngleEntry | One preferred torsion angle for a rule, characterized by its value, the two tolerance bands and a score |
| CTorsionRuleMatch | A single match of a ConfGen::TorsionRule against a rotatable bond: the rule, the bond and the four atoms that span the torsion |
| CTorsionRuleMatcher | Finds torsion rules from a ConfGen::TorsionLibrary instance that match a given rotatable bond |
| ►NDescr | Contains classes and functions related to the generation and processing of pharmacophore and molecule descriptors |
| CAtomAutoCorrelation3DVectorCalculator | AutoCorrelation3DVectorCalculator implementation for the calculation of atom-centered 3D auto-correlation vectors of chemical structures |
| CAtomRDFCodeCalculator | RDFCodeCalculator implementation for the calculation of atom-centered radial distribution function (RDF) codes of chemical structures |
| CAutoCorrelation2DVectorCalculator | Calculation of the topological (2D) auto-correlation vector of a molecular graph |
| CAutoCorrelation3DVectorCalculator | Generic implementation of the 3D auto-correlation vector calculation for sequences of entities of arbitrary type |
| CBCUTDescriptorCalculator | Calculation of the BCUT (Burden-CAS-University-of-Texas) descriptor of a molecular graph |
| CBulkSimilarityCalculator | Calculator that performs a bulk pairwise comparison of a single query descriptor against a stored set of target descriptors using a configurable similarity function |
| CBurdenMatrixGenerator | Calculation of the Burden matrix of a molecular graph |
| ►CCircularFingerprintGenerator | Generation of atom-centered circular substructure fingerprints in the spirit of SciTegic's Extended Connectivity Fingerprints (ECFP) |
| CDefAtomIdentifierFunctor | The functor for the generation of ECFP atom identifiers |
| CDefBondIdentifierFunctor | The default functor for the generation of bond identifiers |
| CFeatureAutoCorrelation3DVectorCalculator | AutoCorrelation3DVectorCalculator specialization for feature-centered 3D auto-correlation vectors of pharmacophores |
| CFeatureRDFCodeCalculator | RDFCodeCalculator implementation for the calculation of feature-centered radial distribution function (RDF) codes of pharmacophores |
| CKuvekPocketDescriptorCalculator | Implements the algorithm devised by Kuvek et al. [KBPD] for the calculation of receptor binding pocket shape and surface electrostatics descriptors |
| CMACCSFingerprintGenerator | Generation of 166 bit MACCS key fingerprints |
| CMolecularComplexityCalculator | Calculation of the molecular complexity of a molecular graph after Hendrickson, Huang and Toczko |
| CMoleculeAutoCorr2DDescriptorCalculator | Calculation of a topological (2D) auto-correlation descriptor of a molecular graph partitioned by specific atom types |
| CMoleculeAutoCorr3DDescriptorCalculator | Calculation of a 3D auto-correlation descriptor of a molecular graph partitioned by specific atom types |
| CMoleculeRDFDescriptorCalculator | Calculation of an RDF descriptor of a molecular graph partitioned by specific atom types |
| CNPoint2DPharmacophoreFingerprintGenerator | N-point pharmacophore fingerprint generator that uses topological feature distances |
| CNPoint3DPharmacophoreFingerprintGenerator | N-point pharmacophore fingerprint generator that uses spatial 3D feature distances |
| CNPointPharmacophoreFingerprintGenerator | Abstract base for N-point pharmacophore fingerprint generators |
| ►CPathFingerprintGenerator | Generation of Daylight-style path fingerprints of molecular graphs |
| CDefAtomDescriptorFunctor | The default functor for the generation of atom descriptors |
| CDefBondDescriptorFunctor | The default functor for the generation of bond descriptors |
| CPharmacophoreAutoCorr3DDescriptorCalculator | Calculation of a 3D auto-correlation descriptor of a pharmacophore partitioned by specific feature types |
| CPharmacophoreRDFDescriptorCalculator | Calculation of an RDF descriptor of a pharmacophore partitioned by specific feature types |
| CPubChemFingerprintGenerator | Generation of 881 bit PubChem fingerprints |
| CRDFCodeCalculator | Generic implementation of the radial distribution function (RDF) code calculation for sequences of entities of arbitrary type |
| CTanimotoSimilarity | Functor class for calculating Tanimoto Similarities [CITB] of bitsets and vectors |
| CCosineSimilarity | Functor class for calculating Cosine Similarities [WCOS] of bitsets and vectors |
| CEuclideanSimilarity | Functor class for calculating the Euclidean Similarity [GSIM] of bitsets |
| CManhattanSimilarity | Functor class for calculating the Manhattan Similarity [GSIM] of bitsets |
| CDiceSimilarity | Functor class for calculating the Dice Similarity [GSIM] of bitsets |
| CTverskySimilarity | Functor class for calculating the Tversky Similarity [GSIM] of bitsets |
| CHammingDistance | Functor class for calculating the Hamming Distance [WHAM, CITB] between bitsets |
| CManhattanDistance | Functor class for calculating the Manhattan Distance [MADI] between bitsets and vectors |
| CEuclideanDistance | Functor class for calculating the Euclidean Distance [CITB] between bitsets and vectors |
| ►NForceField | Contains classes and functions related to molecular force fields |
| NAtomProperty | Provides keys for built-in Chem::Atom properties |
| NBondProperty | Provides keys for built-in Chem::Bond properties |
| NInteractionType | Provides flags for the specification of a set of force field interaction types |
| NMMFF94ParameterSet | Provides constants for the specification of a MMFF94 parameter set variant |
| NMolecularGraphProperty | Provides keys for built-in Chem::MolecularGraph properties |
| NUFFAtomType | Provides constants for the specification of numeric Universal Force Field (UFF) atom types |
| CElasticPotential | Stores parameters for an elastic potential (harmonic distance restraint) between a pair of atoms |
| CError | Base class of the ForceField subsystem exception hierarchy |
| CParameterizationFailed | Thrown when force field parameterization has failed |
| CGradientVectorTraits | Generic primary traits template providing zero-initialization for a 3D gradient vector container of type GV |
| CGradientVectorTraits< Math::VectorArray< V > > | ForceField::GradientVectorTraits specialization for containers of type Math::VectorArray |
| CGradientVectorTraits< std::vector< V > > | ForceField::GradientVectorTraits specialization for containers of type std::vector |
| CMMFF94AngleBendingInteraction | Stores parameters for a single MMFF94 angle-bending interaction defined over an atom triplet |
| CMMFF94AngleBendingInteractionParameterizer | Detects and parameterizes the MMFF94 angle-bending interactions of a molecular graph |
| ►CMMFF94AngleBendingParameterTable | Data structure for the storage and lookup of MMFF94 angle-bending interaction parameters |
| CEntry | Data structure for the storage of values associated with a single table entry |
| ►CMMFF94AromaticAtomTypeDefinitionTable | Data structure for the storage and lookup of MMFF94 aromatic atom type definitions |
| CEntry | Data structure for the storage of values associated with a single table entry |
| CMMFF94AromaticSSSRSubset | Implements the extraction of all rings in the SSSR of a molecular graph that are considered aromatic according to the MMFF94 aromaticity model |
| ►CMMFF94AtomTypePropertyTable | Data structure for the storage and lookup of structural and chemical property data associated with numeric MMFF94 atom types |
| CEntry | Data structure for the storage of values associated with a single table entry |
| CMMFF94AtomTyper | Assigns MMFF94 symbolic and numeric atom types to the atoms of a molecular graph |
| ►CMMFF94BondChargeIncrementTable | Data structure for the storage and lookup of MMFF94 bond charge increments |
| CEntry | Data structure for the storage of values associated with a single table entry |
| CMMFF94BondStretchingInteraction | Stores parameters for a single MMFF94 bond-stretching interaction between two bonded atoms |
| CMMFF94BondStretchingInteractionParameterizer | Detects and parameterizes the MMFF94 bond-stretching interactions of a molecular graph |
| ►CMMFF94BondStretchingParameterTable | Data structure for the storage and lookup of MMFF94 bond-stretching interaction parameters |
| CEntry | Data structure for the storage of values associated with a single table entry |
| ►CMMFF94BondStretchingRuleParameterTable | Data structure for the storage and lookup of MMFF94 bond-stretching interaction fallback parameters |
| CEntry | Data structure for the storage of values associated with a single table entry |
| CMMFF94BondTyper | Assigns MMFF94 bond type indices to the bonds of a molecular graph |
| CMMFF94ChargeCalculator | Calculator for the MMFF94 partial atomic charges of a molecular graph |
| ►CMMFF94DefaultStretchBendParameterTable | Data structure for the storage and lookup of MMFF94 stretch-bend interaction fallback parameters |
| CEntry | Data structure for the storage of values associated with a single table entry |
| CMMFF94ElectrostaticInteraction | Stores parameters for a single MMFF94 electrostatic interaction between two non-bonded atoms |
| CMMFF94ElectrostaticInteractionParameterizer | Detects and parameterizes the MMFF94 electrostatic interactions of a molecular graph |
| CMMFF94EnergyCalculator | Calculates the total MMFF94 force field energy for a set of atom 3D coordinates |
| ►CMMFF94FormalAtomChargeDefinitionTable | Data structure for the storage and lookup of formal charge definitions used by the MMFF94 charge model |
| CEntry | Data structure for the storage of values associated with a single table entry |
| CMMFF94GradientCalculator | Calculates the total MMFF94 force field energy and its gradient for a set of atom 3D coordinates |
| CMMFF94HeavyToHydrogenAtomTypeMap | Data structure for the storage and lookup of heavy-to-hydrogen symbolic MMFF94 atom type mappings |
| CMMFF94InteractionData | Container holding the full set of MMFF94 interaction parameter records for a molecular graph |
| CMMFF94InteractionParameterizer | Highly configurable implementation of the complete workflow for molecular graph MMFF94 interaction perception and parameterization |
| CMMFF94OutOfPlaneBendingInteraction | Stores parameters for a single MMFF94 out-of-plane bending interaction at a trigonal center |
| CMMFF94OutOfPlaneBendingInteractionParameterizer | Detects and parameterizes the MMFF94 out-of-plane bending interactions of a molecular graph |
| ►CMMFF94OutOfPlaneBendingParameterTable | Data structure for the storage and lookup of MMFF94 out-of-plane bending interaction force constants |
| CEntry | Data structure for the storage of values associated with a single table entry |
| ►CMMFF94PartialBondChargeIncrementTable | Data structure for the storage and lookup of MMFF94 per-atom partial bond charge increment and formal charge adjustment factors |
| CEntry | Data structure for the storage of values associated with a single table entry |
| ►CMMFF94PrimaryToParameterAtomTypeMap | Data structure for the storage and lookup of primary numeric MMFF94 atom type to fallback parameter atom type list mappings |
| CEntry | Data structure for the storage of values associated with a single table entry |
| CMMFF94StretchBendInteraction | Stores paramters for a single MMFF94 stretch-bend coupling interaction |
| CMMFF94StretchBendInteractionParameterizer | Detects and parameterizes the MMFF94 stretch-bend interactions of a molecular graph |
| ►CMMFF94StretchBendParameterTable | Data structure for the storage and lookup of MMFF94 stretch-bend interaction parameters |
| CEntry | Data structure for the storage of values associated with a single table entry |
| ►CMMFF94SymbolicAtomTypePatternTable | Data structure storing SMARTS substructure patterns used to assign symbolic MMFF94 atom types during atom typing |
| CEntry | A single atom type pattern record |
| CMMFF94SymbolicToNumericAtomTypeMap | Lookup table mapping each symbolic MMFF94 atom type to its corresponding numeric MMFF94 atom type |
| CMMFF94TorsionInteraction | Stores parameters for a single MMFF94 torsion interaction over an atom quadruplet i-j-k-l |
| CMMFF94TorsionInteractionParameterizer | Detects and parameterizes the MMFF94 torsion interactions of a molecular graph |
| ►CMMFF94TorsionParameterTable | Data structure for the storage and lookup of MMFF94 torsion interaction parameters |
| CEntry | Data structure for the storage of values associated with a single table entry |
| CMMFF94VanDerWaalsInteraction | Stores parameters for a single MMFF94 Van der Waals interaction between two non-bonded atoms |
| CMMFF94VanDerWaalsInteractionParameterizer | Detects and parameterizes the MMFF94 Van der Waals interactions of a molecular graph |
| ►CMMFF94VanDerWaalsParameterTable | Data structure for the storage and lookup of MMFF94 interaction parameters |
| CEntry | Data structure for the storage of values associated with a single table entry |
| ►CUFFAtomTypePropertyTable | Data structure for the storage and lookup of various properties associated with numeric UFF atom types |
| CEntry | Data structure for the storage of values associated with a single table entry |
| ►NGRAIL | Contains classes and functions related to the GRAIL method [GRAIL, GRADE] |
| NAttributedGridProperty | Provides keys for built-in Grid::AttributedGrid properties |
| NAttributedGridPropertyDefault | Provides default values for built-in Grid::AttributedGrid properties |
| NFeatureType | Provides constants for the specification of GRAIL-specific extended pharmacophore feature types that refine H-bond donor and acceptor categories by the chemical environment (atom element + SYBYL-like type) of the participating heavy atom |
| CAtomDensityGridCalculator | Calculator that fills a spatial grid with combined per-atom density contributions |
| CBindingAffinityCalculator | Predicts the binding affinity of a ligand pose from its GRAIL descriptor vector |
| CBuriednessGridCalculator | Calculator that fills a spatial grid with per-cell buriedness scores derived from GRAIL::BuriednessScore |
| CBuriednessScore | Functor for the calculation of the buriedness of a 3D query position with respect to the surrounding atoms |
| ►CFeatureInteractionScoreGridCalculator | Calculator that fills a spatial grid with per-cell feature-interaction scores against a set of target pharmacophore features |
| CMaxScoreFunctor | Score-combination functor returning the maximum (infinity norm) of the per-feature scores |
| CScoreSumFunctor | Score-combination functor returning the sum of the per-feature scores |
| CGeneralizedBellAtomDensity | Functor for the evaluation of the generalized-bell atom density contribution of an atom at a query position |
| CGRAILDataSetGenerator | Generator that pre-computes the per-cell interaction-score grids and the atom-density grid used by GRAIL scoring of ligand poses against a target environment |
| CGRAILDescriptorCalculator | Calculation of GRAIL descriptors for protein-ligand complexes |
| CGRAILXDescriptorCalculator | Calculation of the extended GRAIL-X descriptor for protein-ligand complexes |
| ►NGrid | Contains classes and functions related to grid based data representation and processing |
| NAttributedGridProperty | Provides keys for built-in Grid::AttributedGrid properties |
| NAttributedGridPropertyDefault | Provides default values for built-in Grid::AttributedGrid properties |
| NControlParameter | Provides keys for built-in control-parameters |
| NControlParameterDefault | Provides default values for built-in control-parameters |
| NDataFormat | Provides preinitialized Base::DataFormat objects for all supported data formats |
| CRegularGrid | Implementation of the Grid::SpatialGrid interface for regular spatial grids |
| CRegularGridSet | Indirected array of dynamically allocated Grid::RegularGrid instances |
| CAttributedGrid | Abstract base class for grid types that also carry generic key/value properties |
| CCDFDRegularGridReader | Reader for regular spatial grid data in the native I/O format of the CDPL |
| CCDFDRegularGridSetReader | Reader for regular spatial grid set data in the native I/O format of the CDPL |
| CCDFDRegularGridSetWriter | Writer for regular spatial grid set data in the native I/O format of the CDPL |
| CCDFDRegularGridWriter | Writer for regular spatial grid data in the native I/O format of the CDPL |
| CCUBEDRegularGridReader | Reader for regular spatial grid data in the Gaussian CUBE [CUBE] format |
| CCUBEDRegularGridWriter | Writer for regular spatial grid data in the Gaussian CUBE [CUBE] format |
| CSpatialGrid | Abstract base class for attributed grids whose elements have a defined 3D position in space |
| ►NMath | Contains classes and functions related to mathematics |
| CMatrixReference | Lightweight matrix expression that proxies a reference to an underlying matrix container |
| CVector | Dynamically-sized dense vector with configurable underlying storage |
| CMatrix | Dynamically-sized dense row-major matrix with configurable underlying storage |
| CRotationMatrix | \( N \times N \) rotation matrix backed by a unit quaternion (or an axis-angle representation) |
| CScalingMatrix | \( N \times N \) diagonal scaling matrix |
| CTranslationMatrix | \( N \times N \) translation matrix in homogeneous coordinates |
| CBFGSMinimizer | Implementation of the Broyden-Fletcher-Goldfarb-Shanno (BFGS) algorithm for solving unconstrained nonlinear optimization problems |
| CCommonType | Trait that resolves the common arithmetic type of T1 and T2 via std::common_type |
| CDirectAssignmentProxy | Proxy that converts an assignment to a Math container into the corresponding direct-assignment call on the container (assign / plusAssign / minusAssign) bypassing alias detection |
| CExpression | CRTP base class for all numeric expression types in the Math namespace (Barton-Nackman idiom) |
| CVectorExpression | CRTP base class for all vector expression types |
| CMatrixExpression | CRTP base class for all matrix expression types |
| CQuaternionExpression | CRTP base class for all quaternion expression types |
| CGridExpression | CRTP base class for all grid expression types |
| CVectorContainer | Refinement of Math::VectorExpression marking the derived type as a concrete (writable) vector container |
| CMatrixContainer | Refinement of Math::MatrixExpression marking the derived type as a concrete (writable) matrix container |
| CQuaternionContainer | Refinement of Math::QuaternionExpression marking the derived type as a concrete (writable) quaternion container |
| CGridContainer | Refinement of Math::GridExpression marking the derived type as a concrete (writable) grid container |
| CScalarBinaryAssignmentFunctor | Base class for binary in-place assignment functors of the form F::apply(T1, const T2&) |
| CScalarAssignment | Scalar plain-assignment functor: apply(t1, t2) performs t1 = t2 |
| CScalarAdditionAssignment | Scalar in-place addition functor: apply(t1, t2) performs t1 += t2 |
| CScalarSubtractionAssignment | Scalar in-place subtraction functor: apply(t1, t2) performs t1 -= t2 |
| CScalarMultiplicationAssignment | Scalar in-place multiplication functor: apply(t1, t2) performs t1 *= t2 |
| CScalarDivisionAssignment | Scalar in-place division functor: apply(t1, t2) performs t1 /= t2 |
| CScalarUnaryFunctor | Base class for unary scalar functors of the form F::apply(const T&) returning a T result |
| CScalarNegation | Scalar negation functor: apply(v) returns -v |
| CScalarConjugation | Scalar complex-conjugation functor: apply(v) returns \( \overline{v} \) (identity for real types) |
| CScalarRealUnaryFunctor | Base class for unary scalar functors that return the real part of T (Math::ScalarReal, Math::ScalarImaginary) |
| CScalarReal | Scalar real-part functor: apply(v) returns \( \mathrm{Re}(v) \) (identity for real types) |
| CScalarImaginary | Scalar imaginary-part functor: apply(v) returns \( \mathrm{Im}(v) \) (zero for real types) |
| CScalarBinaryFunctor | Base class for binary scalar functors of the form F::apply(const T1&, const T2&) returning a Math::CommonType result |
| CScalarAddition | Scalar binary addition functor: apply(t1, t2) returns t1 + t2 |
| CScalarSubtraction | Scalar binary subtraction functor: apply(t1, t2) returns t1 - t2 |
| CScalarMultiplication | Scalar binary multiplication functor: apply(t1, t2) returns t1 * t2 |
| CScalarDivision | Scalar binary division functor: apply(t1, t2) returns t1 / t2 |
| CVectorScalarBinaryFunctor | Base class for binary functors that take two vectors and return a scalar (Math::VectorInnerProduct, Math::VectorAngleCosine) |
| CVectorInnerProduct | Vector inner-product functor: apply(e1, e2) returns \( \sum_i e_1(i) \cdot e_2(i) \) |
| CVectorAngleCosine | Functor returning the cosine of the angle between two vectors (optionally clamped to [-1, 1]) |
| CVectorBooleanBinaryFunctor | Base class for binary functors that take two vectors and return a boolean (Math::VectorEquality and similar) |
| CVectorEquality | Vector equality functor: apply(e1, e2) tests element-wise equality of two vector expressions |
| CScalar3VectorBooleanTernaryFunctor | Base class for ternary functors that take two vectors and a scalar tolerance and return a boolean (Math::VectorToleranceEquality) |
| CVectorToleranceEquality | Vector tolerance-equality functor: apply(e1, e2, eps) tests element-wise equality within an absolute tolerance |
| CVectorBinaryFunctor | Base class for binary functors that take two vectors and return a vector (Math::VectorCrossProduct) |
| CVectorCrossProduct | Vector cross-product functor: apply(e1, e2, i) returns the i-th component of the 3D vector cross product \( e_1 \times e_2 \) |
| CVectorScalarUnaryFunctor | Base class for unary functors that take a vector and return a scalar (Math::VectorElementSum) |
| CVectorElementSum | Functor returning the sum of all elements of a vector expression |
| CVectorScalarRealUnaryFunctor | Base class for unary functors that take a vector and return a real-valued scalar (Math::VectorNorm1, Math::VectorNorm2, Math::VectorNormInfinity) |
| CVectorNorm1 | Functor returning the L1 norm of a vector expression |
| CVectorNorm2 | Functor returning the L2 (Euclidean) norm of a vector expression |
| CVectorNormInfinity | Functor returning the L∞ (maximum-magnitude) norm of a vector expression |
| CVectorScalarIndexUnaryFunctor | Base class for unary functors that take a vector and return a vector-element index (Math::VectorNormInfinityIndex) |
| CVectorNormInfinityIndex | Functor returning the index of the vector element with the largest L∞ norm |
| CMatrixBooleanBinaryFunctor | Base class for binary functors that take two matrix expressions and return a bool result (Math::MatrixEquality) |
| CMatrixEquality | Functor checking element-wise equality of two matrix expressions |
| CScalar3MatrixBooleanTernaryFunctor | Base class for ternary functors that take two matrix expressions plus a tolerance scalar and return a bool result (Math::MatrixToleranceEquality) |
| CMatrixToleranceEquality | Functor checking element-wise approximate equality of two matrix expressions within an absolute tolerance |
| CMatrixScalarUnaryFunctor | Base class for unary functors that take a matrix expression and return a scalar result (Math::MatrixElementSum, Math::MatrixTrace) |
| CMatrixElementSum | Functor returning the sum of all elements of a matrix expression |
| CMatrixTrace | Functor returning the trace (sum of diagonal entries) of a matrix expression |
| CMatrixScalarRealUnaryFunctor | Base class for unary functors that take a matrix expression and return a real-valued scalar (Math::MatrixNorm1, Math::MatrixNormFrobenius, Math::MatrixNormInfinity) |
| CMatrixNorm1 | Functor returning the L1 (maximum absolute column sum) norm of a matrix expression |
| CMatrixNormFrobenius | Functor returning the Frobenius norm of a matrix expression |
| CMatrixNormInfinity | Functor returning the L∞ (maximum absolute row sum) norm of a matrix expression |
| CVectorMatrixUnaryFunctor | Base class for unary functors that produce a matrix element from a vector expression and (i, j) cell indices (Math::DiagonalMatrixFromVector, Math::CrossProductMatrixFromVector) |
| CDiagonalMatrixFromVector | Functor producing the diagonal matrix element at (i, j) from a vector expression ( \( e(i) \) on the diagonal, 0 elsewhere) |
| CCrossProductMatrixFromVector | Functor producing the cross-product (skew-symmetric) matrix element at (i, j) for a 3D vector expression |
| CMatrixVectorBinaryFunctor | Base class for binary functors that take a matrix expression and a vector expression and return a vector element scalar result (Math::MatrixVectorProduct, Math::VectorMatrixProduct) |
| CMatrixVectorProduct | Functor returning element i of the matrix-vector product \( e_1 \cdot e_2 \) |
| CVectorMatrixProduct | Functor returning element i of the vector-matrix product \( e_1 \cdot e_2 \) |
| CMatrixBinaryFunctor | Base class for binary functors that take two matrix expressions and return a matrix element scalar result (Math::MatrixProduct) |
| CMatrixProduct | Functor returning element (i, j) of the matrix product \( e_1 \cdot e_2 \) |
| CQuaternionBooleanBinaryFunctor | Base class for binary functors that take two quaternion expressions and return a bool result (Math::QuaternionEquality) |
| CQuaternionEquality | Functor checking component-wise equality of two quaternion expressions |
| CScalar3QuaternionBooleanTernaryFunctor | Base class for ternary functors that take two quaternion expressions plus a tolerance scalar and return a bool result (Math::QuaternionToleranceEquality) |
| CQuaternionToleranceEquality | Functor checking component-wise approximate equality of two quaternion expressions within an absolute tolerance |
| CQuaternionScalarUnaryFunctor | Base class for unary functors that take a quaternion expression and return a scalar result (Math::QuaternionElementSum) |
| CQuaternionElementSum | Functor returning the sum of the four components of a quaternion expression |
| CQuaternionScalarRealUnaryFunctor | Base class for unary functors that take a quaternion expression and return a real-valued scalar (Math::QuaternionNorm, Math::QuaternionNorm2) |
| CQuaternionNorm | Functor returning the (Euclidean) norm \( \|e\| \) of a quaternion expression |
| CQuaternionNorm2 | Functor returning the squared norm \( \|e\|^2 \) of a quaternion expression |
| CQuaternionUnaryFunctor | Base class for per-component unary functors that take a quaternion expression and produce a quaternion result via applyC1 / applyC2 / applyC3 / applyC4 (Math::QuaternionUnreal, Math::QuaternionConjugate) |
| CQuaternionUnreal | Per-component functor returning the unreal (pure-quaternion) part of a quaternion expression (zeros C1, keeps C2/C3/C4) |
| CQuaternionConjugate | Per-component functor returning the quaternion conjugate (keeps C1, negates C2/C3/C4) |
| CScalar1QuaternionBinaryFunctor | Base class for per-component binary functors that take a scalar T (lhs) and a quaternion expression (Math::Scalar1QuaternionAddition, Math::Scalar1QuaternionSubtraction) |
| CScalar1QuaternionAddition | Per-component functor returning \( t + e \) (scalar t added to the real component of e) |
| CScalar1QuaternionSubtraction | Per-component functor returning \( t - e \) (scalar t with the quaternion e subtracted) |
| CScalar2QuaternionBinaryFunctor | Base class for per-component binary functors that take a quaternion expression (lhs) and a scalar T (Math::Scalar2QuaternionAddition, Math::Scalar2QuaternionSubtraction, Math::QuaternionInverse) |
| CScalar2QuaternionAddition | Per-component functor returning \( e + t \) (scalar t added to the real component of e) |
| CScalar2QuaternionSubtraction | Per-component functor returning \( e - t \) (scalar t subtracted from the real component of e) |
| CQuaternionInverse | Per-component functor returning the multiplicative inverse \( \overline{e} / \|e\|^2 \) of a quaternion expression (n2 is the precomputed squared norm) |
| CQuaternionBinaryFunctor | Base class for per-component binary functors that take two quaternion expressions and produce a quaternion result (Math::QuaternionProduct) |
| CQuaternionProduct | Per-component functor returning the Hamilton product \( e_1 \cdot e_2 \) of two quaternion expressions |
| CScalar3QuaternionTernaryFunctor | Base class for per-component ternary functors that take two quaternion expressions plus a scalar (Math::QuaternionDivision) |
| CQuaternionDivision | Per-component functor returning the quaternion division \( e_1 \cdot e_2^{-1} \) (n2 is the precomputed squared norm of e_2) |
| CScalar13QuaternionTernaryFunctor | Base class for per-component ternary functors that take a scalar T1 (lhs), a quaternion expression, and a scalar T2 (Math::ScalarQuaternionDivision) |
| CScalarQuaternionDivision | Per-component functor returning the scalar/quaternion division \( t \cdot e^{-1} \) (n2 is the precomputed squared norm of e) |
| CQuaternionVectorBinaryFunctor | Base class for binary functors that take a quaternion expression and a vector expression and return a vector element scalar (Math::QuaternionVectorRotation) |
| CQuaternionVectorRotation | Functor returning element i of the rotated 3-dimensional vector \( e_1 \cdot e_2 \cdot e_1^{-1} \) (quaternion rotation of \( e_2 \) by \( e_1 \)) |
| CGridBooleanBinaryFunctor | Base class for binary functors that take two grid expressions and return a bool result (Math::GridEquality) |
| CGridEquality | Functor checking cell-wise equality of two grid expressions |
| CScalar3GridBooleanTernaryFunctor | Base class for ternary functors that take two grid expressions plus a tolerance scalar and return a bool result (Math::GridToleranceEquality) |
| CGridToleranceEquality | Functor checking cell-wise approximate equality of two grid expressions within an absolute tolerance |
| CGridScalarUnaryFunctor | Base class for unary functors that take a grid expression and return a scalar result (Math::GridElementSum) |
| CGridElementSum | Functor returning the sum of all cells of a grid expression |
| CGridReference | Lightweight grid expression that proxies a reference to an underlying grid container |
| CGrid | Dynamically-sized dense 3D grid ( \( d_1 \times d_2 \times d_3 \)) with configurable underlying storage |
| CZeroGrid | Constant grid expression whose cells are all zero |
| CScalarGrid | Constant grid expression in which every cell equals the same scalar value |
| CGridTemporaryTraits< GridReference< G > > | Math::GridTemporaryTraits specialization inheriting the temporary type of the underlying grid for a Math::GridReference view |
| CGridTemporaryTraits< const GridReference< G > > | Math::GridTemporaryTraits specialization inheriting the temporary type of the underlying grid for a const Math::GridReference view |
| CGridUnary | Expression-template node applying a unary functor F element-wise to a grid expression E |
| CGridUnaryTraits | Traits selecting the expression-template node and its result type for the Math::GridUnary instantiation <E, F> |
| CGridBinary1 | Expression-template node combining two grid expressions E1 and E2 element-wise via the binary functor F |
| CGridBinary1Traits | Traits selecting the expression-template node and its result type for the Math::GridBinary1 instantiation Binary <E1, E2, F> |
| CScalar1GridBinary | Expression-template node combining a scalar E1 (lhs) and a grid expression E2 (rhs) element-wise via the binary functor F |
| CScalar1GridBinaryTraits | Traits selecting the expression-template node and its result type for the Math::Scalar1GridBinary instantiation <E1, E2, F> |
| CScalar2GridBinary | Expression-template node combining a grid expression E1 (lhs) and a scalar E2 (rhs) element-wise via the binary functor F |
| CScalar2GridBinaryTraits | Traits selecting the expression-template node and its result type for the Math::Scalar2GridBinary instantiation <E1, E2, F> |
| CKabschAlgorithm | Implementation of the Kabsch algorithm [KABA] |
| CInitListMatrix | Lightweight matrix container that wraps a nested std::initializer_list of T values |
| CSparseMatrix | Sparse matrix that stores only non-default entries keyed by a packed (row, column) identifier |
| CBoundedVector | Variable-size vector with a fixed upper capacity N stored in a stack-allocated array |
| CBoundedMatrix | Variable-size matrix with fixed upper capacities M \( \times \) N stored in a stack-allocated array |
| CCMatrix | Fixed-size dense matrix of dimensions M \( \times \) N backed by a 2D C-array (no dynamic allocation) |
| CZeroMatrix | Constant matrix expression whose entries are all zero |
| CScalarMatrix | Constant matrix expression in which every entry equals the same scalar value |
| CIdentityMatrix | Constant identity-matrix expression (1 on the diagonal, 0 elsewhere) |
| CVectorTemporaryTraits< MatrixReference< M > > | Math::VectorTemporaryTraits specialization inheriting the temporary type of the underlying matrix for a Math::MatrixReference view |
| CVectorTemporaryTraits< const MatrixReference< M > > | Math::VectorTemporaryTraits specialization inheriting the temporary type of the underlying matrix for a const Math::MatrixReference view |
| CMatrixTemporaryTraits< MatrixReference< M > > | Math::MatrixTemporaryTraits specialization inheriting the temporary type of the underlying matrix for a Math::MatrixReference view |
| CMatrixTemporaryTraits< const MatrixReference< M > > | Math::MatrixTemporaryTraits specialization inheriting the temporary type of the underlying matrix for a const Math::MatrixReference view |
| CRange | Half-open index range \( [start, stop) \) used for slicing vector and matrix expressions |
| CLower | Tag selecting the lower-triangular view (entries strictly above the diagonal read as zero) for Math::TriangularAdapter |
| CUnitLower | Tag selecting the unit-lower-triangular view (zero above the diagonal, one on the diagonal) for Math::TriangularAdapter |
| CUpper | Tag selecting the upper-triangular view (entries strictly below the diagonal read as zero) for Math::TriangularAdapter |
| CUnitUpper | Tag selecting the unit-upper-triangular view (zero below the diagonal, one on the diagonal) for Math::TriangularAdapter |
| CTriangularAdapter | Matrix expression that exposes only the triangular part of an underlying matrix M selected by the policy Tri (Math::Lower, Math::UnitLower, Math::Upper or Math::UnitUpper) |
| CVectorTemporaryTraits< TriangularAdapter< M, Tri > > | Math::VectorTemporaryTraits specialization inheriting the temporary type of the wrapped matrix for a Math::TriangularAdapter view |
| CVectorTemporaryTraits< const TriangularAdapter< M, Tri > > | Math::VectorTemporaryTraits specialization inheriting the temporary type of the wrapped matrix for a const Math::TriangularAdapter view |
| CMatrixTemporaryTraits< TriangularAdapter< M, Tri > > | Math::MatrixTemporaryTraits specialization inheriting the temporary type of the wrapped matrix for a Math::TriangularAdapter view |
| CMatrixTemporaryTraits< const TriangularAdapter< M, Tri > > | Math::MatrixTemporaryTraits specialization inheriting the temporary type of the wrapped matrix for a const Math::TriangularAdapter view |
| CMatrixUnary | Expression-template node applying a unary functor F element-wise to a matrix expression E |
| CMatrixUnaryTraits | Traits selecting the expression-template node and its result type for the Math::MatrixUnary instantiation <E, F> |
| CVectorMatrixUnary | Expression-template node interpreting a vector expression E as a column matrix via the per-element functor F |
| CVectorMatrixUnaryTraits | Traits selecting the expression-template node and its result type for the Math::VectorMatrixUnary instantiation <E, F> |
| CMatrixBinary1 | Expression-template node combining two matrix expressions E1 and E2 element-wise via the binary functor F |
| CMatrixBinary1Traits | Traits selecting the expression-template node and its result type for the Math::MatrixBinary1 instantiation <E1, E2, F> |
| CMatrixBinary2 | Expression-template node combining two matrix expressions E1 and E2 via a binary functor F that is invoked with both expressions plus the (i, j) cell indices |
| CMatrixBinary2Traits | Traits selecting the expression-template node and its result type for the Math::MatrixBinary2 instantiation <E1, E2, F> |
| CVectorMatrixBinary | Expression-template node interpreting a binary combination of two vector expressions as a matrix (e.g. outer product), via the per-cell functor F invoked with both expressions and the cell coordinates |
| CVectorMatrixBinaryTraits | Traits selecting the expression-template node and its result type for the Math::VectorMatrixBinary instantiation <E1, E2, F> |
| CMatrix1VectorBinary | Expression-template node interpreting a binary combination of a matrix expression E1 and a vector expression E2 as a vector (e.g. matrix-vector product), via the per-element functor F invoked with both expressions and the index |
| CMatrix1VectorBinaryTraits | Traits selecting the expression-template node and its result type for the Math::Matrix1VectorBinary instantiation <E1, E2, F> |
| CMatrix2VectorBinary | Expression-template node interpreting a binary combination of a vector expression E1 and a matrix expression E2 as a vector (e.g. vector-matrix product), via the per-element functor F invoked with both expressions and the index |
| CMatrix2VectorBinaryTraits | Traits selecting the expression-template node and its result type for the Math::Matrix2VectorBinary instantiation <E1, E2, F> |
| CScalar1MatrixBinary | Expression-template node combining a scalar E1 (lhs) and a matrix expression E2 (rhs) element-wise via the binary functor F |
| CScalar1MatrixBinaryTraits | Traits selecting the expression-template node and its result type for the Math::Scalar1MatrixBinary instantiation <E1, E2, F> |
| CScalar2MatrixBinary | Expression-template node combining a matrix expression E1 (lhs) and a scalar E2 (rhs) element-wise via the binary functor F |
| CScalar2MatrixBinaryTraits | Traits selecting the expression-template node and its result type for the Math::Scalar2MatrixBinary instantiation <E1, E2, F> |
| CMatrixTranspose | Mutable view adapter that exposes the transpose of a matrix M as a matrix expression ( \( (i, j) \to M(j, i) \)) |
| CVectorTemporaryTraits< MatrixTranspose< M > > | Math::VectorTemporaryTraits specialization inheriting the temporary type of the wrapped matrix for a Math::MatrixTranspose view |
| CVectorTemporaryTraits< const MatrixTranspose< M > > | Math::VectorTemporaryTraits specialization inheriting the temporary type of the wrapped matrix for a const Math::MatrixTranspose view |
| CMatrixTemporaryTraits< MatrixTranspose< M > > | Math::MatrixTemporaryTraits specialization inheriting the temporary type of the wrapped matrix for a Math::MatrixTranspose view |
| CMatrixTemporaryTraits< const MatrixTranspose< M > > | Math::MatrixTemporaryTraits specialization inheriting the temporary type of the wrapped matrix for a const Math::MatrixTranspose view |
| CMatrixRow | Vector-expression proxy that views a single row of an underlying matrix |
| CMatrixColumn | Vector-expression proxy that views a single column of an underlying matrix |
| CMatrixRange | Matrix-expression proxy that views a contiguous rectangular subrange of an underlying matrix |
| CMatrixSlice | Matrix-expression proxy that views a strided rectangular slice of an underlying matrix |
| CVectorTemporaryTraits< MatrixRow< M > > | Vector-temporary trait specialization for Math::MatrixRow — inherits the temporary type from the wrapped matrix |
| CVectorTemporaryTraits< const MatrixRow< M > > | Vector-temporary trait specialization for const Math::MatrixRow — inherits the temporary type from the wrapped matrix |
| CMatrixTemporaryTraits< MatrixRow< M > > | Matrix-temporary trait specialization for Math::MatrixRow — inherits the temporary type from the wrapped matrix |
| CMatrixTemporaryTraits< const MatrixRow< M > > | Matrix-temporary trait specialization for const Math::MatrixRow — inherits the temporary type from the wrapped matrix |
| CVectorTemporaryTraits< MatrixColumn< M > > | Vector-temporary trait specialization for Math::MatrixColumn — inherits the temporary type from the wrapped matrix |
| CVectorTemporaryTraits< const MatrixColumn< M > > | Vector-temporary trait specialization for const Math::MatrixColumn — inherits the temporary type from the wrapped matrix |
| CMatrixTemporaryTraits< MatrixColumn< M > > | Matrix-temporary trait specialization for Math::MatrixColumn — inherits the temporary type from the wrapped matrix |
| CMatrixTemporaryTraits< const MatrixColumn< M > > | Matrix-temporary trait specialization for const Math::MatrixColumn — inherits the temporary type from the wrapped matrix |
| CVectorTemporaryTraits< MatrixRange< M > > | Vector-temporary trait specialization for Math::MatrixRange — inherits the temporary type from the wrapped matrix |
| CVectorTemporaryTraits< const MatrixRange< M > > | Vector-temporary trait specialization for const Math::MatrixRange — inherits the temporary type from the wrapped matrix |
| CMatrixTemporaryTraits< MatrixRange< M > > | Matrix-temporary trait specialization for Math::MatrixRange — inherits the temporary type from the wrapped matrix |
| CMatrixTemporaryTraits< const MatrixRange< M > > | Matrix-temporary trait specialization for const Math::MatrixRange — inherits the temporary type from the wrapped matrix |
| CVectorTemporaryTraits< MatrixSlice< M > > | Vector-temporary trait specialization for Math::MatrixSlice — inherits the temporary type from the wrapped matrix |
| CVectorTemporaryTraits< const MatrixSlice< M > > | Vector-temporary trait specialization for const Math::MatrixSlice — inherits the temporary type from the wrapped matrix |
| CMatrixTemporaryTraits< MatrixSlice< M > > | Matrix-temporary trait specialization for Math::MatrixSlice — inherits the temporary type from the wrapped matrix |
| CMatrixTemporaryTraits< const MatrixSlice< M > > | Matrix-temporary trait specialization for const Math::MatrixSlice — inherits the temporary type from the wrapped matrix |
| CMinimizerVariableArrayTraits | Traits template that adapts arbitrary variable-array types to the linear-algebra operations required by minimizer implementations (dot, norm2, axpy, clear, assign, multiply, sub) |
| CMinimizerVariableArrayTraits< VectorArray< V > > | Math::MinimizerVariableArrayTraits specialization for Math::VectorArray storage (a sequence of fixed-size vectors) |
| CMinimizerVariableArrayTraits< std::vector< V > > | Math::MinimizerVariableArrayTraits specialization for std::vector storage of fixed-size vectors |
| CMLRModel | Performs Multiple Linear Regression [WLIREG] on a set of data points \( (y_i, \vec{X}_i) \) |
| CQuaternionReference | Lightweight quaternion expression that proxies a reference to an underlying quaternion container |
| CQuaternion | General 4-component quaternion \( q = c_1 + c_2 i + c_3 j + c_4 k \) |
| CRealQuaternion | Pure-real quaternion \( q = c_1 + 0i + 0j + 0k \) that stores only the real component |
| CQuaternionTemporaryTraits< const QuaternionReference< Q > > | Math::QuaternionTemporaryTraits specialization inheriting the temporary type of the underlying quaternion for a const Math::QuaternionReference view |
| CQuaternionTemporaryTraits< QuaternionReference< Q > > | Math::QuaternionTemporaryTraits specialization inheriting the temporary type of the underlying quaternion for a Math::QuaternionReference view |
| CQuaternionVectorAdapter | View adapter that exposes a quaternion as a 4-element vector expression (indices map to the components C1, C2, C3, C4) |
| CCVector | Fixed-size vector of dimension N backed by a C-array (no dynamic allocation) |
| CVectorTemporaryTraits< QuaternionVectorAdapter< Q > > | Math::VectorTemporaryTraits specialization selecting Math::CVector as the temporary type for a Math::QuaternionVectorAdapter view |
| CVectorTemporaryTraits< const QuaternionVectorAdapter< Q > > | Math::VectorTemporaryTraits specialization selecting Math::CVector as the temporary type for a const Math::QuaternionVectorAdapter view |
| CQuaternionUnary1 | Expression-template node applying a unary functor F that returns a quaternion result to a quaternion expression E |
| CQuaternionUnary1Traits | Traits selecting the expression-template node and its result type for the Math::QuaternionUnary1 instantiation <E, F> |
| CQuaternionUnary2 | Expression-template node applying a per-component functor F to a quaternion expression E, where F exposes four separate apply methods (applyC1 / applyC2 / applyC3 / applyC4) operating on the whole source expression |
| CQuaternionUnary2Traits | Traits selecting the expression-template node and its result type for the Math::QuaternionUnary2 instantiation <E, F> |
| CQuaternionBinary1 | Expression-template node combining two quaternion expressions E1 and E2 component-wise via the binary functor F |
| CQuaternionBinary1Traits | Traits selecting the expression-template node and its result type for the Math::QuaternionBinary1 instantiation <E1, E2, F> |
| CQuaternionBinary2 | Expression-template node combining two quaternion expressions E1 and E2 via the per-component functor F (which exposes four separate applyC1 / applyC2 / applyC3 / applyC4 methods operating on the whole source expressions) |
| CQuaternionBinary2Traits | Traits selecting the expression-template node and its result type for the Math::QuaternionBinary2 instantiation <E1, E2, F> |
| CScalar1QuaternionBinary1 | Expression-template node combining a scalar E1 (lhs) and a quaternion expression E2 (rhs) component-wise via the binary functor F |
| CScalar1QuaternionBinary1Traits | Traits selecting the expression-template node and its result type for the Math::Scalar1QuaternionBinary1 instantiation <E1, E2, F> |
| CScalar1QuaternionBinary2 | Expression-template node combining a scalar E1 (lhs) and a quaternion expression E2 (rhs) via the per-component functor F (which exposes applyC1 / applyC2 / applyC3 / applyC4 methods) |
| CScalar1QuaternionBinary2Traits | Traits selecting the expression-template node and its result type for the Math::Scalar1QuaternionBinary2 instantiation <E1, E2, F> |
| CScalar2QuaternionBinary1 | Expression-template node combining a quaternion expression E1 (lhs) and a scalar E2 (rhs) component-wise via the binary functor F |
| CScalar2QuaternionBinary1Traits | Traits selecting the expression-template node and its result type for the Math::Scalar2QuaternionBinary1 instantiation <E1, E2, F> |
| CScalar2QuaternionBinary2 | Expression-template node combining a quaternion expression E1 (lhs) and a scalar E2 (rhs) via the per-component functor F (which exposes applyC1 / applyC2 / applyC3 / applyC4 methods) |
| CScalar2QuaternionBinary2Traits | Traits selecting the expression-template node and its result type for the Math::Scalar2QuaternionBinary2 instantiation <E1, E2, F> |
| CScalar3QuaternionTernary | Expression-template node combining two quaternion expressions E1 (lhs) and E2 (middle) with a scalar E3 (rhs) via the per-component ternary functor F |
| CScalar3QuaternionTernaryTraits | Traits selecting the expression-template node and its result type for the Math::Scalar3QuaternionTernary instantiation <E1, E2, E3, F> |
| CScalar13QuaternionTernary | Expression-template node combining a scalar E1 (lhs), a quaternion expression E2 (middle), and a scalar E3 (rhs) via the per-component ternary functor F |
| CScalar13QuaternionTernaryTraits | Traits selecting the expression-template node and its result type for the Math::Scalar13QuaternionTernary instantiation <E1, E2, E3, F> |
| CGridCoordinatesMatrixTransformTraits | Reusable transformation traits used by Math::RegularSpatialGrid when the coordinate transform is a 4x4 matrix |
| CGridCoordinatesTransformTraits | Primary traits template for grid-coordinate transformations of type T (left unspecialized; specialize for new transform types) |
| CGridCoordinatesTransformTraits< CMatrix< T, 4, 4 > > | Math::GridCoordinatesTransformTraits specialization for the fixed-size Math::CMatrix 4x4 transformation type |
| CGridCoordinatesTransformTraits< BoundedMatrix< T, 4, 4 > > | Math::GridCoordinatesTransformTraits specialization for the bounded Math::BoundedMatrix 4x4 transformation type |
| CRegularSpatialGrid | 3D grid data structure combining a Math::Grid data store with a coordinate-system transformation that maps grid-cell indices to 3D world positions |
| CSlice | Index slice ( \( start, stride, size \)) used for strided slicing of vector and matrix expressions |
| CSparseContainerElement | Proxy that exposes a single (key, value) entry of a sparse container as a writable reference |
| CTypeTraits< SparseContainerElement< C > > | Math::TypeTraits specialization that delegates to the underlying value type of a Math::SparseContainerElement |
| CScalarAbsImpl | Helper class template for retrieving the absolute value of scalar arithmetic types |
| CScalarAbsImpl< false > | Specialization of Math::ScalarAbsImpl for unsigned types |
| CScalarTraits | Common operations and type aliases for scalar arithmetic types |
| CTypeTraits | Primary traits template for scalar arithmetic value types |
| CComplexTraits | Common operations and type aliases for complex arithmetic types |
| CTypeTraits< std::complex< T > > | Math::TypeTraits specialization for complex arithmetic value types |
| CVectorTemporaryTraits | Selects a concrete temporary vector type compatible with the vector expression V |
| CMatrixTemporaryTraits | Selects a concrete temporary matrix type compatible with the matrix expression M |
| CQuaternionTemporaryTraits | Selects a concrete temporary quaternion type compatible with the quaternion expression Q |
| CGridTemporaryTraits | Selects a concrete temporary grid type compatible with the grid expression G |
| CIsScalar | Type trait identifying T as a scalar arithmetic type (true for built-in arithmetic types) |
| CIsScalar< std::complex< T > > | Math::IsScalar specialization that treats std::complex<T> as scalar when T is arithmetic |
| CVectorReference | Lightweight vector expression that proxies a reference to an underlying vector container |
| CInitListVector | Lightweight vector container that wraps a std::initializer_list for construction-style initialization |
| CSparseVector | Sparse vector that stores only non-default entries in an associative key-to-value container |
| CZeroVector | Constant vector expression whose elements are all zero |
| CUnitVector | Constant vector expression \( e_i \) that contains 1 at a single specified index and 0 elsewhere |
| CScalarVector | Constant vector expression in which every element equals the same scalar value |
| CVectorTemporaryTraits< const VectorReference< V > > | Math::VectorTemporaryTraits specialization inheriting the temporary type of the underlying vector for a const Math::VectorReference view |
| CVectorTemporaryTraits< VectorReference< V > > | Math::VectorTemporaryTraits specialization inheriting the temporary type of the underlying vector for a Math::VectorReference view |
| CHomogenousCoordsAdapter | Vector expression that exposes a vector V as its homogeneous-coordinate extension by appending an implicit 1 at the end |
| CVectorQuaternionAdapter | Quaternion expression that exposes a 4-element vector as a quaternion (component indices 0-3 map to C1-C4) |
| CQuaternionTemporaryTraits< VectorQuaternionAdapter< V > > | Math::QuaternionTemporaryTraits specialization selecting Math::Quaternion as the temporary type for a Math::VectorQuaternionAdapter view |
| CQuaternionTemporaryTraits< const VectorQuaternionAdapter< V > > | Math::QuaternionTemporaryTraits specialization selecting Math::Quaternion as the temporary type for a const Math::VectorQuaternionAdapter view |
| CVectorTemporaryTraits< HomogenousCoordsAdapter< V > > | Math::VectorTemporaryTraits specialization inheriting the temporary type of the wrapped vector for a Math::HomogenousCoordsAdapter view |
| CVectorTemporaryTraits< const HomogenousCoordsAdapter< V > > | Math::VectorTemporaryTraits specialization inheriting the temporary type of the wrapped vector for a const Math::HomogenousCoordsAdapter view |
| CVectorArray | Array data type for the ordered storage of vector objects |
| CVectorArrayAlignmentCalculator | Convenience wrapper around Math::KabschAlgorithm that operates directly on Math::VectorArray inputs |
| CVectorUnary | Expression-template node applying a unary functor F element-wise to a vector expression E |
| CVectorUnaryTraits | Traits selecting the expression-template node and its result type for the Math::VectorUnary instantiation <E, F> |
| CVectorBinary1 | Expression-template node combining two vector expressions E1 and E2 element-wise via the binary functor F |
| CVectorBinary1Traits | Traits selecting the expression-template node and its result type for the Math::VectorBinary1 instantiation <E1, E2, F> |
| CVectorBinary2 | Expression-template node combining two vector expressions E1 and E2 via a binary functor F invoked with both expressions plus the element index i |
| CVectorBinary2Traits | Traits selecting the expression-template node and its result type for the Math::VectorBinary2 instantiation <E1, E2, F> |
| CScalar1VectorBinary | Expression-template node combining a scalar E1 (lhs) and a vector expression E2 (rhs) element-wise via the binary functor F |
| CScalar1VectorBinaryTraits | Traits selecting the expression-template node and its result type for the Math::Scalar1VectorBinary instantiation <E1, E2, F> |
| CScalar2VectorBinary | Expression-template node combining a vector expression E1 (lhs) and a scalar E2 (rhs) element-wise via the binary functor F |
| CScalar2VectorBinaryTraits | Traits selecting the expression-template node and its result type for the Math::Scalar2VectorBinary instantiation <E1, E2, F> |
| CQuaternionVectorBinary | Expression-template node combining a quaternion expression E1 and a vector expression E2 into a vector expression via the per-element functor F (used e.g. for quaternion-vector rotation) |
| CQuaternionVectorBinaryTraits | Traits selecting the expression-template node and its result type for the Math::QuaternionVectorBinary instantiation <E1, E2, F> |
| CVectorElementAccessor | Access functor used by Math::VectorIteratorTraits to read mutable vector elements via Util::IndexedElementIterator |
| CVectorElementAccessor< const E > | Specialization of Math::VectorElementAccessor for const vector references (read-only iteration) |
| CVectorIteratorTraits | Traits selecting the element accessor and Util::IndexedElementIterator specialization for mutable iteration over E |
| CVectorIteratorTraits< const E > | Specialization of Math::VectorIteratorTraits for read-only iteration over E |
| CVectorRange | Vector-expression proxy that views a contiguous half-open subrange of an underlying vector |
| CVectorSlice | Vector-expression proxy that views a strided slice of an underlying vector |
| CVectorTemporaryTraits< VectorRange< V > > | Math::VectorTemporaryTraits specialization inheriting the temporary type of the underlying vector for a Math::VectorRange view |
| CVectorTemporaryTraits< const VectorRange< V > > | Math::VectorTemporaryTraits specialization inheriting the temporary type of the underlying vector for a const Math::VectorRange view |
| CVectorTemporaryTraits< VectorSlice< V > > | Math::VectorTemporaryTraits specialization inheriting the temporary type of the underlying vector for a Math::VectorSlice view |
| CVectorTemporaryTraits< const VectorSlice< V > > | Math::VectorTemporaryTraits specialization inheriting the temporary type of the underlying vector for a const Math::VectorSlice view |
| ►NMolProp | Contains classes and functions related to the calculation/preciction of physicochemical molecular properties |
| NAtomProperty | Provides keys for built-in Chem::Atom properties |
| NAtomPropertyDefault | Provides default values for MolProp-specific Chem::Atom properties |
| NBondProperty | Provides keys for built-in Chem::Bond properties |
| NCoordinationGeometry | Provides constants used to specify the spatial geometry of atom arrangements around a common central atom |
| NHBondAcceptorAtomType | Provides constants used to specify the structural class of H-bond acceptor atoms |
| NHBondDonorAtomType | Provides constants used to specify the structural class of H-bond donor atoms |
| NMolecularGraphProperty | Provides keys for built-in Chem::MolecularGraph properties |
| CAtomHydrophobicityCalculator | Implementation of Greene's algorithm [CATA] for the calculation of atom hydrophobicities |
| CElementHistogram | Data type for the storage of element histograms of chemical compounds |
| CFunctionalGroupList | Implementation of Ertl's algorithm [FGPE] for the identification of functional groups in organic molecules |
| CHBondAcceptorAtomTyper | Implements the perception of H-bond acceptor atom types (see namespace MolProp::HBondAcceptorAtomType) |
| CHBondDonorAtomTyper | Implements the perception of H-bond donor atom types (see namespace MolProp::HBondDonorAtomType) |
| CLogSCalculator | Calculation of the aqueous solubility ( \( \log S \)) of molecular graphs using the atom-contribution method of Hou, Xia, Zhang and Xu |
| CMassComposition | Data type for the storage of mass percent compositions of chemical compounds |
| CMHMOPiChargeCalculator | Calculator that uses a Modified Hückel Molecular Orbital (MHMO) treatment to compute π-electron densities, π-charges, π-bond orders and the total π-electron energy of a molecular graph |
| CPEOESigmaChargeCalculator | Calculator that uses the Partial Equalization of Orbital Electronegativities (PEOE) method of Gasteiger and Marsili to compute σ atomic charges and electronegativities of a molecular graph |
| CTPSACalculator | Calculation of the topological polar surface area (TPSA) of molecular graphs based on fragment contributions |
| CXLogPCalculator | Calculation of the octanol/water partition coefficient ( \( \log P \)) of molecular graphs using the atom-additive method of Wang, Gao and Lai |
| ►NPharm | Contains classes and functions related to pharmacophore perception and pharmacophore applications |
| NControlParameter | Provides keys for built-in control-parameters |
| NControlParameterDefault | Provides default values for built-in control-parameters |
| NDataFormat | Provides preinitialized Base::DataFormat objects for all supported data formats |
| NFeatureContainerProperty | Provides keys for built-in Pharm::FeatureContainer properties |
| NFeatureContainerPropertyDefault | Provides default values for built-in Pharm::FeatureContainer properties |
| NFeatureGeometry | Provides constants for the specification of the generic geometry of a pharmacophore feature |
| NFeatureProperty | Provides keys for built-in Pharm::Feature properties |
| NFeaturePropertyDefault | Provides default values for built-in Pharm::Feature properties |
| NFeatureType | Provides constants for the specification of the generic type of a pharmacophore feature |
| CAromaticFeatureGenerator | Pharm::FeatureGenerator implementation that perceives aromatic ring features by enumerating the aromatic SSSR subset of the input molecular graph |
| CBasicFeature | Pharm::Feature implementation owned by a Pharm::BasicPharmacophore parent |
| CBasicPharmacophore | Concrete Pharm::Pharmacophore implementation that owns its features as Pharm::BasicFeature instances managed through an internal object pool |
| CCationPiInteractionConstraint | Constraint functor that tests whether an aromatic/cationic feature pair satisfies the geometric criteria for a cation-π interaction (center distance plus cation-to-ring-plane-normal angle) |
| CCationPiInteractionScore | Pharm::FeatureInteractionScore implementation that scores an aromatic/cationic feature pair by combining per-component scores for cation-to-ring-center distance and cation-displacement to ring-plane-normal angle |
| CCDFFeatureContainerWriter | Writer for feature container data in the native I/O format of the CDPL |
| CCDFPharmacophoreReader | Reader for pharmacophore data in the native I/O format of the CDPL |
| CDefaultInteractionAnalyzer | Interaction analyzer pre-configured with the built-in default set of interaction constraints (hydrogen-bonding, ionic, aromatic-aromatic, cation-π, hydrophobic, halogen-bonding) |
| CDefaultPharmacophoreGenerator | Pharmacophore generator pre-configured with the built-in default set of feature generators |
| CFeature | Abstract base class representing a single pharmacophore feature within a parent Pharm::Pharmacophore |
| CFeatureContainer | Abstract base class for containers holding a sequence of Pharm::Feature objects with associated properties (e.g. a pharmacophore or feature set) |
| CFeatureDistanceConstraint | Constraint functor that accepts a pair of features whose 3D-position distance lies within a configured [min, max] interval |
| CFeatureDistanceScore | Pharm::FeatureInteractionScore implementation that scores a feature pair based on whether their 3D-position distance falls within a configured [min, max] interval |
| CFeatureGenerator | Abstract base class for generators that perceive one type of pharmacophore feature (e.g. an aromatic ring or H-bond donor) and append the perceived features to a Pharm::Pharmacophore |
| CFeatureGeometryMatchFunctor | Match functor that quantifies the goodness of the spatial orientation match between two pharmacophore features, applying type-specific tolerances for H-bond donor/acceptor, halogen-bond donor/acceptor and aromatic features |
| CFeatureInteractionScore | Abstract base class for scoring functors that quantify the strength of a directional pharmacophore-feature interaction (e.g. H-bond, ionic, π-π stacking) between two Pharm::Feature instances |
| CFeatureInteractionScoreCombiner | Composite Pharm::FeatureInteractionScore that combines two underlying interaction scores via a user-supplied binary combination function (default: maximum) |
| CFeatureMapping | Data type for the storage and lookup of arbitrary feature to feature mappings |
| CFeaturePairDistanceMatchFunctor | Match functor that tests whether two feature pairs share a compatible inter-feature distance, with the compatibility relation switched between query-mode (asymmetric) and non-query-mode (symmetric) |
| CFeaturePositionMatchFunctor | Match functor that quantifies the goodness of the 3D-position match between two pharmacophore features by comparing their separation against the configured per-feature tolerance |
| CFeatureSet | Concrete Pharm::FeatureContainer implementation that stores references to existing Pharm::Feature instances |
| CFeatureTypeHistogram | Data type for the storage of feature type histograms of pharmacophores |
| CFeatureTypeMatchFunctor | Match functor that accepts a feature pair when both features share the same Pharm::FeatureType identifier |
| CFileScreeningHitCollector | Hit-callback functor for use with Pharm::ScreeningProcessor that writes each accepted hit molecule (optionally aligned and annotated with score/database properties) to a Base::DataWriter sink |
| CHBondAcceptorFeatureGenerator | Pharm::FeatureGenerator implementation that perceives H-bond acceptor features by matching a built-in set of SMARTS patterns |
| CHBondDonorFeatureGenerator | Pharm::FeatureGenerator implementation that perceives H-bond donor features by matching a built-in set of SMARTS patterns |
| CHBondingInteractionConstraint | Constraint functor that tests whether a Pharm::Feature pair satisfies geometric H-bond criteria (H-bond length plus acceptor-H-donor and H-bond direction to acceptor vector angles) |
| CHBondingInteractionScore | Pharm::FeatureInteractionScore implementation that scores a donor/acceptor feature pair by combining per-component scores for H-bond length, acceptor-H-donor angle and H-bond direction to acceptor vector angle |
| CHydrophobicAtomFeatureGenerator | Pharm::FeatureGenerator implementation that emits one hydrophobic feature per atom whose individual hydrophobicity exceeds a configurable threshold |
| CHydrophobicFeatureGenerator | Pharm::FeatureGenerator implementation that perceives hydrophobic features by grouping atoms into rings, chains and small fragment groups whose total atom hydrophobicity exceeds the per-class threshold |
| CHydrophobicInteractionConstraint | Pharm::FeatureDistanceConstraint specialization that accepts a hydrophobic feature pair when its center distance lies within the typical hydrophobic interaction range |
| CHydrophobicInteractionScore | Pharm::FeatureDistanceScore specialization that scores a hydrophobic feature pair based on its center distance in the typical hydrophobic interaction range |
| CInteractionAnalyzer | Analyzer that detects pairwise interactions between features of two Pharm::FeatureContainer instances based on user-registered per-feature-type-pair interaction constraint functions |
| CInteractionConstraintConnector | Composite feature-interaction constraint that combines two underlying constraint functions via a logical conjunction or disjunction |
| CInteractionPharmacophoreGenerator | Driver that generates an interaction pharmacophore by perceiving a core pharmacophore on a ligand, an environment pharmacophore on the surrounding pocket residues, analyzing the inter-feature interactions and emitting features representing the detected interactions (optionally with exclusion volumes) |
| CIonicInteractionConstraint | Pharm::FeatureDistanceConstraint specialization that accepts an oppositely-charged ionic feature pair when its center distance lies within the typical salt-bridge range |
| CIonicInteractionScore | Pharm::FeatureDistanceScore specialization that scores an oppositely-charged ionic feature pair based on its center distance in the typical salt-bridge range |
| CNegIonizableFeatureGenerator | Pharm::FeatureGenerator implementation that perceives negative ionizable group features by matching a built-in set of SMARTS patterns |
| COrthogonalPiPiInteractionConstraint | Constraint functor that tests whether an aromatic feature pair satisfies the geometric criteria for an orthogonal (T-shaped) π-π interaction (horizontal/vertical center separations plus ring-normal angle) |
| COrthogonalPiPiInteractionScore | Pharm::FeatureInteractionScore implementation that scores an aromatic feature pair for an orthogonal (T-shaped) π-π interaction by combining per-component scores for horizontal/vertical center separations and ring-plane-normal angle |
| CParallelPiPiInteractionConstraint | Constraint functor that tests whether an aromatic feature pair satisfies the geometric criteria for a parallel (sandwich/displaced) π-π interaction (vertical/horizontal center separations plus ring-normal angle) |
| CParallelPiPiInteractionScore | Pharm::FeatureInteractionScore implementation that scores an aromatic feature pair for a parallel (sandwich/displaced) π-π interaction by combining per-component scores for vertical/horizontal center separations and ring-plane-normal angle |
| CPatternBasedFeatureGenerator | Pharm::FeatureGenerator implementation that perceives pharmacophore features by substructure pattern matching, with separate include and exclude pattern lists |
| CPharmacophore | Abstract base class for mutable containers of Pharm::Feature instances representing a pharmacophore model |
| CPharmacophoreAlignment | Pharmacophore alignment driver — a Chem::SpatialEntityAlignment specialization for Pharm::Feature objects that aligns two feature sets according to their type, geometry and 3D positions |
| CPharmacophoreFitScore | Scoring functor that quantifies how well a candidate set of features fits a reference pharmacophore, combining feature-match count, per-feature position deviation and geometry-match contributions |
| CPharmacophoreFitScreeningScore | Pharm::PharmacophoreFitScore specialization that scores a Pharm::ScreeningProcessor::SearchHit by applying the underlying pharmacophore-fit score to its query and hit features |
| CPharmacophoreGenerator | Base class for pharmacophore generators that orchestrate per-feature-type Pharm::FeatureGenerator instances to produce the features of a Pharm::Pharmacophore from a Chem::MolecularGraph |
| CPMLFeatureContainerWriter | Writer for feature container data in the native I/O format of LigandScout |
| CPMLPharmacophoreReader | Reader for pharmacophore data in the native I/O format of LigandScout |
| CPosIonizableFeatureGenerator | Pharm::FeatureGenerator implementation that perceives positive ionizable group features by matching a built-in set of SMARTS patterns |
| CPSDMolecularGraphOutputHandler | Handler for the output of molecular graph data in the CDPL PSD-format |
| CPSDMolecularGraphWriter | Writer for molecular graph data in the CDPL PSD-format |
| CPSDMoleculeInputHandler | Handler for the input of molecule data in the CDPL PSD-format |
| CPSDMoleculeReader | Reader for molecule data in the CDPL PSD-format |
| CPSDPharmacophoreInputHandler | Handler for the input of pharmacophore data in the CDPL PSD-format |
| CPSDPharmacophoreReader | Reader for pharmacophore data in the CDPL PSD-format |
| CPSDScreeningDBAccessor | Pharm::ScreeningDBAccessor implementation that reads pharmacophore screening databases stored in the built-in optimized PSD format |
| CPSDScreeningDBCreator | Pharm::ScreeningDBCreator implementation that builds optimized pharmacophore screening databases in the built-in PSD format |
| CScreeningDBAccessor | Abstract base class for accessors that read the data stored in pharmacophore screening databases |
| CScreeningDBCreator | Abstract base class for creators that build optimized pharmacophore screening databases |
| ►CScreeningProcessor | High-level driver for pharmacophore-based screening of a Pharm::ScreeningDBAccessor-backed database against a query feature container, reporting alignment hits via a user-supplied callback |
| CSearchHit | Data structure representing a single alignment hit produced by the screening processor, bundling the source pharmacophore/molecule, the alignment transformation and the source-database indices |
| CSpatialFeatureMapping | Pharm::FeatureMapping specialization that perceives a reference-to-aligned feature mapping based on type, position and geometry compatibility under a given transformation, caching per-pair position and geometry match scores for later retrieval |
| CXBondAcceptorFeatureGenerator | Pharm::FeatureGenerator implementation that perceives halogen-bond acceptor features by matching a built-in set of SMARTS patterns |
| CXBondDonorFeatureGenerator | Pharm::FeatureGenerator implementation that perceives halogen-bond donor features by matching a built-in set of SMARTS patterns |
| CXBondingInteractionConstraint | Constraint functor that tests whether a halogen-bond donor/acceptor feature pair satisfies the geometric criteria for a halogen bond (halogen-acceptor distance plus the two characteristic angles) |
| CXBondingInteractionScore | Pharm::FeatureInteractionScore implementation that scores a halogen-bond donor/acceptor feature pair by combining per-component scores for halogen-acceptor distance, acceptor-halogen-bound-atom angle and acceptor direction angle |
| ►NShape | Contains classes and functions related to molecular shape representation and processing |
| NAlignmentResultSelectionMode | Provides constants for selecting which alignment results are kept by alignment routines |
| NSymmetryClass | Provides constants for the rotational symmetry class of a Gaussian shape |
| CAlignmentResult | Result of a Gaussian-shape alignment between a reference and an aligned shape |
| CExactGaussianShapeOverlapFunction | Shape::GaussianShapeOverlapFunction implementation that evaluates the overlap analytically using the full Gaussian-product expansion (no approximations) |
| CFastGaussianShapeAlignment | High-level driver for the fast alignment of Gaussian shapes against a set of reference shapes |
| CFastGaussianShapeOverlapFunction | Shape::GaussianShapeOverlapFunction implementation that uses two approximation techniques to trade some accuracy for a substantial speedup compared to Shape::ExactGaussianShapeOverlapFunction |
| ►CGaussianShape | Data type for the descripton of arbitrary shapes composed of spheres approximated by gaussian functions |
| CElement | Data structure representing a single sphere of the Gaussian shape, characterized by a position, radius, hardness and color |
| CGaussianShapeAlignment | High-level driver for the alignment of Gaussian shapes against a set of reference shapes |
| CGaussianShapeAlignmentStartGenerator | Abstract base class for generators of starting transformations used to seed Gaussian-shape overlap optimization |
| CGaussianShapeFunction | Function representation of a Gaussian shape, used to evaluate the shape's density, volume, surface area and related quantities at arbitrary 3D positions |
| ►CGaussianShapeFunctionAlignment | Driver for the alignment of one Shape::GaussianShapeFunction (the aligned shape) against a fixed reference Shape::GaussianShapeFunction |
| CResult | A single alignment result: rigid-body transformation plus shape and color overlap values |
| CGaussianShapeGenerator | Generates Shape::GaussianShape instances from molecular graphs |
| CGaussianShapeOverlapFunction | Abstract base class for functions evaluating the overlap between two Gaussian shape functions |
| CGaussianShapeSet | Data structure storing a set of (shared) Gaussian shapes |
| CPrincipalAxesAlignmentStartGenerator | Generator that produces alignment starting transformations by aligning the principal axes of the aligned shape to those of the reference shape |
| CTotalOverlapTanimotoScore | Functor wrapping Shape::calcTotalOverlapTanimotoScore() |
| CShapeTanimotoScore | Functor wrapping Shape::calcShapeTanimotoScore() |
| CColorTanimotoScore | Functor wrapping Shape::calcColorTanimotoScore() |
| CTanimotoComboScore | Functor wrapping Shape::calcTanimotoComboScore() |
| CTotalOverlapTverskyScore | Functor wrapping Shape::calcTotalOverlapTverskyScore() |
| CShapeTverskyScore | Functor wrapping Shape::calcShapeTverskyScore() |
| CColorTverskyScore | Functor wrapping Shape::calcColorTverskyScore() |
| CTverskyComboScore | Functor wrapping Shape::calcTverskyComboScore() |
| CReferenceTotalOverlapTverskyScore | Functor wrapping Shape::calcReferenceTotalOverlapTverskyScore() |
| CReferenceShapeTverskyScore | Functor wrapping Shape::calcReferenceShapeTverskyScore() |
| CReferenceColorTverskyScore | Functor wrapping Shape::calcReferenceColorTverskyScore() |
| CReferenceTverskyComboScore | Functor wrapping Shape::calcReferenceTverskyComboScore() |
| CAlignedTotalOverlapTverskyScore | Functor wrapping Shape::calcAlignedTotalOverlapTverskyScore() |
| CAlignedShapeTverskyScore | Functor wrapping Shape::calcAlignedShapeTverskyScore() |
| CAlignedColorTverskyScore | Functor wrapping Shape::calcAlignedColorTverskyScore() |
| CAlignedTverskyComboScore | Functor wrapping Shape::calcAlignedTverskyComboScore() |
| CScreeningProcessor | High-level driver for shape-based virtual screening of molecular databases |
| CScreeningSettings | Bundle of configuration parameters for Shape::ScreeningProcessor |
| ►NUtil | Contains general purpose algorithms, containers, functors and other classes |
| CArray | Dynamic array class providing amortized constant time access to arbitrary elements |
| CBronKerboschAlgorithm | Implementation of the Bron-Kerbosch clique-detection algorithm [BKA] |
| CCompoundDataReader | Composite Base::DataReader that aggregates several underlying readers and presents their records as one contiguous record stream |
| CCompressedDataReader | Adapter that wraps a stream-based reader with a decompression stream to read records from a compressed data stream |
| CCompressedDataWriter | Convenience wrapper that combines a Util::CompressionOStream of type CompStream with a stream-based writer WriterImpl so that data written via this Base::DataWriter is automatically compressed on the fly |
| CCompressionAlgoTraits | Traits-style template selecting the boost::iostreams compression/decompression filters that implement a given Util::CompressionAlgo. Specialized for each supported algorithm |
| CCompressionAlgoTraits< GZIP > | Util::CompressionAlgoTraits specialization for the gzip algorithm |
| CCompressionAlgoTraits< BZIP2 > | Util::CompressionAlgoTraits specialization for the bzip2 algorithm |
| CCompressionStreamBase | Base class for stream wrappers that buffer (de)compressed data through a temporary file |
| CDecompressionIStream | Input stream wrapper that transparently decompresses data read from an underlying compressed source stream |
| CCompressionOStream | Output stream wrapper that transparently compresses data and writes it to an underlying sink stream when the wrapper is closed or destroyed |
| CCompressedIOStream | Bidirectional stream wrapper that decompresses data read from stream into a temporary buffer and re-compresses the (possibly modified) buffer back to stream on close |
| CDefaultDataInputHandler | Default Base::DataInputHandler implementation that exposes a fixed Base::DataFormat and instantiates readers of the supplied stream-based ReaderImpl type (file-based readers are produced by wrapping it in Util::FileDataReader) |
| CDefaultDataOutputHandler | Default Base::DataOutputHandler implementation that exposes a fixed Base::DataFormat and instantiates writers of the supplied stream-based WriterImpl type (file-based writers are produced by wrapping it in Util::FileDataWriter) |
| CDereferencer | Unary functor for the dereferenciation of pointers without null pointer checking |
| CNullCheckDereferencer | Unary functor for the dereferenciation of pointers with null pointer checking |
| ►CDGCoordinatesGeneratorBase | Serves as foundation for subclasses that perform coordinates generation based on distance-geometry |
| CDistanceConstraint | A constraint that pins the distance between two points to the interval [lb, ub] |
| CDGCoordinatesGenerator | Generic distance-geometry implementation for the generation of coordinates that fulfill user-provided distance constraints |
| ►CDGCoordinatesGenerator< 3, T > | Specialized distance-geometry implementation for the generation of 3D coordinates that fulfill user-provided distance and volume constraints |
| CVolumeConstraint | A constraint that pins the signed tetrahedral volume spanned by four points to the interval [lb, ub] |
| CFileDataReader | Convenience wrapper that adapts a stream-based reader implementation ReaderImpl into a file-based Base::DataReader by opening an std::ifstream and forwarding all read operations to the wrapped reader |
| CFileDataWriter | Convenience wrapper that adapts a stream-based writer implementation WriterImpl into a file-based Base::DataWriter by opening an std::fstream and forwarding all write operations to the wrapped writer |
| CFileRemover | RAII helper that deletes a file when the FileRemover instance goes out of scope (unless released beforehand). Useful for guaranteeing the cleanup of temporary files |
| CIndexedElementIterator | STL compatible random access iterator for container elements accessible by index |
| CIndirectArray | Dynamic array class for the storage of object pointers with an indirected query interface |
| CMapDefaultValue | Helper supplying the default value returned by Util::Map when a queried key is absent |
| CMapDefaultValue< ValueType, false > | Util::MapDefaultValue specialization for the case in which default values are not allowed |
| CMap | A unique sorted associative container that maps keys to values |
| CMultiFormatDataReader | Reader that auto-dispatches to a format-specific reader registered with Base::DataIOManager |
| CMultiFormatDataWriter | Base::DataWriter front-end that automatically selects a concrete handler from Base::DataIOManager based on the output file name or an explicitly supplied format identifier |
| CMultiMapDefaultValue | Helper supplying the default value returned by Util::MultiMap when a queried key is absent |
| CMultiMapDefaultValue< ValueType, false > | Util::MultiMapDefaultValue specialization for the case in which default values are not allowed |
| CMultiMap | A multiple sorted associative container that maps keys to values |
| ►CObjectPool | Data structure that caches instances of type T up to a user specified amount |
| CDefaultConstructor | Default object factory which creates new instances of ObjectType via new |
| CDefaultDestructor | Default object destructor which destroys instances of ObjectType via delete |
| ►CObjectStack | Reusable object pool with stack-like borrow/return semantics |
| CDefaultConstructor | Default object factory which creates new instances of ObjectType via new |
| CPropertyValue | Unary functor that retrieves the value of a given property from the Base::PropertyContainer instance provided as argument |
| CPropertyValueProduct | Binary functor that calculates the product of two property values retrieved from a pair of Base::PropertyContainer instances passed as argument |
| CStreamDataReader | Helper class that implements Base::DataReader for std::istream based data readers |
| ►NVis | Contains classes and functions related to data visualization |
| NAlignment | Provides flags that are used to specify the 2D alignment of graphical objects within a bounded rectangular area |
| NArrowStyle | Provides constants for the specification of reaction arrow styles in 2D depictions of chemical reactions |
| NAtomProperty | Provides keys for built-in Chem::Atom properties |
| NAtomPropertyDefault | Provides default values for built-in Chem::Atom properties |
| NBondProperty | Provides keys for built-in Chem::Bond properties |
| NBondPropertyDefault | Provides default values for built-in Chem::Bond properties |
| NControlParameter | Provides keys for built-in control-parameters |
| NControlParameterDefault | Provides default values for built-in control-parameters |
| NDataFormat | Provides preinitialized Base::DataFormat objects for all supported image output formats |
| NLayoutDirection | Provides constants that are used to specify the main direction of object layouts |
| NLayoutStyle | Provides constants that are used to specify the layout of a set of graphical objects |
| NMolecularGraphProperty | Provides keys for built-in Chem::MolecularGraph properties |
| NMolecularGraphPropertyDefault | Provides default values for built-in Chem::MolecularGraph properties |
| NObject3DProperty | Provides keys for built-in Vis::Object3D properties |
| NObject3DPropertyDefault | Provides default values for built-in Vis::Object3D properties |
| NReactionProperty | Provides keys for built-in Chem::Reaction properties |
| NReactionPropertyDefault | Provides default values for built-in Chem::Reaction properties |
| NSizeAdjustment | Provides constants that are used to specify the size adjustment policy for graphical objects within a bounded rectangular area |
| CBrush | Specifies the fill pattern and fill color of shapes |
| CCairoFontMetrics | Implements the FontMetrics interface for the Cairo rendering backend |
| CCairoPointerTraits | Traits class providing the reference-count management functions for a particular Cairo data type T |
| CCairoPointerTraits< cairo_t > | Specialization of CairoPointerTraits for the object type cairo_t |
| CCairoPointerTraits< cairo_surface_t > | Specialization of CairoPointerTraits for the object type cairo_surface_t |
| CCairoPointerTraits< cairo_pattern_t > | Specialization of CairoPointerTraits for the object type cairo_pattern_t |
| CCairoPointer | A smart pointer managing the lifetime of allocated Cairo data structures |
| CCairoRenderer2D | Implements the Renderer2D interface on top of the Cairo 2D Graphics Library |
| CClipPathPrimitive2D | 2D graphics primitive representing a clipping region in 2D space |
| CColor | Specifies a color in terms of its red, green and blue components and an alpha-channel for transparency |
| CColorTable | Container for the storage and lookup of Vis::Color objects that are associated with a numeric identifier |
| CDefaultAtomColorTable | Provides default colors for the element dependent coloring of atom labels in 2D depictions of chemical structures |
| CDefaultFeatureColorTable | Provides default colors for the type dependent coloring of chemical features in 3D visualizations of pharmacophores |
| CEllipsePrimitive2D | 2D graphics primitive representing an ellipse |
| CFeatureContainerObject3DFactory | Class implementing the creation of Vis::Object3D instances providing a 3D representation of Pharm::FeatureContainer data objects for visualization purposes |
| CFeatureContainerObject3DWriter | Generic writer that converts Pharm::FeatureContainer instances into a 3D scene representation (via Vis::FeatureContainerObject3DFactory) and forwards them to a WriterImpl Object3D writer |
| CFont | Specifies a font for drawing text |
| CFontMetrics | Interface providing methods for querying information about the metrics of a font |
| CGraphicsPrimitive2D | The abstract base class of all 2D graphics primitives |
| CIcosahedronMesh3D | A pre-defined triangle mesh providing the vertices and faces of a regular icosahedron |
| CImageWriter | Abstract base class for writers that render Chem::MolecularGraph or Chem::Reaction instances into a raster/vector image via an internal Cairo surface |
| CLine2D | Specifies a line segment in 2D space |
| CLinePrimitive2D | 2D graphics primitive representing a single line |
| CLineSegmentListPrimitive2D | 2D graphics primitive representing a list of disjoint line segments |
| CMaterial | Defines material properties of Vis::Object3D instances |
| CObject3D | Hierarchical 3D scene object that owns a list of nested sub-objects and inherits its property bag from Base::PropertyContainer |
| CObject3DFactory | The abstract base of classes implementing the creation of Vis::Object3D instances for the 3D visualization of data objects |
| CPath2D | Provides a container for painting operations, enabling arbitrary graphical shapes to be constructed and reused |
| CPath2DConverter | Provides an interface for classes that implement the conversion of Vis::Path2D objects into rendering backend specific path descriptions or drawing operations |
| CPathPrimitive2D | 2D graphics primitive representing an arbitrary path in 2D space |
| CPDFMolecularGraphWriter | Creates 2D structure diagrams of molecular graphs in the Portable Document Format (PDF) [WPDF] |
| CPDFReactionWriter | Creates 2D depictions of chemical reactions in the Portable Document Format (PDF) [WPDF] |
| CPen | Specifies how to draw lines and outlines of shapes |
| CPLYObject3DWriter | Outputs 3D visualization data represented by Vis::Object3D instances in the Polygon File Format [PLYFMT] |
| CPNGMolecularGraphWriter | Creates 2D structure diagrams of molecular graphs in the Portable Network Graphics (PNG) [WPNG] format |
| CPNGReactionWriter | Creates 2D depictions of chemical reactions in the Portable Network Graphics (PNG) [WPNG] format |
| CPointArray2D | Stores a set of points in 2D space |
| CPointListPrimitive2D | 2D graphics primitive representing a list of points |
| CPolygonPrimitive2D | 2D graphics primitive representing a polygon |
| CPolylinePrimitive2D | 2D graphics primitive representing a set of connected line segments |
| CPSMolecularGraphWriter | Creates 2D structure diagrams of molecular graphs in the PostScript (PS) [WPS] format |
| CPSReactionWriter | Creates 2D depictions of chemical reactions in the PostScript (PS) [WPS] format |
| CQtFontMetrics | Implements the FontMetrics interface for the Qt rendering backend |
| CQtObjectFactory | Provides methods for the creation of QFont, QColor, QPen and QBrush objects from Font, Color, Pen and Brush instances |
| CQtRenderer2D | Implements the Renderer2D interface on top of the Qt Toolkit |
| CR3DObject3DWriter | Outputs 3D visualization data represented by Vis::Object3D instances in the Raster3D [R3DFMT] format |
| CReactionView2D | Implements the 2D visualization of chemical reactions |
| CRectangle2D | Specifies an axis aligned rectangular area in 2D space |
| CRenderer2D | Interface providing methods for low level 2D drawing operations |
| CRightFrustumMesh3D | A pre-defined triangle mesh providing the vertices and faces of a right frustum specified by the contructor arguments |
| CShape3D | The abstract base of all classes describing the geometric shape of 3D objects |
| CShape3DVisitor | The base of all Vis::Shape3D visitor implementations [VPTN] |
| CSizeSpecification | Specifies the value and type of a size attribute and defines how the value may change during processing steps |
| CSTLObject3DWriter | Outputs 3D visualization data represented by Vis::Object3D instances in the STL [STLFMT] format |
| ►CStructureGridView2D | Implements the 2D visualization of multiple chemical structures arranged in a grid |
| CCell | Data structure storing the contents of a grid cell |
| CStructureView2D | Implements the 2D visualization of chemical structures |
| CSVGMolecularGraphWriter | Creates 2D structure diagrams of molecular graphs in the Scalable Vector Graphics (SVG) [WSVG] format |
| CSVGReactionWriter | Creates 2D depictions of chemical reactions in the Scalable Vector Graphics (SVG) [WSVG] format |
| CTextBlockPrimitive2D | 2D graphics primitive representing a block of styled text |
| CTextLabelPrimitive2D | 2D graphics primitive representing a text label |
| CTorusMesh3D | Pre-defined triangle mesh providing the vertices and faces of a torus specified by the contructor arguments |
| CTriangleMesh3D | Data structure for describing the geometric shape of 3D objects by means of a triangle mesh |
| CView2D | The abstract base of classes implementing the 2D visualization of data objects |
| CVRMLObject3DWriter | Outputs 3D visualization data represented by Vis::Object3D instances in the VRML [VRML97] format |
1.9.1