| Nbertini | |
| Nblackbox | |
| Nconfig | |
| CConfigs | Bundles of configuration types, as TypeLists, grouped by solve stage |
| CDefaults | |
| CAlgoBuilder | A de-serializer, whose responsibility it is to construct runnable objects based on input files |
| CZeroDimRT | Runtime options selecting which ZeroDim algorithm to instantiate |
| CAnyAlgorithm | Type-erased base for all nag algorithms, exposing a single Run() entry point |
| Ndetail | |
| CConfigured | This templated struct allows one to provide a variable typelist of config structs (or anything else for that matter), and provides a way to get and set these configs by looking up the structs by type |
| CConfigured< TypeList< Ts... > > | Configured specialization accepting the config types packaged in a TypeList |
| CIndexByType | |
| CIndexByType< T, T, RemainingT... > | |
| CIndexByType< T1, T2, RemainingT... > | |
| CAreValidArguments | |
| CAreValidArguments< true > | |
| CDefaultConstruct | Holds a default-constructed value of T, used to fill arguments not present when unpermuting |
| CIsTemplateParameter | Base template, which says 'no', it's not in the pack |
| CIsTemplateParameter< F, S, T... > | Specialized template, which says 'yes', if it is in the pack, by recursively expanding the pack |
| CIsTemplateParameter< T, TypeList< Ts... > > | IsTemplateParameter specialization accepting the candidate types packaged in a TypeList |
| CDigest256 | A 256-bit content digest – the output of Sha256, used as a persistent identity key |
| CSingleton | A virtual singleton base class which can be used in a heirarchy to require a class to be singleton |
| CTypeList | A basic typelist, in the style of Modern C++ Design, but using variadic templates |
| CListCat | Concatenate two typelists |
| CListCat< TypeList< Ts... >, TypeList< Rs... > > | A specialization of ListCat for joining two lists |
| CListCat< TypeList< Ps... >, TypeList< Qs... >, TypeList< Rs... > > | A specialization of ListCat for joining 3+ lists |
| CSharedPointerPolicy | Pool pointer policy that holds objects via std::shared_ptr |
| CPool | A process-wide cache of objects, held by pointer, that hands out shared references |
| Npolicy | |
| CDefaultConstruct | A policy for what to do when a visited type is encoutered by a visitor it doesn't know |
| CRaiseExceptionWithTypeNamesInMessage | A policy that throws (with the offending type names) when an unknown visitor is encountered |
| Nendgame | |
| CAMPEndgame | Specifies some necessaries for AMP style endgame implementations, which differ from the fixed precision ones |
| CEGPrecSelector< tracking::AMPTracker > | Selects the AMP endgame precision policy for the adaptive-precision tracker |
| CEndgameBase | Base endgame class for all endgames offered in Bertini2 |
| CCauchyEndgame | Class used to finish tracking paths during Homotopy Continuation |
| CPowerSeriesEndgame | Class used to finish tracking paths during Homotopy Continuation |
| CFixedPrecEndgame | Fixed-precision endgame precision policy (refines and ensures precision at a single working precision) |
| CEGPrecSelector | Base empty class |
| CEndgameSelector | Facilitates lookup of required endgame type based on tracker type |
| CSecurityConfig | Security (divergence-bailout) configuration for an endgame |
| CEndgameConfig | Configuration common to all endgames (sampling and final-approximation tolerances) |
| CPowerSeriesConfig | Power-series-endgame configuration |
| CCauchyConfig | Cauchy-endgame configuration |
| CTrackBackConfig | Track-back endgame configuration |
| CAlgoTraits | |
| CAlgoTraits< PowerSeriesEndgame< PrecT > > | Specialization for PowerSeries, which uses CRTP |
| CAlgoTraits< CauchyEndgame< PrecT > > | Specialization for Cauchy, which uses CRTP |
| CComputedSamplePoint | A new sample point on the path was computed, adding one point to the sequence of the endgame's approach to the target time |
| CCircleAdvanced | Advanced around the circle around target time |
| CPrecisionChanged | Event emitted when the endgame's working precision changes |
| CEGPrecSelector< tracking::DoublePrecisionTracker > | Selects the fixed-precision endgame policy for the double-precision tracker |
| CEGPrecSelector< tracking::MultiplePrecisionTracker > | Selects the fixed-precision endgame policy for the multiple-precision tracker |
| CEGPrecSelector< tracking::FixedPrecisionTracker< D > > | Selects the fixed-precision endgame policy for a fixed-precision tracker |
| CGoryDetailLogger | Logs the endgame run, with gory detail |
| CEventRecorder | Counts endgame events and captures their payloads, for tests and diagnostics |
| CSampleSequenceCollector | Collects an endgame's approach to the root as a time-indexed sequence, for callers that need to watch a quantity BEHAVE as the point improves rather than judge it at a single point |
| CEndgamePrecPolicyBase | A common base type for various precision types, fixed and adaptive |
| Nnode | |
| Nspecial_number | |
| CPi | The number  |
| CE | The number  |
| CDecodingCursor | A read position over one canonical-encoding text, with the small lexical helpers the grammar needs (literals, words, netstrings, numbers) |
| CDecodingContext | The back-reference table of one decoding pass: the nodes in first-encounter order, so #<index> resolves to the node the encoder numbered index |
| CEncodingContext | Traversal state for one canonical-encoding pass: the back-reference table |
| CNode | An interface for all nodes in a function tree, and for a function object as well |
| CSumOperator | Represents summation and difference Operator |
| CNegateOperator | The negation Operator |
| CMultOperator | Multiplication and division Operator |
| CPowerOperator | Operator for power functions with arbitrary expressions in the exponent and base |
| CIntegerPowerOperator | This class represents the exponentiation Operator |
| CSqrtOperator | Represents the square root Operator |
| CExpOperator | Exponential function |
| CLogOperator | Natural logarithm function |
| COperator | Abstract Node type from which all Operators inherit |
| CUnaryOperator | Interface for all unary Operator types |
| CNaryOperator | Abstract interface for n-ary Operator types |
| CTrigOperator | Abstract class for trigonometric Operator types |
| CSinOperator | Provides the sine Operator |
| CArcSinOperator | Provides the inverse sine Operator |
| CCosOperator | Provides the cosine Operator |
| CArcCosOperator | Provides the arc cosine Operator |
| CTanOperator | Provides the tangent Operator |
| CArcTanOperator | Provides the inverse tangent Operator |
| CNamedExpression | A user-named expression — the surviving, immutable entry point into a subtree |
| CDifferential | Provides the differential type for differentiation of expression trees |
| CNumber | Abstract Number type from which other Numbers derive |
| CInteger | Signed real Integer storage in an expression tree |
| CComplex | A complex-number literal node in an expression tree |
| CRational | The Rational number type for Bertini2 expression trees |
| CSymbol | Abstract symbol class |
| CNameHolder | Capability class for things which have a name |
| CNamedSymbol | Symbols which have names are named symbols |
| CVariable | Represents variable leaves in the function tree |
| Nclassic | |
| CClassicWriteOptions | Tracking / precision settings to emit in the CONFIG section, in Bertini 1 terms |
| Ngenerators | |
| CBertiniNumPolicy | Karma real-number formatting policy: always scientific, at the type's full precision |
| CBertiniNumPolicy< real_mp > | BertiniNumPolicy specialization for multiprecision reals (precision follows the value) |
| CClassic | Generators emitting numbers and vectors in classic Bertini format (real then imaginary) |
| CCPlusPlus | Generators emitting numbers in C++ source literal format |
| Nparsing | |
| Nclassic | |
| CSplitInputFile | Storage class for input file that splits up the config portion from the input portion |
| CSplitInputFileParser | Qi Parser object for parsing text into the SplitInputfile class |
| CCommentStripper | Qi Parser object for removing comments from a line of text and then returns the uncommented line |
| CFunctionParser | A Qi grammar parser for parsing text into function trees |
| CMpfrFloatParser | A Qi grammar parsing a real multiprecision number, at a precision matching the input's digits |
| CMpfrComplexParser | A Qi grammar parsing a complex multiprecision number (real then imaginary part) |
| CConfigParser | Base variadic parser for parsing many config structs at once |
| CConfigParser< ConfigT > | Specialization of ConfigParser for a single config struct |
| CConfigParser< detail::TypeList< Ts... > > | Specialization of ConfigParser for a typelist, returning a thing passed down from the base variadic case |
| CConfigSettingParser< Iterator, algorithm::TolerancesConfig, Skipper > | Parser for the TolerancesConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, algorithm::ZeroDimConfig, Skipper > | Parser for the ZeroDimConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, algorithm::MidPathConfig, Skipper > | Parser for the MidPathConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, algorithm::RecordsConfig, Skipper > | Parser for RecordsConfig: the classic input format has no keyword for it, so this consumes the config text and leaves the defaults |
| CConfigSettingParser< Iterator, algorithm::AutoRetrackConfig, Skipper > | Parser for the AutoRetrackConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, algorithm::SharpeningConfig, Skipper > | Parser for the SharpeningConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, algorithm::RegenerationConfig, Skipper > | Parser for the RegenerationConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, algorithm::PostProcessingConfig, Skipper > | Parser for the PostProcessingConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, algorithm::classic::AlgoChoice, Skipper > | Parser for the AlgoChoice settings block of classic Bertini input |
| CConfigSettingParser< Iterator, algorithm::classic::EndgameChoiceConfig, Skipper > | Parser for the EndgameChoiceConfig settings block of classic Bertini input |
| CConfigSettingParser | Qi Parser object for parsing config settings This ensures we can provide backwards compatibility with Bertini Classic input files |
| CConfigSettingParser< Iterator, bertini::endgame::SecurityConfig, Skipper > | Parser for the SecurityConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, bertini::endgame::EndgameConfig, Skipper > | Parser for the EndgameConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, bertini::endgame::PowerSeriesConfig, Skipper > | Parser for the PowerSeriesConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, bertini::endgame::CauchyConfig, Skipper > | Parser for the CauchyConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, bertini::endgame::TrackBackConfig, Skipper > | Parser for the TrackBackConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, algorithm::RandomConfig, Skipper > | Parser for the RandomConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, PrecisionType, Skipper > | Qi Parser object for parsing config settings This ensures we can provide backwards compatibility with Bertini Classic input files |
| CConfigSettingParser< Iterator, Predictor, Skipper > | Parser for the Predictor settings block of classic Bertini input |
| CConfigSettingParser< Iterator, TrackerConfig, Skipper > | The tracker's own settings, from a classic input file |
| CConfigSettingParser< Iterator, SteppingConfig, Skipper > | Parser for the SteppingConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, NewtonConfig, Skipper > | Parser for the NewtonConfig settings block of classic Bertini input |
| CConfigSettingParser< Iterator, FixedPrecisionConfig, Skipper > | As of this writing, there are no meaningful settings in FixedPrecisionConfig, so this parser is ... empty |
| CConfigSettingParser< Iterator, AdaptiveMultiplePrecisionConfig, Skipper > | Parser for the AdaptiveMultiplePrecisionConfig settings block of classic Bertini input |
| CSystemParser | Qi Parser object for parsing text into the System class |
| Nlinalg | |
| CPartialPivLU | Stateful partial-pivot LU factor/solve with preallocated, precision-adjustable banks |
| Nlogging | |
| CLogging | |
| Nalgorithm | |
| Nclassic | |
| CEndgameChoiceConfig | Selects which endgame to use (classic input) |
| Noutput | |
| COutputter | Prints data from algorithms |
| CClassic | |
| CClassic< HomotopySolver< A, B, C > > | Writes a solver's results in the classic Bertini output format |
| CClassic< ZeroDimSolver< A, B, C > > | |
| CNonsingularSolutions | Extracts the nonsingular (multiplicity-one) solutions from a solver's results |
| CAllSolutions | Extracts all solutions from a solver's results |
| CSharpen | |
| Nzero_dim_detail | |
| COwnedHomotopy | Owns and builds the target / start system / homotopy for a zero-dim solve |
| CAnyAlgorithm | Type-erased base for all nag algorithms, exposing a single Run() entry point |
| CTolerancesConfig | Newton and path-tracking tolerances |
| CMidPathConfig | Configuration for the midpath (path-crossing) check |
| CAutoRetrackConfig | Configuration for auto-retracking paths flagged as crossed |
| CSharpeningConfig | Configuration for sharpening computed solutions |
| CRegenerationConfig | Configuration for the regeneration cascade |
| CPostProcessingConfig | Configuration for post-processing solutions (reality/finiteness/singularity classification) |
| CRecordsConfig | How a recording algorithm uses the records it finds: not what to compute, but what already-recorded work counts as done |
| CZeroDimConfig | Top-level configuration for a zero-dimensional solve (times, precision, threading) |
| CMetaConfig | Top-level meta configuration: which algorithm to run |
| CRandomConfig | The RNG seed a classic Bertini input file asks for, via randomseed: N; |
| CAlgoTraits | |
| CPathStarted | The algorithm is beginning work on one solution path, carrying its index |
| CPathComplete | The algorithm has finished work on one solution path, carrying its index |
| CMidpathChecker | Detects whether any solution paths crossed during tracking, before the endgame |
| CCrossedPath | Stores data for each path that crosses, including the index of the path, all paths that it crosses with, and whether it has the same starting point as a path it crosses with |
| CNewtonRefineResult | The outcome of a standalone Newton refinement |
| CNumericalIrreducibleDecomposition | Forward declare of the NumericalIrreducibleDecomposition algorithm |
| CAlgoTraits< NumericalIrreducibleDecomposition< TrackerType, EndgameType, SystemType > > | Specify the traits for the algorithm |
| CAnyNID | Type-erased base for the Numerical Irreducible Decomposition algorithm |
| CSharpen | |
| CHomotopySolver | The continuation primitive: given a homotopy + a source of start points, track each path through the tracker and endgame, resolve crossings, classify the endpoints, and report |
| CScopedSessionState | Restores the ambient session state a solve may perturb: "a solve
leaves the session as it found it" |
| CZeroDimSolver | The zero-dimensional solve algorithm: given a polynomial system, form a start system and a homotopy, then run the continuation engine |
| CAlgoTraits< HomotopySolver< TrackerType, EndgameType, SystemType > > | Specify the traits for the algorithm |
| CAnyZeroDim | Type-erased base for a zero-dimensional solve, exposing output and config entry points |
| CAlgorithmMetaData | Metadata structs |
| CSolutionMetaData | Per-solution metadata gathered during and after a path track |
| CEGBoundaryMetaData | State captured at the endgame boundary, handed off to start the endgame |
| CMidpathCheckReport | Summary of what the midpath (path-crossing) check found at the endgame boundary, and what the algorithm did about it |
| CSolveReport | A concise, human-readable summary of a zero-dimensional solve: how every path ended up, and – crucially – whether any path was lost |
| Nstart_system | |
| CMHomogeneous | The $m$-homogeneous start system for Numerical Algebraic Geometry |
| CTotalDegreeBinomial | Roots-of-unity start system for 1-homogeneous polynomial systems |
| CTotalDegreeLinearProduct | Total degree start system for 1-homogeneous polynomial systems, built from random linear products |
| CUser | The user-provided start system for Numerical Algebraic Geometry |
| CStartSystem | Abstract base class for other start systems |
| Nnag_datatype | |
| Npolicy | |
| CCopy | Storage policy that holds objects by value (a copy) |
| CReference | Storage policy that holds a reference to an externally-owned object |
| CSharedPtr | Storage policy that holds objects via std::shared_ptr |
| CNumericalIrreducibleDecomposition | The NID data type for Bertini2 |
| CWitnessSet | The main way to represent a positive dimensional component in numerical algebraic geometry |
| Nparallel | |
| CStartPointTask | Work item for the speculative-full-path model: a path index plus its start point |
| CFullPathResult | Result of executing one WHOLE path: start -> endgame boundary -> target |
| CThreadSafeQueue | A simple thread-safe (mutex + condition-variable) FIFO queue |
| CPoolShutdownSentinel | |
| CWorkerThreadPool | Thread pool for parallel path tracking within a single MPI worker rank |
| Nrecords | |
| CDrawStream | A deterministic, fully-specified random stream (SHA-256 counter mode) |
| COutputDirectory | One structured output directory: definitions/ + history/ + derived views |
| Nsettings | |
| Nparsing | |
| CConfigToIni | Qi Parser object for converting Bertini configuration settings into ini format so they can be read by Boost.ProgramOptions |
| Nblocks | |
| CBlendBlock | A block forming the blend (coupling homotopy) H = sum_i c_i(t) * operand_i of several systems |
| Cis_block | Detection trait: does B satisfy the evaluation-block contract? |
| Cis_block< B, std::void_t< decltype(std::declval< const B & >().NumFunctions()), decltype(std::declval< const B & >().DependsOnPathVariable()), decltype(std::declval< const B & >().Precision()), decltype(std::declval< const B & >().Precision(0u)), decltype(std::declval< const B & >().Degrees()), decltype(std::declval< const B & >().Degrees(std::declval< VariableGroup const & >())), decltype(std::declval< const B & >().IsHomogeneous(std::declval< VariableGroup const & >())), decltype(std::declval< const B & >().IsPolynomial(std::declval< VariableGroup const & >())), decltype(std::declval< B & >().Homogenize(std::declval< VariableGroup const & >(), std::declval< std::shared_ptr< node::Variable > const & >())), decltype(std::declval< const B & >().template EvalInPlace< complex_dbl >(std::declval< Eigen::Ref< Vec< complex_dbl > > >(), std::declval< Vec< complex_dbl > const & >(), std::declval< complex_dbl const & >())), decltype(std::declval< const B & >().template JacobianInPlace< complex_dbl >(std::declval< Eigen::Ref< Mat< complex_dbl > > >(), std::declval< Vec< complex_dbl > const & >(), std::declval< complex_dbl const & >())), decltype(std::declval< const B & >().template TimeDerivInPlace< complex_dbl >(std::declval< Eigen::Ref< Vec< complex_dbl > > >(), std::declval< Vec< complex_dbl > const & >(), std::declval< complex_dbl const & >()))> > | |
| CLinearFormsBlock | A block of system functions, each an affine linear form f_i(x) = c_i |
| CPolynomialBlock | The polynomial evaluation block: function trees + derivatives + SLP |
| CProductsOfLinearsBlock | A block of system functions, each a product of linear forms |
| CRandomizationBlock | A block that randomizes an overdetermined operand system down to a square one (with a constant coefficient matrix) |
| Nsystem | |
| CPrecon | A collection of preconstructed example systems, for tests and demonstrations |
| Ntracking | |
| Npredict | |
| CExplicitRKPredictor | A class which stores all the explicit single-step multi-stage ODE predictor methods |
| Ncorrect | |
| CNewtonCorrector | /class NewtonCorrector |
| CAMPTracker | Functor-like class for tracking paths on a system |
| CTracker | Base tracker class for trackers offered in Bertini2 |
| CStepMetadata | Metadata produced by a single predict or correct step |
| CSteppingConfig | Settings governing step-size adjustment during tracking |
| CNewtonConfig | Settings governing the Newton corrector's iteration bounds |
| CTrackerConfig | The thresholds a tracker judges a path against: close enough, and too big |
| CFixedPrecisionConfig | Settings for a fixed-precision tracker (carries the single working precision in effect) |
| CAdaptiveMultiplePrecisionConfig | Holds the program parameters with respect to Adaptive Multiple Precision |
| CFixedPrecisionTracker | CRTP base for trackers that work at a single fixed precision (double or fixed multiple) |
| CTrackerTraits | Trait lookup mapping a tracker type to its numeric types, event-emitter type, precision config, and the type/config lists it needs |
| CSuccessfulPredict | The predict part of tracking step was successful |
| CSuccessfulCorrect | The correct part of a time step was successful |
| CPrecisionChanged | Event emitted when the tracker's working precision changes |
| CPrecisionIncreased | Precision increased during tracking |
| CPrecisionDecreased | Precision decreased during tracking |
| CInitializing | TrackPath is initializing the tracker |
| CDoublePrecisionTracker | A tracker that works entirely in hardware double precision |
| CMultiplePrecisionTracker | A tracker that works at a fixed multiprecision (set from the default precision at construction) |
| CFirstPrecisionRecorder | Observer that records the starting precision and the first precision increase of each track: each call to TrackPath, from its start |
| CMinMaxPrecisionRecorder | Observer that records the minimum and maximum precision of each track: each call to TrackPath, from its start |
| CPathPrecisionRecorder | Observer that records the precision a whole path used, across every call to TrackPath that tracks it: the track to the endgame boundary and every endgame sub-track |
| CPrecisionAccumulator | Observer that collects the precision at every tracking event into a vector |
| CAMPPathAccumulator | Example usage: PathAccumulator<AMPTracker> path_accumulator; |
| CGoryDetailLogger | Observer that logs verbose ("gory detail") diagnostics for every tracking event |
| CStepFailScreenPrinter | Observer that prints a message to standard out whenever a step fails |
| CParsedArgs | Parsed results of the command-line arguments |
| CScopedStopRequest | Clears any stale stop request on the way in, and again on the way out |
| CAnyEvent | Strawman Event type, enabling polymorphism |
| CEvent | |
| CEvent< ObsT, true > | For emission of events from observables |
| CEvent< ObsT, false > | For emission of events from observables |
| CIncompatibleObserver | Thrown when an observer is attached to an observable it cannot observe |
| CObservable | An abstract observable type, maintaining a list of observers, who can be notified in case of Events |
| CAnyObserver | Strawman base class for Observer objects |
| CObserver | Actual observer type, which you should derive from to extract custom information from observable types |
| CMultiObserver | A class which can glob together observer types into a new, single observer type |
| CTypedObserver | CRTP base that turns an observer into a set of typed Observe() overloads |
| CVisitableBase | The base class for visitable types |
| CVisitorBase | A strawman class for implementing the visitor pattern |
| CVisitor | The first non-trivial visitor class |
| Cscoped_mpfr_precision_options_this_thread | RAII guard setting the multiprecision variable-precision options for the current thread, restoring on scope exit |
| Cscoped_mpfr_precision_options_all_threads | RAII guard setting the multiprecision variable-precision options for all threads, restoring on scope exit |
| CNumTraits | Numeric traits for a bertini number type: digit counts, conversions, and companion types |
| CNumTraits< double > | Numeric traits for the built-in double type |
| CNumTraits< complex_dbl > | Numeric traits for double-precision complex numbers |
| CNumTraits< real_mp > | Numeric traits for multiprecision reals (digit counts follow the thread precision) |
| CNumTraits< complex_mp > | Numeric traits for multiprecision complex numbers (digit counts follow the thread precision) |
| CNumTraits< mpq_rational > | Numeric traits for exact rationals (provides decimal-string parsing) |
| CSystemPool | |
| CPointPool | |
| CPatch | An affine chart on a product of projective spaces |
| CSlice | A linear slice of affine or projective space: a stack of linear forms, M [x ; 1] |
| CSLPOutputLocations | A struct encapsulating the starting locations of outputs in the SLP's memory layout |
| CSLPInputLocations | A struct encapsulating the starting locations of inputs in the SLP's memory layout |
| CSLPNumberOf | A struct encapsulating the numbers of things appearing in the SLP |
| CConstantRecipe | An exact, node-independent description of a constant baked into the program: enough to (re)produce the constant's value at any working precision, without evaluating a function-tree node (ADR-0027; node evaluation is being retired) |
| CSLPMemory | The per-thread mutable working state of a straight-line program evaluation: the register file (one bank per number type), the working precision, and the freshness / frozen-prologue flags |
| CSLPProgram | The immutable compiled straight-line program (ADR-0027): the instruction tape, the constant recipe (true values of numbers + integer bank), and the memory layout (numbers of / locations of things) |
| CStraightLineProgram | An implementation of straight-line programs, implemented with strong inspiration from Bertini1's implementation |
| CSLPCompiler | Compiles a System (or polynomial block) into a StraightLineProgram by visiting its function-tree nodes and emitting tape instructions (with common-subexpression sharing) |
| CNodeMatrix | A matrix of expression-tree nodes (the symbolic Jacobian), stored row-major |
| CSystem | The fundamental polynomial system class for Bertini2 |
| Nboost | |
| Nmultiprecision | |
| Cis_compatible_arithmetic_type< double, number< Backend > > | |
| Cis_compatible_arithmetic_type< mpq_rational, number< Backend > > | |
