flags.h

Go to the documentation of this file.

 
/*
 *  GiNaC Copyright (C) 1999-2026 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, see <https://www.gnu.org/licenses/>.
 */
 
#ifndef GINAC_FLAGS_H
#define GINAC_FLAGS_H
 
namespace GiNaC {
 
class expand_options {
public:
    enum {
        expand_indexed = 0x0001,      
        expand_function_args = 0x0002, 
        expand_rename_idx = 0x0004, 
        expand_transcendental = 0x0008 
    };
};
 
class has_options {
public:
    enum {
        algebraic = 0x0001              
    };
};
 
class subs_options {
public:
    enum {
        no_pattern = 0x0001,             
        subs_no_pattern = 0x0001, // for backwards compatibility
        algebraic = 0x0002,              
        subs_algebraic = 0x0002,  // for backwards compatibility
        pattern_is_product = 0x0004,     
        pattern_is_not_product = 0x0008, 
        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
    };
};
 
class domain {
public:
    enum {
        complex,
        real,
        positive
    };
};
 
class series_options {
public:
    enum {
        suppress_branchcut = 0x0001
    };
};
 
class determinant_algo {
public:
    enum {
        automatic,
        gauss,
        divfree,
        laplace,
        bareiss
    };
};
 
class solve_algo {
public:
    enum {
        automatic,
        gauss,
        divfree,
        bareiss,
        markowitz
    };
};
 
class status_flags {
public:
    enum {
        dynallocated    = 0x0001, 
        evaluated       = 0x0002, 
        expanded        = 0x0004, 
        hash_calculated = 0x0008, 
        not_shareable   = 0x0010, 
        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()
    };
};
 
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
    };
};
 
class remember_strategies {
public:
    enum {
        delete_never,   
        delete_lru,     
        delete_lfu,     
        delete_cyclic   
    };
};
 
class factor_options {
public:
    enum {
        polynomial = 0x0000, 
        all        = 0x0001  
    };
};
 
} // namespace GiNaC
 
#endif // ndef GINAC_FLAGS_H