libalgebra-demo/libalgebra/poly_basis.h

/* *************************************************************

Copyright 2010 Terry Lyons, Stephen Buckley, Djalil Chafai, 
Greg Gyurkó and Arend Janssen. 

Distributed under the terms of the GNU General Public License, 
Version 3. (See accompanying file License.txt)

************************************************************* */




//  poly_basis.h


// Include once wrapper
#ifndef DJC_COROPA_LIBALGEBRA_POLYBASISH_SEEN
#define DJC_COROPA_LIBALGEBRA_POLYBASISH_SEEN


template<typename SCA, typename RAT>
class poly_basis : public basis_traits<With_Degree>
{
public:
        typedef std::map<LET, DEG> KEY;
        const KEY empty_key;
        typedef RAT RATIONAL;
        struct KEY_LESS;
        typedef std::map<KEY, SCA, KEY_LESS> MAP;
        typedef poly<SCA, RAT> POLY;
public:
        poly_basis(void) {}
public:
        // tjl the code below is strange - 
        // the result of such an evaluation should be a scalar times a key of unevaluated variables
        inline SCA eval_key(const KEY& k, const std::map<LET, SCA>& values) const
        {
                SCA result(1);
                typename KEY::const_iterator it;
                for (it = k.begin(); it != k.end(); ++it)
                        if (it->second > 0)
                        {
                                typename std::map<LET, SCA>::const_iterator iit;
                                iit = values.find(it->first);
                                try
                                {       
                                        if (iit != values.end())
                                        {
                                                for (DEG j = 1; j <= it->second; ++j)
                                                        result *= iit->second;  
                                        }
                                        else
                                        {
                                                throw "not all variables have values!";
                                        }

                                }
                                catch (char* str)
                                {
                                        std::cerr << "Exception raised: " << str << '\n';
                                        abort();
                                }

                        }
                        

                return result;
        }
        inline static KEY prod2(const KEY& k1, const KEY& k2)
        {
                KEY k(k1);
                typename KEY::const_iterator it;
                for (it = k2.begin(); it != k2.end(); ++it)
                {
                        k[it->first] += it->second;
                }
                return k;
        }

        inline static POLY prod(const KEY& k1, const KEY& k2)
        {
                POLY result;
                result[prod2(k1, k2)] = ((SCA)+1);
                return result;
        }
        inline KEY keyofletter(LET letter) const
        {
                KEY result;
                result[letter] = +1;
                return result;
        }
        inline static DEG degree(const KEY& k)
        {
                DEG result (0);
                typename KEY::const_iterator it;
                for (it = k.begin(); it != k.end(); ++it)
                {
                        result += DEG(it->second);
                }
                return result;
        }
        
        struct  KEY_LESS
        {
                bool inline operator()(const KEY& lhs, const KEY& rhs) const
                {
                        return ((degree(lhs) < degree(rhs)) || ((degree(lhs) == degree(rhs)) && lhs < rhs));
                }
        };      

        
        inline KEY begin(void) const
        {
                return empty_key;
        }
        //inline KEY end(void) const
        //{
        //KEY result; // empty key.
        //result.push_back(0); // invalid key.
        //return result;
        //}
        //inline KEY nextkey(const KEY& k) const
        //{
        //KEY::size_type i;
        //for (i = k.size()-1; i >= 0; --i)
        //if (k[i]<n_letters) { KEY result(k); result[i] += 1; return result; }
        //return end();
        //}
        
        inline friend
                std::ostream& operator<<(std::ostream& os, const std::pair<poly_basis*, KEY>& t)
        {
                bool first(true);
                typename KEY::const_iterator it;
                for (it = t.second.begin(); it != t.second.end(); ++it)
                        if (it->second > 0)
                        {
                                if (!first)
                                        os << ' ';
                                else
                                        first = false;
                                os << "x" << it->first;
                                if (it->second > 1)
                                        os << '^' << it->second;
                        }
                return os;
        }
};

// Include once wrapper
#endif // DJC_COROPA_LIBALGEBRA_POLYBASISH_SEEN

//EOF.