UnivariatePolynomial.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_UNIVARIATEPOLYNOMIAL_H
#define GINACRA_UNIVARIATEPOLYNOMIAL_H

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

#include "constants.h"
#include "Polynomial.h"

using std::ostream;
using std::invalid_argument;
using std::overflow_error;
using std::list;
using GiNaC::symbol;
using GiNaC::print_context;
using GiNaC::X;

namespace GiNaCRA
{
    class UnivariatePolynomial:
        public Polynomial
    {
        public:

            // Con- and destructors //

            UnivariatePolynomial():
                Polynomial( 0 ),
                mVariable( X ),
                mEnabledPolynomialCheck( false )
            {}

            UnivariatePolynomial( const numeric& n ):
                Polynomial( X - n ),
                mVariable( X ),
                mEnabledPolynomialCheck( false )
            {}

            UnivariatePolynomial( const ex& p, const symbol& s, bool enableCheck = true ) throw ( invalid_argument );

            UnivariatePolynomial( const UnivariatePolynomial& p ):
                Polynomial( p ),
                mVariable( p.mVariable ),
                mEnabledPolynomialCheck( p.mEnabledPolynomialCheck )
            {}

            // Selectors //

            const symbol variable() const
            {
                return mVariable;
            }

            const bool enabledPolynomialCheck() const
            {
                return mEnabledPolynomialCheck;
            }

            // Operators //

            UnivariatePolynomial inVariable( const symbol& x ) const
            {
                return UnivariatePolynomial( this->subs( mVariable == x ), x );
            }

            // assignment operators

            const UnivariatePolynomial& operator = ( const UnivariatePolynomial& );

            const UnivariatePolynomial& operator = ( const ex& );

            // Operations //

            ex coeff( int i ) const
            {
                return ex::coeff( mVariable, i );
            }

            ex lcoeff() const
            {
                return ex::lcoeff( mVariable );
            }

            ex tcoeff() const
            {
                return ex::tcoeff( mVariable );
            }

            ex content() const
            {
                return ex::content( mVariable );
            }

            UnivariatePolynomial diff( unsigned nth = 1 ) const
            {
                return UnivariatePolynomial( ex::diff( mVariable, nth ), mVariable, mEnabledPolynomialCheck );
            }

            UnivariatePolynomial trunc() const;

            bool isZero() const
            {
                return ex::is_zero();
            }

            const bool hasZeroRoot() const
            {
                return ldegree() > 0;
            }

            int degree() const
            {
                return ex::degree( mVariable );
            }

            int ldegree() const
            {
                return ex::ldegree( mVariable );
            }

            UnivariatePolynomial primpart() const
            {
                return UnivariatePolynomial( ex::primpart( mVariable ), mVariable, mEnabledPolynomialCheck );
            }

            UnivariatePolynomial primpart( const ex& content ) const
            {
                return UnivariatePolynomial( ex::primpart( mVariable, content ), mVariable, mEnabledPolynomialCheck );
            }

            UnivariatePolynomial sepapart() const;

            UnivariatePolynomial nonzeropart() const;

            bool isCompatible( const UnivariatePolynomial& o ) const
            {
                return mVariable == o.mVariable;
            }

            bool isConstant() const
            {
                return ex::degree( mVariable ) == 0;
            }

            ex evaluateAt( const ex& a ) const
            {
                return UnivariatePolynomial( ex::subs( mVariable == a ), mVariable );
            }

            // Arithmetic Operations //

            const UnivariatePolynomial rem( const UnivariatePolynomial& o ) const
            {
                return UnivariatePolynomial( GiNaC::rem( *this, o, mVariable ), mVariable );
            }

            const UnivariatePolynomial quo( const UnivariatePolynomial& o ) const
            {
                return UnivariatePolynomial( GiNaC::quo( *this, o, mVariable ), mVariable, mEnabledPolynomialCheck );
            }

            const UnivariatePolynomial add( const UnivariatePolynomial& o ) const
            {
                return UnivariatePolynomial( *this + o, mVariable, mEnabledPolynomialCheck );
            }

            const UnivariatePolynomial mul( const UnivariatePolynomial& o ) const
            {
                return UnivariatePolynomial( *this * o, mVariable, mEnabledPolynomialCheck );
            }

            const UnivariatePolynomial sub( const UnivariatePolynomial& o ) const
            {
                return UnivariatePolynomial( *this - o, mVariable, mEnabledPolynomialCheck );
            }

            UnivariatePolynomial square() const
            {
                return UnivariatePolynomial( (*this) * (*this), mVariable, mEnabledPolynomialCheck );
            }

            const UnivariatePolynomial gcd( const UnivariatePolynomial& o ) const
            {
                return UnivariatePolynomial( GiNaC::gcd( *this, o ), mVariable, mEnabledPolynomialCheck );
            }

            const UnivariatePolynomial resultant( const UnivariatePolynomial& o ) const
            {
                return UnivariatePolynomial( GiNaC::resultant( *this, o, mVariable ), mVariable );
                //                return UnivariatePolynomial::subresultants( *this, o ).front();
            }

            // Relational Operations //

            const bool isEqual( const UnivariatePolynomial& o ) const
            {
                return (this->is_equal( o ) && mVariable.is_equal( o.mVariable ));
            }

            // Static Methods //

            static list<UnivariatePolynomial> standardSturmSequence( const UnivariatePolynomial& a,
                                                                     const UnivariatePolynomial& b )
                    throw ( invalid_argument );

            static bool univariatePolynomialIsLess( const UnivariatePolynomial& a, const UnivariatePolynomial& b );

            static bool univariatePolynomialIsLessLowDeg( const UnivariatePolynomial& a, const UnivariatePolynomial& b );

            static bool univariatePolynomialIsLessOddDeg( const UnivariatePolynomial& a, const UnivariatePolynomial& b );

            static bool univariatePolynomialIsLessOddLowDeg( const UnivariatePolynomial& a, const UnivariatePolynomial& b );

            static bool univariatePolynomialIsLessEvenDeg( const UnivariatePolynomial& a, const UnivariatePolynomial& b );

            static bool univariatePolynomialIsLessEvenLowDeg( const UnivariatePolynomial& a, const UnivariatePolynomial& b );

            enum subresultantStrategy
            {
                GENERIC_SUBRESULTANTSTRATEGY = 0,    /* * Generic algorithm. */
                LAZARDS_SUBRESULTANTSTRATEGY = 1,    /* * Perform Lazard's optimization. */
                DUCOS_SUBRESULTANTSTRATEGY = 2,    /* * Perform Ducos' optimization. */
            };

            static const list<UnivariatePolynomial> subresultants( const UnivariatePolynomial& a,
                                                                   const UnivariatePolynomial& b,
                                                                   const subresultantStrategy strategy = GENERIC_SUBRESULTANTSTRATEGY );

            static const vector<ex> subresultantCoefficients( const UnivariatePolynomial& a,
                                                              const UnivariatePolynomial& b,
                                                              const subresultantStrategy strategy = GENERIC_SUBRESULTANTSTRATEGY );

            static const vector<ex> principalSubresultantCoefficients( const UnivariatePolynomial& a,
                                                                       const UnivariatePolynomial& b,
                                                                       const subresultantStrategy strategy = GENERIC_SUBRESULTANTSTRATEGY );

            // Methods from ex //

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

        protected:

            // Attributes //

            symbol mVariable;    // the main variable of the univariate polynomial (only changed by using operator=)
            bool   mEnabledPolynomialCheck;    // flag to disable (when set to false) the is_polynomial check in the constructors in every method of this object

        private:

            // Auxiliary Methods //

    };    // class UnivariatePolynomial

}    // namespace GiNaC

#endif