constants.h

Go to the documentation of this file.

/*
 * GiNaCRA - GiNaC Real Algebra package
 * Copyright (C) 2010-2012  Ulrich Loup, Joachim Redies, Sebastian Junges
 *
 * This file is part of GiNaCRA.
 *
 * GiNaCRA 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 3 of the License, or
 * (at your option) any later version.
 *
 * GiNaCRA 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 GiNaCRA.  If not, see <http://www.gnu.org/licenses/>.
 *
 */


#ifndef GINACRA_CONSTANTS_H
#define GINACRA_CONSTANTS_H

#include <numeric> // provides accumulate(..)
#include <sstream>
#include <string>
#include <ginac/ginac.h>

using std::string;
using std::stringstream;
using std::binary_function;
using std::unary_function;
using std::vector;
using std::list;
using std::pair;
using GiNaC::basic;
using GiNaC::numeric;
using GiNaC::ex;

namespace GiNaC
{
    typedef struct infinitesimal_symbol_struct:
        public symbol
    {
        numeric limit_value;

        infinitesimal_symbol_struct():
            symbol(),
            limit_value( 0 )
        {}

        infinitesimal_symbol_struct( const std::string& name ):
            symbol( name ),
            limit_value( 0 )
        {}

        infinitesimal_symbol_struct( const std::string& name, const numeric& l ):
            symbol( name ),
            limit_value( l )
        {}

        const numeric limit()
        {
            return limit_value;
        }

    } infinitesimal_symbol;

    // infinitesimal elements: epsilon < delta < gamma < zeta
    const infinitesimal_symbol EPSILON( "€" );
    const infinitesimal_symbol DELTA( "ð" );
    const infinitesimal_symbol GAMMA( "đ" );
    const infinitesimal_symbol ZETA( "¢" );

    enum sign { NEGATIVE_SIGN = -1, ZERO_SIGN = 0, POSITIVE_SIGN = 1 };

    const symbol X( "X" );

    const numeric ZERO( 0 );

    struct ex_is_lessdeg:
        public binary_function<ex, ex, bool>
    {
        vector<symbol> variables;

        ex_is_lessdeg( const vector<symbol>& variables ):
            variables( variables )
        {}

        bool operator ()( const ex& a, const ex& b ) const
        {
            return true;
        }

        struct get_degree:
            public unary_function<symbol, int>
        {
            ex p;

            get_degree( const ex& q ):
                p( q )
            {}

            int operator ()( const symbol& x )
            {
                return p.degree( x );
            }
        };

        inline list<int> exponents( const ex& p, const vector<symbol>& variables ) const
        {
            int n = 0;
            for( vector<symbol>::const_iterator i = variables.begin(); i != variables.end(); ++i )
                n++;
            list<int> exponents( n, 0 );
            transform( variables.begin(), variables.end(), exponents.begin(), get_degree( p ));
            return exponents;
        }
    };

    struct ex_is_less_deggrlex:
        public ex_is_lessdeg
    {
        ex_is_less_deggrlex( const vector<symbol>& variables ):
            ex_is_lessdeg( variables )
        {}

        bool operator ()( const ex& a, const ex& b ) const
        {
            list<int> e1   = exponents( a, variables );
            list<int> e2   = exponents( b, variables );
            int       deg1 = accumulate( e1.begin(), e1.end(), 0 );
            int       deg2 = accumulate( e2.begin(), e2.end(), 0 );
            if( deg1 < deg2 )
                return true;
            else if( deg1 > deg2 )
                return false;
            else
                // return !lexicographical_compare(e1.begin(), e1.end(), e2.begin(), e2.end()); // for weak ordering!
                return lexicographical_compare( e2.begin(), e2.end(), e1.begin(), e1.end() );
        }
    };

    struct ex_is_less_degrevlex:
        public ex_is_lessdeg
    {
        ex_is_less_degrevlex( const vector<symbol>& variables ):
            ex_is_lessdeg( variables )
        {}

        bool operator ()( const ex& a, const ex& b ) const
        {
            list<int> e1   = exponents( a, variables );
            list<int> e2   = exponents( b, variables );
            int       deg1 = accumulate( e1.begin(), e1.end(), 0 );
            int       deg2 = accumulate( e2.begin(), e2.end(), 0 );
            if( deg1 < deg2 )
                return true;
            else if( deg1 > deg2 )
                return false;
            else
                //          return !lexicographical_compare(e1.rbegin(), e1.rend(), e2.rbegin(), e2.rend()); // for weak ordering!
                return lexicographical_compare( e2.rbegin(), e2.rend(), e1.rbegin(), e1.rend() );
        }
    };

    struct ex_is_under_the_staircase:
        public unary_function<ex, bool>
    {
        list<ex> corners;

        ex_is_under_the_staircase( const list<ex> corners ):
            corners( corners )
        {}

        bool operator ()( const ex& monomial ) const
        {
            for( list<ex>::const_iterator i = corners.begin(); i != corners.end(); ++i )
            {
                ex q = 0;
                if( divide( *i, monomial, q ))    // monomial divides *i by q
                    return true;
            }
            return false;
        }
    };

    template<class monomialOrdering>
    struct expair_is_lesseq:
        public binary_function<pair<ex, ex>, pair<ex, ex>, bool>
    {
        vector<symbol> variables;

        expair_is_lesseq( const vector<symbol>& variables ):
            variables( variables )
        {}

        bool operator ()( const pair<ex, ex>& a, const pair<ex, ex>& b ) const
        {
            return monomialOrdering( variables )( a.second, b.second );
        }

    };

}    // namespace GiNaC

#endif // GINACRA_CONSTANTS_H