TwoPolynomial.h

Go to the documentation of this file.

/*
 *  Copyright (c) 2018, Martin Duy Tat
 *  All rights reserved.
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright notice,
 *     this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright notice,
 *     this list of conditions and the following disclaimer in the documentation
 *     and/or other materials provided with the distribution.
 *  3. Neither the name of STFC nor the names of its contributors may be used to
 *     endorse or promote products derived from this software without specific
 *     prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef TWO_POLYNOMIAL_H
#define TWO_POLYNOMIAL_H

#include <vector>

namespace polynomial {

struct vectorLengths {
    std::size_t nx;
    std::size_t ny;
    std::size_t nx1;
    std::size_t ny1;
    std::size_t nx2;
    std::size_t ny2;
};

class TwoPolynomial {
public:
    TwoPolynomial();
    explicit TwoPolynomial(const std::vector<std::vector<int>> &coefficients);
    TwoPolynomial(const TwoPolynomial &poly);
    TwoPolynomial& operator= (const TwoPolynomial &poly);
    ~TwoPolynomial();
    void differentiateX();
    void differentiateS();
    void multiplyConstant (const int &constant);
    void multiplydSfactors(const TwoPolynomial &poly);
    void convert2Dto1Darray(double *vec1, double *vec2,
                            const vectorLengths &nn,
                            const TwoPolynomial &poly) const;
    void convolution(double *vec1, double *vec2,
                     const std::size_t &nx, const std::size_t &ny) const;
    void convert1Dto2Darray(double *vec1, const vectorLengths &nn);
    void multiplyPolynomial(const TwoPolynomial &poly);
    void printPolynomial() const;
    int getCoefficient(const std::size_t &Xorder,
                       const std::size_t &Sorder) const;
    void setCoefficient(const int &coefficient,
                        const std::size_t &Xorder,
                        const std::size_t &Sorder);
    std::size_t getMaxXorder() const;
    std::size_t getMaxSorder() const;
    void setMaxXorder(const std::size_t &maxXorder);
    void setMaxSorder(const std::size_t &maxSorder);
    std::size_t getNdSfactors() const;
    std::vector<std::size_t> getdSfactors() const;
    void setdSfactors(const std::vector<std::size_t> &dSfactors);
    void setZero();
    bool isZero() const;
    double evaluatePolynomial(const double &x, const double &s) const;
    void truncate(const std::size_t &truncateOrder);
    void addPolynomial(const TwoPolynomial &poly);
    friend bool operator < (const TwoPolynomial &left,
                            const TwoPolynomial &right);
    friend bool operator == (const TwoPolynomial &left,
                             const TwoPolynomial &right);
    friend class PolynomialSum;
private:
    std::size_t maxXorder_m;
    std::size_t maxSorder_m;
    std::vector<std::vector<int>> coefficients_m;
    std::vector<std::size_t> dSfactors_m;
};

inline
    std::size_t TwoPolynomial::getMaxXorder() const {
        return maxXorder_m;
}
inline
    std::size_t TwoPolynomial::getMaxSorder() const {
        return maxSorder_m;
}
inline
    std::size_t TwoPolynomial::getNdSfactors() const {
        return dSfactors_m.size();
}
inline
    std::vector<std::size_t> TwoPolynomial::getdSfactors() const {
        return dSfactors_m;
}
inline
    void TwoPolynomial::setdSfactors(
                        const std::vector<std::size_t> &dSfactors) {
        dSfactors_m = dSfactors;
}
inline
    bool TwoPolynomial::isZero() const {
        return (maxXorder_m == 0 && maxSorder_m == 0 &&
                coefficients_m[0][0] == 0);
}
inline
    void TwoPolynomial::truncate(const std::size_t &truncateOrder) {
        if (truncateOrder < maxXorder_m) {
            coefficients_m.resize(truncateOrder + 1);
            maxXorder_m = truncateOrder;
        }
}

}

#endif