|
carl
25.02
Computer ARithmetic Library
|
|
carl
25.02
Computer ARithmetic Library
|
| ►Ncarl | Carl is the main namespace for the library |
| ►Ncheckpoints | |
| CCheckpointVector | |
| CCheckpointVerifier | |
| ►Ncontractor | |
| CEvaluation | Represents a contraction operation of the form |
| CContractor | |
| ►Nconvert_poly | |
| CConvertHelper | |
| CConvertHelper< ContextPolynomial< A, B, C >, MultivariatePolynomial< A, B, C > > | |
| CConvertHelper< MultivariatePolynomial< A, B, C >, ContextPolynomial< A, B, C > > | |
| ►Nconvert_ran | |
| CConvertHelper | |
| ►Ncovering | |
| CSetCover | Represents a set cover problem |
| CTypedSetCover | Represents a set cover problem where a set is represented by some type |
| ►Ndetail | |
| Cstream_joined_impl | |
| Ctuple_accumulate_impl | Helper functor for carl::tuple_accumulate that actually does the work |
| Cvariant_is_type_visitor | |
| Cvariant_extend_visitor | |
| Cvariant_hash | |
| Cis_from_variant_wrapper | |
| Cis_from_variant_wrapper< Check, T, Variant< Args... > > | |
| ►Nformula | |
| ►Nsymmetry | |
| CColorGenerator | Provides unique ids (colors) for all kinds of different objects in the formula: variable types, relations, formula types, numbers, special colors and indexes |
| CPermutation | |
| CGraphBuilder | |
| ►Nhelper | |
| CSubstitutor | |
| CPolynomialSubstitutor | |
| CBitvectorSubstitutor | |
| CUninterpretedSubstitutor | |
| ►Nio | |
| ►Ndetail | |
| CSMTLIBScriptContainer | Shorthand to allow writing SMTLIB scripts in one line |
| CSMTLIBOutputContainer | |
| ►Nhelper | |
| ►CErrorHandler | |
| Cresult | |
| ►Nparser | |
| CRationalPolicies | |
| ►CExpressionParser | |
| Cperform_addition | |
| Cperform_division | |
| Cperform_multiplication | |
| Cperform_negate | |
| Cperform_power | |
| Cperform_subtraction | |
| Cprint_expr_type | |
| CFormulaParser | |
| CParser | |
| CPolynomialParser | |
| CRationalFunctionParser | |
| CDIMACSExporter | Write formulas to the DIMAS format |
| CDIMACSImporter | Parser for the DIMACS format |
| CMapleStream | |
| CSkipper | |
| COPBParser | |
| COPBFile | |
| COPBImporter | |
| CQEPCADStream | |
| CSMTLIBStream | Allows to print carl data structures in SMTLIB syntax |
| CInvalidInputStringException | |
| CStringParser | |
| ►Nlogging | Contains a custom logging facility |
| CFilter | This class checks if some log message shall be forwarded to some sink |
| CFormatter | Formats a log messages |
| CLogger | Main logger class |
| CRecordInfo | Additional information about a log message |
| CSink | Base class for a logging sink |
| CStreamSink | Logging sink that wraps an arbitrary std::ostream |
| CFileSink | Logging sink for file output |
| ►Nparser | |
| CisDivisible | |
| CisDivisible< true > | |
| CisDivisible< false > | |
| CRationalPolicies | Specialization of qi::real_policies for our rational types |
| CIntegerParser | Parses (signed) integers |
| CDecimalParser | Parses decimals, including floating point and scientific notation |
| CRationalParser | Parses rationals, being two decimals separated by a slash |
| ►Npool | |
| ►CLocalPool | |
| Ccontent_equal | |
| Ccontent_hash | |
| CLocalPoolElementWrapper | |
| CLocalPoolElement | |
| ►CPool | |
| Ccontent_equal | |
| Ccontent_hash | |
| CPoolElementWrapper | |
| CPoolElement | |
| CRehashPolicy | Mimics stdlibs default rehash policy for hashtables |
| ►Nran | |
| ►Ninterval | |
| CFieldExtensions | This class can be used to construct iterated field extensions from a sequence of real algebraic numbers |
| CLazardEvaluation | |
| CRealRootIsolation | Compact class to isolate real roots from a univariate polynomial using bisection |
| Cran_evaluator | |
| ►Nsettings | |
| CSettings | Base class for central settings class |
| Cduration | Helper type to parse duration as std::chrono values with boost::program_options |
| Cbinary_quantity | Helper type to parse quantities with binary SI-style suffixes |
| Cmetric_quantity | Helper type to parse quantities with SI-style suffixes |
| COptionPrinter | Helper class to nicely print the options that are available |
| CSettingsPrinter | Helper class to nicely print the settings that were parsed |
| CSettingsParser | Base class for a settings parser |
| ►Nstatistics | |
| CMultiCounter | |
| CSeries | |
| CStatistics | |
| CStatisticsCollector | |
| CStatisticsPrinter | |
| CTimer | |
| ►Ntree_detail | |
| CNode | |
| CBaseIterator | This is the base class for all iterators |
| CPreorderIterator | Iterator class for pre-order iterations over all elements |
| CPostorderIterator | Iterator class for post-order iterations over all elements |
| CLeafIterator | Iterator class for iterations over all leaf elements |
| CDepthIterator | Iterator class for iterations over all elements of a certain depth |
| CChildrenIterator | Iterator class for iterations over all children of a given element |
| CPathIterator | Iterator class for iterations from a given element to the root |
| ►Nvs | |
| ►Ndetail | |
| CSubstitution | |
| CTerm | |
| Czero | A square root expression with side conditions |
| CBasicConstraint | Represent a polynomial (in)equality against zero |
| CCArLConverter | |
| CConvertTo | |
| CConvertFrom | |
| CGiNaCConversion | |
| CToGiNaC | |
| CFromGiNaC | |
| CVariable | A Variable represents an algebraic variable that can be used throughout carl |
| CVariablePool | This class generates new variables and stores human-readable names for them |
| Cvariable_type_filter | |
| CcarlVariables | |
| CMultivariateRoot | |
| CVariableAssignment | |
| CVariableComparison | Represent a sum type/variant of an (in)equality between a variable on the left-hand side and multivariateRoot or algebraic real on the right-hand side |
| CDivisionLookupResult | The result of |
| CUpdateFnct | |
| CDefaultBuchbergerSettings | Standard settings used if the Buchberger object is not instantiated with another template parameter |
| CBuchberger | Gebauer and Moeller style implementation of the Buchberger algorithm |
| CBuchbergerStats | A little class for gathering statistics about the Buchberger algorithm calls |
| CCriticalPairConfiguration | |
| CCriticalPairs | A data structure to store all the SPolynomial pairs which have to be checked |
| CCriticalPairsEntry | A list of SPol pairs which have to be checked by the Buchberger algorithm |
| CSPolPair | Basic spol-pair |
| CSPolPairCompare | |
| CAbstractGBProcedure | |
| CGBProcedure | A general class for Groebner Basis calculation |
| CUpdateFnc | |
| CStdAdding | |
| CRadicalAwareAdding | |
| CRealRadicalAwareAdding | |
| CIdealDatastructureVector | |
| CIdeal | |
| CReductorConfiguration | Class with the settings for the reduction algorithm |
| CReductor | A dedicated algorithm for calculating the remainder of a polynomial modulo a set of other polynomials |
| CReductorEntry | An entry in the reduction polynomial |
| CInterval | The class which contains the interval arithmetic including trigonometric functions |
| Cis_interval_type< carl::Interval< Number > > | |
| Cis_interval_type< const carl::Interval< Number > > | |
| Cpolicies | Struct which holds the rounding and checking policies required for boost interval |
| Cpolicies< double, Interval > | Template specialization for rounding and checking policies for native double |
| CLowerBound | |
| CUpperBound | |
| Cis_number_type< Interval< T > > | |
| Cchecking | |
| Crounding | |
| Cis_interval_type | States whether a given type is an Interval |
| CVarSolutionFormula | |
| CContraction | |
| CSimpleNewton | |
| Cis_integer_type< cln::cl_I > | States that cln::cl_I has the trait is_integer_type |
| Cis_rational_type< cln::cl_RA > | States that cln::cl_RA has the trait is_rational_type |
| CIntegralType< cln::cl_I > | States that IntegralType of cln::cl_I is cln::cl_I |
| CIntegralType< cln::cl_RA > | States that IntegralType of cln::cl_RA is cln::cl_I |
| CFLOAT_T | Templated wrapper class which allows universal usage of different IEEE 754 implementations |
| CFloatConv | Struct which holds the conversion operator for any two instanciations of FLOAT_T with different underlying floating point implementations |
| CconvRnd | |
| CIntegralType< carl::FLOAT_T< F > > | |
| Cis_rational_type< FLOAT_T< C > > | |
| Cis_float_type< carl::FLOAT_T< C > > | |
| Cis_integer_type< mpz_class > | States that mpz_class has the trait is_integer_type |
| Cis_rational_type< mpq_class > | States that mpq_class has the trait is_rational_type |
| CIntegralType< mpq_class > | States that IntegralType of mpq_class is mpz_class |
| CIntegralType< mpz_class > | States that IntegralType of mpz_class is mpz_class |
| CEEA | Extended euclidean algorithm for numbers |
| Cis_subset_of_integers_type< signed char > | States that signed char has the trait is_subset_of_integers_type |
| Cis_subset_of_integers_type< short int > | States that short int has the trait is_subset_of_integers_type |
| Cis_subset_of_integers_type< int > | States that int has the trait is_subset_of_integers_type |
| Cis_subset_of_integers_type< long int > | States that long int has the trait is_subset_of_integers_type |
| Cis_subset_of_integers_type< long long int > | States that long long int has the trait is_subset_of_integers_type |
| Cis_subset_of_integers_type< unsigned char > | States that unsigned char has the trait is_subset_of_integers_type |
| Cis_subset_of_integers_type< unsigned short int > | States that unsigned short int has the trait is_subset_of_integers_type |
| Cis_subset_of_integers_type< unsigned int > | States that unsigned int has the trait is_subset_of_integers_type |
| Cis_subset_of_integers_type< unsigned long int > | States that unsigned long int has the trait is_subset_of_integers_type |
| Cis_subset_of_integers_type< unsigned long long int > | States that unsigned long long int has the trait is_subset_of_integers_type |
| CIntegralType< float > | States that IntegralType of float is sint |
| CIntegralType< double > | States that IntegralType of double is sint |
| CIntegralType< long double > | States that IntegralType of long double is sint |
| Cconstant_zero | |
| Cconstant_one | |
| CFactorizationFactory | This class provides a cached factorization for numbers |
| CFactorizationFactory< uint > | This class provides a cached prime factorization for std::size_t |
| CIntegerPairCompare | |
| CGaloisField | A finite field |
| CGaloisFieldManager | |
| CGFNumber | Galois Field numbers, i.e |
| CPrimeFactory | This class provides a convenient way to enumerate primes |
| Cremove_all | |
| Cremove_all< T, T > | |
| Chas_subtype | This template is designed to provide types that are related to other types |
| CUnivariatePolynomial | This class represents a univariate polynomial with coefficients of an arbitrary type |
| CMultivariatePolynomial | The general-purpose multivariate polynomial class |
| Cis_rational_type | States if a type is a rational type |
| Cis_subset_of_rationals_type | States if a type represents a subset of all rationals and the representation is similar to a rational |
| Cis_field_type | States if a type is a field |
| Cis_field_type< GFNumber< C > > | States that a Gallois field is a field |
| Cis_finite_type | States if a type represents only a finite domain |
| Cis_finite_type< GFNumber< C > > | Type trait is_finite_type_domain |
| Cis_float_type | States if a type is a floating point type |
| Cis_integer_type | States if a type is an integer type |
| Cis_subset_of_integers_type | States if a type represents a subset of all integers |
| Cis_number_type | States if a type is a number type |
| Cis_number_type< GFNumber< C > > | |
| Ccharacteristic | Type trait for the characteristic of the given field (template argument) |
| CIntegralType | Gives the corresponding integral type |
| CIntegralType< GFNumber< C > > | |
| CUnderlyingNumberType | Gives the underlying number type of a complex object |
| CPreventConversion | |
| CContext | |
| CContextPolynomial | |
| Cneeds_context_type< ContextPolynomial< Coeff, Ordering, Policies > > | |
| Cis_polynomial_type< ContextPolynomial< Coeff, Ordering, Policies > > | |
| Cis_polynomial_type | |
| Cneeds_cache_type | |
| Cneeds_context_type | |
| Cis_factorized_type | |
| CChebyshev | Implements a generator for Chebyshev polynomials |
| CDivisionResult | A strongly typed pair encoding the result of a division, being a quotient and a remainder |
| CEZGCD | Extended Zassenhaus algorithm for multivariate GCD calculation |
| CMultivariateHorner | |
| Cstrategy | |
| CDiophantineEquations | Includes the algorithms 6.2 and 6.3 from the book Algorithms for Computer Algebra by Geddes, Czaper, Labahn |
| CMultivariateHensel | |
| CTaylorExpansion | |
| CMonomial | The general-purpose monomials |
| ChashLess | |
| ChashEqual | |
| CMonomialComparator | A class for term orderings |
| ►CMonomialPool | |
| Ccontent_equal | |
| Ccontent_hash | |
| Cis_polynomial_type< carl::MultivariatePolynomial< T, O, P > > | |
| CUnderlyingNumberType< MultivariatePolynomial< C, O, P > > | States that UnderlyingNumberType of MultivariatePolynomial<C,O,P> is UnderlyingNumberType<C>::type |
| CNoAllocator | |
| CNoReasons | |
| CBVReasons | |
| CStdMultivariatePolynomialPolicies | The default policy for polynomials |
| CTerm | Represents a single term, that is a numeric coefficient and a monomial |
| CTermAdditionManager | |
| ►CIntRepRealAlgebraicNumber | |
| Ccontent | |
| Cis_polynomial_type< carl::UnivariatePolynomial< T > > | |
| CUnderlyingNumberType< UnivariatePolynomial< C > > | States that UnderlyingNumberType of UnivariatePolynomial<T> is UnderlyingNumberType<C>::type |
| CVarInfo | |
| CVarsInfo | |
| Cis_ran_type | |
| ►CRealRootsResult | |
| Cnon_univariate_t | |
| Cnullified_t | |
| Cis_ran_type< IntRepRealAlgebraicNumber< Number > > | |
| ►CRealAlgebraicNumberThom | |
| CContent | |
| Cis_ran_type< RealAlgebraicNumberThom< Number > > | |
| CSignCondition | |
| CSignDetermination | |
| CGroebnerBase | |
| CBaseRepresentation | |
| ►CMultiplicationTable | |
| CTableContent | |
| CTarskiQueryManager | |
| CThomEncoding | |
| CRealAlgebraicNumber | |
| CSqrtEx | |
| CCompileInfo | Compile time generated structure holding information about compiler and system version |
| CCMakeOptionPrinter | |
| ►CBitset | This class is a simple wrapper around boost::dynamic_bitset |
| Citerator | Iterate for iterate over all bits of a Bitset that are set to true |
| ►CBitVector | |
| Cforward_iterator | |
| Ctree | This class represents a tree |
| ►CCompactTree | This class packs a complete binary tree in a vector |
| CNode | |
| ►CHeap | A heap priority queue |
| Cc_iterator | |
| CTimer | This classes provides an easy way to obtain the current number of milliseconds that the program has been running |
| ►CCache | |
| CInfo | |
| CIDPool | |
| CSingleton | Base class that implements a singleton |
| Coverloaded | |
| Cdependent_bool_type | |
| Cany | Meta-logical disjunction |
| Cany< Head, Tail... > | |
| Call | Meta-logical conjunction |
| Call< Head, Tail... > | |
| CVoid | |
| Cis_instantiation_of | |
| Cis_instantiation_of< Template, Template< Args... > > | |
| Chash_inserter | Utility functor to hash a sequence of object using an output iterator |
| Cmpl_unique | |
| Cmpl_concatenate_impl | |
| Cmpl_concatenate_impl< 1, Front, Tail... > | |
| Cmpl_concatenate | |
| Cmpl_variant_of_impl | |
| Cmpl_variant_of_impl< true, Vector, Unpacked... > | |
| Cmpl_variant_of | |
| Cequal_to | Alternative specialization of std::equal_to for pointer types |
| Cequal_to< T *, mayBeNull > | |
| Cequal_to< std::shared_ptr< T >, mayBeNull > | |
| Cnot_equal_to | |
| Cnot_equal_to< T *, mayBeNull > | |
| Cnot_equal_to< std::shared_ptr< T >, mayBeNull > | |
| Cless | Alternative specialization of std::less for pointer types |
| Cless< T *, mayBeNull > | |
| Cless< std::shared_ptr< T >, mayBeNull > | |
| Cgreater | |
| Cgreater< T *, mayBeNull > | |
| Cgreater< std::shared_ptr< T >, mayBeNull > | |
| Chash | Alternative specialization of std::hash for pointer types |
| Chash< T *, mayBeNull > | |
| Chash< std::shared_ptr< T >, mayBeNull > | |
| Ctuple_convert | |
| Ctuple_convert< Converter, Information, Out > | |
| Cis_from_variant | |
| Cconvertible_to_variant | |
| CFactorizedPolynomial | |
| Cneeds_cache_type< FactorizedPolynomial< P > > | |
| Cis_factorized_type< FactorizedPolynomial< P > > | |
| CFactorization | |
| CPolynomialFactorizationPair | |
| CRationalFunction | |
| CConstraint | Represent a polynomial (in)equality against zero |
| CCachedConstraintContent | |
| CBVConstraint | |
| CBVConstraintPool | |
| CBVTerm | |
| CBVUnaryContent | |
| CBVBinaryContent | |
| CBVExtractContent | |
| CBVTermContent | |
| CBVTermPool | |
| CBVValue | |
| CBVVariable | Represent a BitVector-Variable |
| CPool | |
| CCondition | |
| CFormula | Represent an SMT formula, which can be an atom for some background theory or a boolean combination of (sub)formulas |
| CFormulaPool | |
| CQuantifierContent | Stores the variables and the formula bound by a quantifier |
| CAuxQuantifierContent | |
| CFormulaContent | |
| CModel | Represent a collection of assignments/mappings from variables to values |
| CModelFormulaSubstitution | |
| CModelMVRootSubstitution | |
| CModelPolynomialSubstitution | |
| CModelSubstitution | Represent a expression for a ModelValue with variables as placeholders, where the final expression's value depends on the bindings/values of these variables |
| CModelValue | Represent a sum type/variant over the different kinds of values that can be assigned to the different kinds of variables that exist in CARL and to use them in a more uniform way, e.g |
| CInfinityValue | This class represents infinity or minus infinity, depending on its flag positive |
| CModelVariable | Represent a sum type/variant over the different kinds of variables that exist in CARL to use them in a more uniform way, e.g |
| CModelConditionalSubstitution | |
| CSort | Implements a sort (for defining types of variables and functions) |
| CSortContent | The actual content of a sort |
| CSortManager | Implements a manager for sorts, containing the actual contents of these sort and allocating their ids |
| CSortValue | Implements a sort value, being a value of the uninterpreted domain specified by this sort |
| CSortValueManager | Implements a manager for sort values, containing the actual contents of these sort and allocating their ids |
| CUEquality | Implements an uninterpreted equality, that is an equality of either two uninterpreted function instances, two uninterpreted variables, or an uninterpreted function instance and an uninterpreted variable |
| CUFInstance | Implements an uninterpreted function instance |
| CUFInstanceContent | The actual content of an uninterpreted function instance |
| CUFInstanceManager | Implements a manager for uninterpreted function instances, containing their actual contents and allocating their ids |
| CUFContent | The actual content of an uninterpreted function instance |
| CUFManager | Implements a manager for uninterpreted functions, containing their actual contents and allocating their ids |
| CUFModel | Implements a sort value, being a value of the uninterpreted domain specified by this sort |
| CUninterpretedFunction | Implements an uninterpreted function |
| CUTerm | Implements an uninterpreted term, that is either an uninterpreted variable or an uninterpreted function instance |
| CUVariable | Implements an uninterpreted variable |
| ►Nstd | STL namespace |
| Chash< carl::BasicConstraint< Pol > > | Implements std::hash for constraints |
| Chash< std::vector< carl::BasicConstraint< Pol > > > | Implements std::hash for vectors of constraints |
| Chash< carl::Relation > | |
| Chash< carl::Variable > | Specialization of std::hash for Variable |
| Chash< carl::MultivariateRoot< Pol > > | |
| Chash< carl::VariableAssignment< Pol > > | |
| Chash< carl::VariableComparison< Pol > > | |
| Chash< carl::BoundType > | Specialization of std::hash for BoundType |
| Chash< carl::Interval< Number > > | Specialization of std::hash for an interval |
| Chash< cln::cl_RA > | |
| Chash< cln::cl_I > | |
| Chash< carl::FLOAT_T< Number > > | |
| Cnumeric_limits< carl::FLOAT_T< Number > > | |
| Chash< mpz_class > | |
| Chash< mpq_class > | |
| Chash< carl::ContextPolynomial< Coeff, Ordering, Policies > > | |
| Cequal_to< carl::Monomial::Arg > | |
| Cless< carl::Monomial::Arg > | |
| Chash< carl::Monomial > | The template specialization of std::hash for carl::Monomial |
| Chash< carl::Monomial::Arg > | The template specialization of std::hash for a shared pointer of a carl::Monomial |
| Chash< carl::MultivariatePolynomial< C, O, P > > | Specialization of std::hash for MultivariatePolynomial |
| Chash< carl::Term< Coefficient > > | Specialization of std::hash for a Term |
| Chash< carl::UnivariatePolynomial< Coefficient > > | Specialization of std::hash for univariate polynomials |
| Cless< carl::UnivariatePolynomial< Coefficient > > | Specialization of std::less for univariate polynomials |
| Chash< carl::IntRepRealAlgebraicNumber< Number > > | |
| Chash< carl::RealAlgebraicNumberThom< Number > > | |
| Chash< carl::SqrtEx< Poly > > | Implements std::hash for square root expressions |
| Chash< carl::Bitset > | |
| Chash< carl::TypeInfoPair< T, I > > | |
| Chash< std::vector< T > > | |
| Chash< carl::FactorizedPolynomial< P > > | |
| Chash< carl::PolynomialFactorizationPair< P > > | |
| Chash< carl::RationalFunction< Pol, AS > > | |
| Chash< carl::Constraint< Pol > > | Implements std::hash for constraints |
| Chash< std::vector< carl::Constraint< Pol > > > | Implements std::hash for vectors of constraints |
| Chash< carl::BVCompareRelation > | |
| Chash< carl::BVConstraint > | Implements std::hash for bit-vector constraints |
| Chash< carl::BVTerm > | Implements std::hash for bit vector terms |
| Chash< carl::BVUnaryContent > | |
| Chash< carl::BVBinaryContent > | |
| Chash< carl::BVExtractContent > | |
| Chash< carl::BVTermContent > | Implements std::hash for bit vector term contents |
| Chash< carl::BVValue > | Implements std::hash for bit vector values |
| Chash< carl::BVVariable > | Implement std::hash for bitvector variables |
| Chash< carl::FormulaContent< Pol > > | Implements std::hash for formula contents |
| Chash< carl::Formula< Pol > > | Implements std::hash for formulas |
| Chash< carl::ModelVariable > | |
| Chash< carl::Sort > | Implements std::hash for sort |
| Chash< carl::SortValue > | Implements std::hash for sort value |
| Chash< carl::UEquality > | Implements std::hash for uninterpreted equalities |
| Chash< carl::UFInstance > | Implements std::hash for uninterpreted function instances |
| Chash< carl::UFInstanceContent > | Implements std::hash for uninterpreted function instance's contents |
| Chash< carl::UFContent > | Implements std::hash for uninterpreted function's contents |
| Chash< carl::UFModel > | Implements std::hash for uninterpreted function model |
| Chash< carl::UninterpretedFunction > | Implements std::hash for uninterpreted functions |
| Chash< carl::UTerm > | Implements std::hash for uninterpreted terms |
| Chash< carl::UVariable > | Implements std::hash for uninterpreted variables |
| Chash< carl::vs::Term< Poly > > | |
| CExecuteBenchmarks | |
| CGbBenchmark | |
| CsortByLeadingTerm | Sorts generators of an ideal by their leading terms |
| CsortByPolSize | Sorts generators of an ideal by their number of terms |
1.9.1 
