OpenInterval.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_OPENINTERVAL_H
#define GINACRA_OPENINTERVAL_H

#include <ginac/ginac.h>
#include <stdexcept>

#include "settings.h"

namespace GiNaCRA
{
    using GiNaC::basic;
    using GiNaC::numeric;
    using GiNaC::ex;
    using GiNaC::print_context;
    using GiNaC::status_flags;

    // Typedefs //

    class OpenInterval;
    typedef std::map<GiNaC::symbol, OpenInterval, GiNaC::ex_is_less> evalintervalmap;

    class OpenInterval:
        public basic
    {
        // Call GiNaC macro (registrar.h) for initiating the implementation into the basic type.
        GINAC_DECLARE_REGISTERED_CLASS(OpenInterval, basic)

        public:

            // Con- and destructors //

            OpenInterval( const numeric& n );

            OpenInterval( const numeric& l, const numeric& r ) throw ( std::invalid_argument );

            OpenInterval( const OpenInterval& i );

            ~OpenInterval();

            // Selectors //

            void setLeft( const numeric& l ) throw ( std::invalid_argument );

            void setRight( const numeric& r ) throw ( std::invalid_argument );

            const numeric left() const;

            const numeric right() const;

            // Operations //

            const bool isZero() const;

            const bool isNormalized() const;

            const bool contains( const numeric& n ) const;

            const bool contains( const OpenInterval& o ) const;

            const bool meets( const numeric& n ) const;

            const OpenInterval intersection( const OpenInterval& o ) const;

            const numeric midpoint() const;

            const numeric sample() const;

            const numeric sampleFast() const
            {
                return (mLeft.numer() < RealAlgebraicNumberSettings::MAX_FASTSAMPLE_BOUND
                        && mRight.numer() < RealAlgebraicNumberSettings::MAX_FASTSAMPLE_BOUND
                        && mLeft.denom() < RealAlgebraicNumberSettings::MAX_FASTSAMPLE_BOUND
                        && mRight.denom() < RealAlgebraicNumberSettings::MAX_FASTSAMPLE_BOUND) ? sample() : midpoint();
            }

            const OpenInterval abs() const;

            // Arithmetic Operations //

            const OpenInterval add( const OpenInterval& o ) const;

            const OpenInterval minus() const;

            const OpenInterval mul( const OpenInterval& o ) const;

            const OpenInterval div( const OpenInterval& o ) const throw ( std::invalid_argument );

            const OpenInterval pow( unsigned e ) const;

            static OpenInterval evaluate( const ex& p, evalintervalmap m ) throw ( std::invalid_argument );

            // Relational Operations //

            const bool isEqual( const OpenInterval& o ) const;

            const bool isLess( const OpenInterval& o ) const;

            const bool isGreater( const OpenInterval& o ) const;

        protected:

            // Methods from basic  //

            bool is_equal_same_type( const basic& ) const;
            void do_print( const print_context&, unsigned level = 0 ) const;
            ex evalf( int level = 0 ) const;
            unsigned calchash() const;

        private:

            // Attributes //

            numeric mLeft;    // pointer to the left bound of the interval (pointer is fixed, value not)
            numeric mRight;    // pointer to the right bound of the interval (pointer is fixed, value not)

            // AUXILIARY FUNCTIONS //

            inline static const numeric findSample( cln::cl_I numeratorL, cln::cl_I denominatorL, cln::cl_I numeratorR, cln::cl_I denominatorR );

            inline static const numeric findSample( long numeratorL, long denominatorL, long numeratorR, long denominatorR );

    };    // class OpenInterval

}    // namespace GiNaC

#endif