Polynomials.hpp

Go to the documentation of this file.

#pragma once
#include "General.hpp"
#include "impl/Details.ipp"
#include <map>
#include <unordered_map>
#include <string>
#include <iostream>
 
 
namespace symmp
{
    template <class exp_t>
    class BaseContainer {
        typedef typename exp_t::deg_t deg_t;
    protected:
 
        BaseContainer(const deg_t* dimensions = nullptr);
 
        deg_t compute_degree(const exp_t& exponent) const;
 
        const deg_t* dimensions;    
    };
 
    template <class _scl, class _exp, template<class...> class _cnt, bool _ord, class ... _arg>
    class DefaultContainer : public BaseContainer<_exp>, implementation_details::container_wrapper<_scl, _exp, _cnt, _ord, _arg...> {
    private:
        typedef typename implementation_details::container_wrapper<_scl, _exp, _cnt, _ord, _arg...> data_t;
    protected:
        typedef _scl scl_t;                 
        typedef _exp exp_t;                 
        typedef typename _exp::deg_t deg_t; 
    public:
        size_t number_of_monomials() const;
 
        bool operator==(const DefaultContainer&) const;
 
        bool operator!=(const DefaultContainer& b) const;
 
        void reserve(size_t n);
 
        void insert(const exp_t& exp, scl_t coeff);
 
        class ConstIterator : public data_t::const_iterator {
        public:
            scl_t coeff() const;            
            const exp_t& exponent() const;  
            deg_t degree() const;           
        private:
            ConstIterator(typename data_t::const_iterator);
            friend class DefaultContainer; 
        };
        ConstIterator begin() const;    
        ConstIterator end() const;      
 
        ConstIterator highest_term() const;
 
    protected:
        using BaseContainer<exp_t>::BaseContainer;
        class Iterator : public data_t::iterator {
        public:
            scl_t& coeff(); 
        private:
            Iterator(typename data_t::iterator);
            friend class DefaultContainer; 
        };
 
        Iterator begin();   
        Iterator end();     
 
        void add(const std::pair<const std::pair<deg_t, exp_t>, scl_t>& kvp);
 
        void subtract(const std::pair<const std::pair<deg_t, exp_t>, scl_t>& kvp);
 
        void multiply_add(const std::pair<const std::pair<deg_t, exp_t>, scl_t >& kvp1, const std::pair<const std::pair <deg_t, exp_t>, scl_t >& kvp2);
    private:
        void add(const std::pair<deg_t, exp_t> key, scl_t value);
    };
 
 
    template <typename container_t>
    class Polynomial : public container_t
    {
    public:
        typedef typename container_t::scl_t scl_t;  
        typedef typename container_t::exp_t exp_t;  
        typedef typename container_t::deg_t deg_t;  
 
        Polynomial(const deg_t* dim_var = nullptr, const std::string* name_var = nullptr);
 
        Polynomial(const exp_t& exp, scl_t coeff, const deg_t* dim_var = nullptr, const std::string* name_var = nullptr);
 
        Polynomial(int num_var, scl_t coeff, const deg_t* dim_var = nullptr, const std::string* name_var = nullptr);
 
        size_t number_of_variables() const;
 
        Polynomial& operator+=(const Polynomial& other);
 
        Polynomial& operator-=(const Polynomial& other);
 
        Polynomial& operator*=(const Polynomial& other);
 
        Polynomial& operator*=(scl_t scalar);
 
        Polynomial operator+(const Polynomial& other) const;
 
        Polynomial operator-(const Polynomial& other) const;
 
        Polynomial operator*(const Polynomial& other) const;
 
        template <class T = int>
        Polynomial operator^(T p) const;
 
    private:
        const std::string* variable_names; //if exp_t does not have the appropriate method
        template <class fun>
        void print(scl_t, const exp_t&, std::ostream&, const fun&) const; //Print monomial using given variable names
        template <class fun>
        void print(std::ostream& os, const fun&) const; //Print polynomial using given variable names
        template<class cont>
        friend std::ostream& operator<< (std::ostream&, const Polynomial<cont>&); 
    };
 
    template <class container_t>
    std::ostream& operator<<(std::ostream& os, const Polynomial<container_t>& a);
 
    template <class _scl, class _exp, bool _ord = 1>
    using Poly = Polynomial<std::conditional_t<_ord, DefaultContainer<_scl, _exp, std::map, 1>, DefaultContainer<_scl, _exp, std::unordered_map, 0>>>;
 
}
#include "impl/Polynomials.ipp"