RealAlgebraicNumberIR.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 GINAC_RA_INTERVALREPRESENTATION_H
#define GINAC_RA_INTERVALREPRESENTATION_H

// Optimization flags
#define GINACRA_INTERVALREPRESENTATION_OPT_NORMALIZE_POLYNOMIAL // call normalizePolynomial in the constructor

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

#include "settings.h"
#include "RationalUnivariatePolynomial.h"
#include "OpenInterval.h"
#include "RealAlgebraicNumber.h"
#include "operators.h"

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

        public:

            // Con- and destructors //

            //     RealAlgebraicNumberIR(const symbol& s) throw(invalid_argument); -> private

            //RealAlgebraicNumberIR( );

            RealAlgebraicNumberIR( const RationalUnivariatePolynomial& p,
                                   const OpenInterval& i,
                                   const list<RationalUnivariatePolynomial>& s = list<RationalUnivariatePolynomial>(),
                                   const bool normalize = true,
                                   const bool isRoot = true )
                    throw ( invalid_argument );

            ~RealAlgebraicNumberIR();

            RealAlgebraicNumberPtr clone() const;

            // Selectors //

            const RationalUnivariatePolynomial polynomial() const
            {
                return mPolynomial;
            }

            const OpenInterval interval() const
            {
                return mInterval;
            }

            const list<RationalUnivariatePolynomial> sturmSequence() const
            {
                return mSturmSequence;
            }

            const unsigned refinementCount() const
            {
                return mRefinementCount;
            }

            // Operators //

            // assignment operators

            const RealAlgebraicNumberIR& operator = ( const RealAlgebraicNumberIR& );

            // Operations //

            void normalizeInterval() throw ( invalid_argument );

            void refine( RealAlgebraicNumberSettings::RefinementStrategy strategy = RealAlgebraicNumberSettings::DEFAULT_REFINEMENTSTRATEGY );

            inline void refine( numeric eps )
            {
                while( mInterval.right() - mInterval.left() > eps )
                    this->refine();
            }

            bool refineAvoiding( numeric n );

            GiNaC::sign sgn() const;

            GiNaC::sign sgn( const RationalUnivariatePolynomial& p ) const;

            const numeric approximateValue() const
            {
                return mInterval.midpoint();
            }

            const numeric sampleValue() const
            {
                return mInterval.sample();
            }

            // Arithmetic Operations //

            RealAlgebraicNumberIR& add( RealAlgebraicNumberIR& o ) throw ( invalid_argument );

            RealAlgebraicNumberIR& minus() const;

            RealAlgebraicNumberIR& mul( RealAlgebraicNumberIR& o ) throw ( invalid_argument );

            RealAlgebraicNumberIR& inverse() const throw ( invalid_argument );

            RealAlgebraicNumberIR& pow( int e ) throw ( invalid_argument );

            // Relational Operations //

            const bool isEqual( RealAlgebraicNumberIR& o );

            const bool isLessWhileUnequal( RealAlgebraicNumberIR& o );

            const bool isLess( RealAlgebraicNumberIR& o );

            // Methods from basic //

            bool info( unsigned inf ) const;

            // Static Methods //

            static RealAlgebraicNumberIR* zero( const symbol& s );

        protected:

            // Methods from basic //

            bool is_equal_same_type( const basic& other ) const;

            void do_print( const print_context& c, unsigned level = 0 ) const;

            ex evalf( int level = 0 ) const;

            unsigned calchash() const;

        private:

            // Attributes //

            RationalUnivariatePolynomial mPolynomial;
            OpenInterval mInterval;
            list<RationalUnivariatePolynomial> mSturmSequence;
            unsigned mRefinementCount;

            // Con- and destructors //

            RealAlgebraicNumberIR( const symbol& s ) throw ( invalid_argument );
    };

    typedef std::tr1::shared_ptr<RealAlgebraicNumberIR> RealAlgebraicNumberIRPtr;

}    // namespace GiNaC

#endif