Polynomial.h

/* Copyright 2018 Kristofer Björnson
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
 
#ifndef COM_DAFER45_TBTK_POLYNOMIAL
#define COM_DAFER45_TBTK_POLYNOMIAL
 
#include "TBTK/TBTKMacros.h"
 
#include <complex>
#include <tuple>
#include <vector>
 
namespace TBTK{
 
template<
    typename FieldType = std::complex<double>,
    typename VariableType = std::complex<double>,
    typename PowerType = int
>
class Polynomial{
public:
    Polynomial(unsigned int numVariables);
 
    void addTerm(
        const FieldType &coefficient,
        const std::vector<PowerType> &powers
    );
 
    void addTerm(
        const FieldType &coefficient,
        const std::initializer_list<PowerType> &powers
    ){
        addTerm(coefficient, std::vector<PowerType>(powers));
    }
 
    void addTerm(const Polynomial &term, PowerType power);
 
    void addTerm(const Polynomial &lhs, const Polynomial &rhs);
 
 
    VariableType operator()(const std::vector<VariableType> &variable) const;
private:
    unsigned int numVariables;
 
    std::vector<std::tuple<FieldType, std::vector<PowerType>>> terms;
 
    std::vector<std::tuple<Polynomial, PowerType>> polynomialTerms;
 
    std::vector<std::tuple<Polynomial, Polynomial>> productTerms;
};
 
template<typename FieldType, typename VariableType, typename PowerType>
Polynomial<FieldType, VariableType, PowerType>::Polynomial(
    unsigned int numVariables
){
    this->numVariables = numVariables;
}
 
template<typename FieldType, typename VariableType, typename PowerType>
void Polynomial<FieldType, VariableType, PowerType>::addTerm(
    const FieldType &coefficient,
    const std::vector<PowerType> &powers
){
    TBTKAssert(
        powers.size() == numVariables,
        "Polynomial::addTerm()",
        "The number of powers '" << powers.size() << "' must be equal"
        << " to the number of variables '" << numVariables << "' in"
        << " the polynomial.",
        ""
    );
 
    terms.push_back(std::make_tuple(coefficient, powers));
}
 
template<typename FieldType, typename VariableType, typename PowerType>
void Polynomial<FieldType, VariableType, PowerType>::addTerm(
    const Polynomial &term,
    PowerType power
){
    TBTKAssert(
        term.numVariables == numVariables,
        "Polynomial::addTerm()",
        "The term has to have the same number of variables as the"
        << " total polynomial. The term has '" << term.numVariables
        << "' variables, while the Polynomial has '" << numVariables
        << "' variables.",
        ""
    );
 
    polynomialTerms.push_back(std::make_tuple(term, power));
}
 
template<typename FieldType, typename VariableType, typename PowerType>
void Polynomial<FieldType, VariableType, PowerType>::addTerm(
    const Polynomial &lhs,
    const Polynomial &rhs
){
    TBTKAssert(
        lhs.numVariables == numVariables,
        "Polynomial::addTerm()",
        "Incompatible number of variables. The left hand side is a"
        << " polynomial with '" << lhs.numVariables << "', while the"
        << " polynomial that the product is added to has '"
        << numVariables << "' variables. The number of variables must"
        << " be the same.",
        ""
    );
    TBTKAssert(
        rhs.numVariables == numVariables,
        "Polynomial::addTerm()",
        "Incompatible number of variables. The right hand side is a"
        << " polynomial with '" << rhs.numVariables << "', while the"
        << " polynomial that the product is added to has '"
        << numVariables << "' variables. The number of variables must"
        << " be the same.",
        ""
    );
 
    productTerms.push_back(std::make_tuple(lhs, rhs));
}
 
template<typename FieldType, typename VariableType, typename PowerType>
VariableType Polynomial<FieldType, VariableType, PowerType>::operator()(
    const std::vector<VariableType> &variables
) const{
    TBTKAssert(
        variables.size() == numVariables,
        "Polynomial::operator()",
        "The number of given variables are '" << variables.size()
        << "', but the polynomial has '" << numVariables << "'"
        << " variables.",
        ""
    );
 
    VariableType value = 0.;
    for(unsigned int n = 0; n < terms.size(); n++){
        VariableType term = std::get<0>(terms[n]);
        for(unsigned int c = 0; c < numVariables; c++){
            PowerType power = std::get<1>(terms[n])[c];
            if(power != 0)
                term *= pow(variables[c], power);
        }
 
        value += term;
    }
 
    for(unsigned int n = 0; n < polynomialTerms.size(); n++){
        VariableType term = pow(
            std::get<0>(polynomialTerms[n])(variables),
            std::get<1>(polynomialTerms[n])
        );
 
        value += term;
    }
 
    for(unsigned int n = 0; n < productTerms.size(); n++){
        const Polynomial &lhs = std::get<0>(productTerms[n]);
        const Polynomial &rhs = std::get<1>(productTerms[n]);
        VariableType term = lhs(variables)*rhs(variables);
 
        value += term;
    }
 
    return value;
}
 
}; //End of namespace TBTK
 
#endif