libalgebra-demo/libalgebra/multi_polynomial.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)

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




//multi_polynomial.h


#ifndef multi_polynomialH_SEEN
#define multi_polynomialH_SEEN


template<typename SCA, typename RAT, DEG n_letters, DEG max_degree>
class multi_polynomial : public algebra<free_monomial_basis<SCA, RAT, n_letters, max_degree> >
{
public:
        typedef free_monomial_basis<SCA, RAT, n_letters, max_degree> BASIS;
        typedef typename BASIS::KEY KEY;
        typedef sparse_vector<BASIS> VECT;
        typedef algebra<BASIS> ALG;
        typedef typename ALG::iterator iterator;
        typedef typename ALG::const_iterator const_iterator;
public:
        multi_polynomial(void) {}
        multi_polynomial(const multi_polynomial& t)
                : ALG(t) {}
        multi_polynomial(const ALG& a)
                : ALG(a) {}
        multi_polynomial(const VECT& v)
                : ALG(v) {}     
        multi_polynomial(LET letter, const SCA& s)
                : ALG(VECT::basis.keyofletter(letter), s) {}
        explicit multi_polynomial(const KEY& k)
                : ALG(k) {}
        explicit multi_polynomial(const SCA& s)
                : ALG(VECT::basis.empty_key, s) {}
public:
  inline __DECLARE_BINARY_OPERATOR(multi_polynomial,*,*=,SCA)
  inline __DECLARE_BINARY_OPERATOR(multi_polynomial,/,/=,RAT)
  inline __DECLARE_BINARY_OPERATOR(multi_polynomial,*,*=,multi_polynomial)
  inline __DECLARE_BINARY_OPERATOR(multi_polynomial,+,+=,multi_polynomial)
  inline __DECLARE_BINARY_OPERATOR(multi_polynomial,-,-=,multi_polynomial)
  inline __DECLARE_UNARY_OPERATOR(multi_polynomial,-,-,ALG)
        inline friend multi_polynomial exp(const multi_polynomial& arg)
        {
                // Computes the truncated exponential of arg
                // 1 + arg + arg^2/2! + ... + arg^n/n! where n = max_degree
                static KEY kunit;
                multi_polynomial result(kunit);
                for (DEG i = max_degree; i >= 1; --i)
                {
                        result.mul_scal_div(arg, (RAT)i);
                        result += (multi_polynomial)kunit;
                }
                return result;
        }
        inline friend multi_polynomial log(const multi_polynomial& arg)
        {
                // Computes the truncated log of arg up to degree max_degree
                // The coef. of the constant term (empty word in the monoid) of arg 
                // is forced to 1.
                // log(arg) = log(1+x) = x - x^2/2 + ... + (-1)^(n+1) x^n/n.
                // max_degree must be > 0
                static KEY kunit;
                multi_polynomial tunit(kunit);
                multi_polynomial x(arg);
                iterator it = x.find(kunit);
                if (it != x.end())
                        x.erase(it);
                multi_polynomial result;
                for (DEG i = max_degree; i >= 1; --i)
                {
                        if (i % 2 == 0)
                                result.sub_scal_div(tunit, (RAT)i);
                        else
                                result.add_scal_div(tunit, (RAT)i);
                        result *= x;
                }
                return result;
        }
};

// Include once wrapper
#endif // DJC_COROPA_LIBALGEBRA_TENSORH_SEEN

//EOF.