/** @file flags.h
*
* Collection of all flags used through the GiNaC framework. */
/*
* GiNaC Copyright (C) 1999-2022 Johannes Gutenberg University Mainz, Germany
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef GINAC_FLAGS_H
#define GINAC_FLAGS_H
namespace GiNaC {
/** Flags to control the behavior of expand(). */
class expand_options {
public:
enum {
expand_indexed = 0x0001, ///< expands (a+b).i to a.i+b.i
expand_function_args = 0x0002, ///< expands the arguments of functions
expand_rename_idx = 0x0004, ///< used internally by mul::expand()
expand_transcendental = 0x0008 ///< expands transcendental functions like log and exp
};
};
/** Flags to control the behavior of has(). */
class has_options {
public:
enum {
algebraic = 0x0001 ///< enable algebraic matching
};
};
/** Flags to control the behavior of subs(). */
class subs_options {
public:
enum {
no_pattern = 0x0001, ///< disable pattern matching
subs_no_pattern = 0x0001, // for backwards compatibility
algebraic = 0x0002, ///< enable algebraic substitutions
subs_algebraic = 0x0002, // for backwards compatibility
pattern_is_product = 0x0004, ///< used internally by expairseq::subschildren()
pattern_is_not_product = 0x0008, ///< used internally by expairseq::subschildren()
no_index_renaming = 0x0010,
// To indicate that we want to substitute an index by something that
// is not an index. Without this flag the index value would be
// substituted in that case.
really_subs_idx = 0x0020
};
};
/** Domain of an object */
class domain {
public:
enum {
complex,
real,
positive
};
};
/** Flags to control series expansion. */
class series_options {
public:
enum {
/** Suppress branch cuts in series expansion. Branch cuts manifest
* themselves as step functions, if this option is not passed. If
* it is passed and expansion at a point on a cut is performed, then
* the analytic continuation of the function is expanded. */
suppress_branchcut = 0x0001
};
};
/** Switch to control algorithm for determinant computation. */
class determinant_algo {
public:
enum {
/** Let the system choose. A heuristics is applied for automatic
* determination of a suitable algorithm. */
automatic,
/** Gauss elimination. If \f$m_{i,j}^{(0)}\f$ are the entries of the
* original matrix, then the matrix is transformed into triangular
* form by applying the rules
* \f[
* m_{i,j}^{(k+1)} = m_{i,j}^{(k)} - m_{i,k}^{(k)} m_{k,j}^{(k)} / m_{k,k}^{(k)}
* \f]
* The determinant is then just the product of diagonal elements.
* Choose this algorithm only for purely numerical matrices. */
gauss,
/** Division-free elimination. This is a modification of Gauss
* elimination where the division by the pivot element is not
* carried out. If \f$m_{i,j}^{(0)}\f$ are the entries of the
* original matrix, then the matrix is transformed into triangular
* form by applying the rules
* \f[
* m_{i,j}^{(k+1)} = m_{i,j}^{(k)} m_{k,k}^{(k)} - m_{i,k}^{(k)} m_{k,j}^{(k)}
* \f]
* The determinant can later be computed by inspecting the diagonal
* elements only. This algorithm is only there for the purpose of
* cross-checks. It is never fast. */
divfree,
/** Laplace elimination. This is plain recursive elimination along
* minors although multiple minors are avoided by the algorithm.
* Although the algorithm is exponential in complexity it is
* frequently the fastest one when the matrix is populated by
* complicated symbolic expressions. */
laplace,
/** Bareiss fraction-free elimination. This is a modification of
* Gauss elimination where the division by the pivot element is
* delayed until it can be carried out without computing
* GCDs. If \f$m_{i,j}^{(0)}\f$ are the entries of the original
* matrix, then the matrix is transformed into triangular form by
* applying the rules
* \f[
* m_{i,j}^{(k+1)} = (m_{i,j}^{(k)} m_{k,k}^{(k)} - m_{i,k}^{(k)} m_{k,j}^{(k)}) / m_{k-1,k-1}^{(k-1)}
* \f]
* (We have set \f$m_{-1,-1}^{(-1)}=1\f$ in order to avoid a case
* distinction in above formula.) It can be shown that nothing more
* than polynomial long division is needed for carrying out the
* division. The determinant can then be read of from the lower
* right entry. This algorithm is rarely fast for computing
* determinants. */
bareiss
};
};
/** Switch to control algorithm for linear system solving. */
class solve_algo {
public:
enum {
/** Let the system choose. A heuristics is applied for automatic
* determination of a suitable algorithm. */
automatic,
/** Gauss elimination. If \f$m_{i,j}^{(0)}\f$ are the entries of the
* original matrix, then the matrix is transformed into triangular
* form by applying the rules
* \f[
* m_{i,j}^{(k+1)} = m_{i,j}^{(k)} - m_{i,k}^{(k)} m_{k,j}^{(k)} / m_{k,k}^{(k)}
* \f]
* This algorithm is well-suited for numerical matrices but generally
* suffers from the expensive division (and computation of GCDs) at
* each step. */
gauss,
/** Division-free elimination. This is a modification of Gauss
* elimination where the division by the pivot element is not
* carried out. If \f$m_{i,j}^{(0)}\f$ are the entries of the
* original matrix, then the matrix is transformed into triangular
* form by applying the rules
* \f[
* m_{i,j}^{(k+1)} = m_{i,j}^{(k)} m_{k,k}^{(k)} - m_{i,k}^{(k)} m_{k,j}^{(k)}
* \f]
* This algorithm is only there for the purpose of cross-checks.
* It suffers from exponential intermediate expression swell. Use it
* only for small systems. */
divfree,
/** Bareiss fraction-free elimination. This is a modification of
* Gauss elimination where the division by the pivot element is
* delayed until it can be carried out without computing
* GCDs. If \f$m_{i,j}^{(0)}\f$ are the entries of the original
* matrix, then the matrix is transformed into triangular form by
* applying the rules
* \f[
* m_{i,j}^{(k+1)} = (m_{i,j}^{(k)} m_{k,k}^{(k)} - m_{i,k}^{(k)} m_{k,j}^{(k)}) / m_{k-1,k-1}^{(k-1)}
* \f]
* (We have set \f$m_{-1,-1}^{(-1)}=1\f$ in order to avoid a case
* distinction in above formula.) It can be shown that nothing more
* than polynomial long division is needed for carrying out the
* division. This is generally the fastest algorithm for solving
* linear systems. In contrast to division-free elimination it only
* has a linear expression swell. For two-dimensional systems, the
* two algorithms are equivalent, however. */
bareiss,
/** Markowitz-ordered Gaussian elimination. Same as the usual
* Gaussian elimination, but with additional effort spent on
* selecting pivots that minimize fill-in. Faster than the
* methods above for large sparse matrices (particularly with
* symbolic coefficients), otherwise slightly slower than
* Gaussian elimination.
*/
markowitz
};
};
/** Flags to store information about the state of an object.
* @see basic::flags */
class status_flags {
public:
enum {
dynallocated = 0x0001, ///< heap-allocated (i.e. created by new if we want to be clever and bypass the stack, @see ex::construct_from_basic() )
evaluated = 0x0002, ///< .eval() has already done its job
expanded = 0x0004, ///< .expand(0) has already done its job (other expand() options ignore this flag)
hash_calculated = 0x0008, ///< .calchash() has already done its job
not_shareable = 0x0010, ///< don't share instances of this object between different expressions unless explicitly asked to (used by ex::compare())
has_indices = 0x0020,
has_no_indices = 0x0040, // ! (has_indices || has_no_indices) means "don't know"
is_positive = 0x0080,
is_negative = 0x0100,
purely_indefinite = 0x0200 // If set in a mul, then it does not contains any terms with determined signs, used in power::expand()
};
};
/** Possible attributes an object can have. */
class info_flags {
public:
enum {
// answered by class numeric, add, mul, function and symbols/constants in particular domains
numeric,
real,
rational,
integer,
crational,
cinteger,
positive,
negative,
nonnegative,
posint,
negint,
nonnegint,
even,
odd,
prime,
// answered by class relation
relation,
relation_equal,
relation_not_equal,
relation_less,
relation_less_or_equal,
relation_greater,
relation_greater_or_equal,
// answered by class symbol
symbol,
// answered by class lst
list,
// answered by class exprseq
exprseq,
// answered by classes numeric, symbol, add, mul, power
polynomial,
integer_polynomial,
cinteger_polynomial,
rational_polynomial,
crational_polynomial,
rational_function,
// answered by class indexed
indexed, // class can carry indices
has_indices, // object has at least one index
// answered by class idx
idx,
// answered by classes numeric, symbol, add, mul, power
expanded,
// is meaningful for mul only
indefinite
};
};
class return_types {
public:
enum {
commutative,
noncommutative,
noncommutative_composite
};
};
/** Strategies how to clean up the function remember cache.
* @see remember_table */
class remember_strategies {
public:
enum {
delete_never, ///< Let table grow undefinitely
delete_lru, ///< Least recently used
delete_lfu, ///< Least frequently used
delete_cyclic ///< First (oldest) one in list
};
};
/** Flags to control the polynomial factorization. */
class factor_options {
public:
enum {
polynomial = 0x0000, ///< factor only expressions that are polynomials
all = 0x0001 ///< factor all polynomial subexpressions
};
};
} // namespace GiNaC
#endif // ndef GINAC_FLAGS_H