polyold.h

#ifndef POLY_H_
#define POLY_H_

#include <cstddef>
#include <array>
#include <type_traits>
#include <utility>
#include <tuple>

template<typename T, std::size_t N = 0>
class poly;

template<typename T>
poly(T) -> poly<T, 1>;

template<typename T, typename... Args>
poly(T, Args...) -> poly<T, sizeof...(Args) + 1>;

template<typename T, std::size_t N>
class poly {
public:
    // Constructors
    constexpr poly() : coefficients{} {}

    template<typename U, std::size_t M, typename = std::enable_if_t<(M <= N) && std::is_convertible_v<U, T>>>
    constexpr poly(const poly<U, M>& other) {
        for (std::size_t i = 0; i < M; ++i) {
            coefficients[i] = other[i];
        }
    }

    template<typename U, std::size_t M, typename = std::enable_if_t<(M <= N) && std::is_convertible_v<U, T>>>
    constexpr poly(poly<U, M>&& other) {     
        for (std::size_t i = 0; i < M; ++i) {
            coefficients[i] = std::move(other[i]);
        }
    }

    template<typename U, typename = std::enable_if_t<std::is_convertible_v<U, T>>>
    constexpr poly(U&& value) {
        coefficients[0] = std::forward<U>(value);
    }

    template<typename... Args, typename = std::enable_if_t<(sizeof...(Args) <= N) && (std::conjunction_v<std::is_convertible<Args, T>...>)>>
    constexpr poly(Args&&... args) : coefficients{std::forward<Args>(args)...} {}

    // Assignment operators
    template<typename U, std::size_t M, typename = std::enable_if_t<(M <= N) && std::is_convertible_v<U, T>>>
    constexpr poly& operator=(const poly<U, M>& other) {
        if (this != &other) {
            for (std::size_t i = 0; i < M; ++i) {
                coefficients[i] = other[i];
            }
        }
        return *this;
    }

    template<typename U, std::size_t M, typename = std::enable_if_t<(M <= N) && std::is_convertible_v<U, T>>>
    constexpr poly& operator=(poly<U, M>&& other) {
        if (this != &other) {
            for (std::size_t i = 0; i < M; ++i) {
                coefficients[i] = std::move(other[i]);
            }
        }
        return *this;
    }

    // Compound assignment operators
    template<typename U, std::size_t M, typename = std::enable_if_t<(M <= N) && std::is_convertible_v<U, T>>>
    constexpr poly& operator+=(const poly<U, M>& other) {
        for (std::size_t i = 0; i < M; ++i) {
            coefficients[i] += other[i];
        }
        return *this;
    }

    template<typename U, typename = std::enable_if_t<std::is_convertible_v<U, T>>>
    constexpr poly& operator+=(const U& value) {
        coefficients[0] += value;
        return *this;
    }

    template<typename U, std::size_t M, typename = std::enable_if_t<(M <= N) && std::is_convertible_v<U, T>>>
    constexpr poly& operator-=(const poly<U, M>& other) {
        for (std::size_t i = 0; i < M; ++i) {
            coefficients[i] -= other[i];
        }
        return *this;
    }

    template<typename U, typename = std::enable_if_t<std::is_convertible_v<U, T>>>
    constexpr poly& operator-=(const U& value) {
        coefficients[0] -= value;
        return *this;
    }

    template<typename U, typename = std::enable_if_t<std::is_convertible_v<U, T>>>
    constexpr poly& operator*=(const U& value) {
        for (auto& coeff : coefficients) {
            coeff *= value;
        }
        return *this;
    }

    template<typename U, std::size_t M, typename = std::enable_if_t<std::is_convertible_v<U, T>>>
    constexpr poly& operator*=(const poly<U, M>& other) {
        *this = *this * other;
        return *this;
    }

    // Indexing operator
    constexpr T& operator[](std::size_t index) {
        return coefficients[index];
    }

    constexpr const T& operator[](std::size_t index) const {
        return coefficients[index];
    }

    // Metoda at.
    template<typename... Args>
    constexpr auto at(Args &&... args) const {
        if constexpr (sizeof...(Args) == 0) {
            return *this;
        } else {
            auto result = T(); //TODO dlaczego dajemy wszystkie argumenty rekurencyjnie?
            for (std::size_t i = 0; i < N; ++i) {
                result = result * std::get<0>(std::forward_as_tuple(args...)) + coefficients[i];
            }
            return result.at(std::forward<Args>(args)...);
        }
    }

    template<typename U, std::size_t K>
    constexpr auto at(const std::array<U, K> &arr) const {
        if constexpr (K == 0) {
            return *this;
        } else {
            auto result = T();
            for (std::size_t i = 0; i < N; ++i) {
                result = result * arr[0] + coefficients[i];
            }
            std::array<U, K - 1> sub_arr;
            std::copy(arr.begin() + 1, arr.end(), sub_arr.begin());
            return result.at(sub_arr);
        }
    }

    // Size method
    constexpr std::size_t size() const {
        return N;
    }

private:
    std::array<T, N> coefficients;
};

// Common type
namespace std {
    template<typename T1, std::size_t N1, typename T2>
    struct common_type<T1, poly<T2, N1> > {
        using type = poly<std::common_type_t<T1, T2>, N1>;
    };

    template<typename T1, typename T2, std::size_t N2>
    struct common_type<poly<T1, N2>, T2> {
        using type = poly<std::common_type_t<T1, T2>, N2>;
    };

    template<typename T1, std::size_t N1, typename T2, std::size_t N2>
    struct common_type<poly<T1, N1>, poly<T2, N2> > {
        using type = poly<std::common_type_t<T1, T2>, (N1 > N2 ? N1 : N2)>;
    };
}

// Funkcja cross
template<typename T1, std::size_t N1, typename T2, std::size_t N2>
auto constexpr cross(const poly<T1, N1> &p, const poly<T2, N2> &q) {
    using ResultType = std::common_type_t<T1, T2>;
    poly<ResultType, N1 + N2> result;

    for (std::size_t i = 0; i < N1; ++i) {
        for (std::size_t j = 0; j < N2; ++j) {
            result[i + j] += p[i] * q[j];
        }
    }

    return result;
}

template<typename T, std::size_t N>
poly<poly<T, N>, 1> constexpr const_poly(const poly<T, N> &p) {
    return poly<poly<T, N>, 1>{p};
}

// Binarne (+,-,*)

template<typename T, std::size_t N, typename U>
constexpr auto operator+(const poly<T, N> &lhs, const U &rhs) {
    using ResultType = std::common_type_t<T, U>;
    poly<ResultType, N> result = lhs;
    result += rhs;
    return result;
}

template<typename T, typename U, std::size_t M>
constexpr auto operator+(const T &lhs, const poly<U, M> &rhs) {
    using ResultType = std::common_type_t<T, U>;
    poly<ResultType, M> result = rhs;
    result += lhs;
    return result;
}

template<typename T, std::size_t N, typename U, std::size_t M>
constexpr auto operator+(const poly<T, N> &lhs, const poly<U, M> &rhs) {
    using ResultType = std::common_type_t<T, U>;
    constexpr std::size_t ResultSize = (N > M) ? N : M;
    poly<ResultType, ResultSize> result;

    for (std::size_t i = 0; i < N; ++i) {
        result[i] += lhs[i];
    }
    for (std::size_t i = 0; i < M; ++i) {
        result[i] += rhs[i];
    }

    return result;
}

template<typename T, std::size_t N, typename U>
constexpr auto operator-(const poly<T, N> &lhs, const U &rhs) {
    using ResultType = std::common_type_t<T, U>;
    poly<ResultType, N> result = lhs;
    result -= rhs;
    return result;
}

template<typename T, typename U, std::size_t M>
constexpr auto operator-(const T &lhs, const poly<U, M> &rhs) {
    using ResultType = std::common_type_t<T, U>;
    poly<ResultType, M> result = -rhs;
    result += lhs;
    return result;
}

template<typename T, std::size_t N, typename U, std::size_t M>
constexpr auto operator-(const poly<T, N> &lhs, const poly<U, M> &rhs) {
    using ResultType = std::common_type_t<T, U>;
    constexpr std::size_t ResultSize = (N > M) ? N : M;
    poly<ResultType, ResultSize> result;

    for (std::size_t i = 0; i < N; ++i) {
        result[i] += lhs[i];
    }
    for (std::size_t i = 0; i < M; ++i) {
        result[i] -= rhs[i];
    }

    return result;
}

template<typename T, std::size_t N, typename U>
constexpr auto operator*(const poly<T, N> &lhs, const U &rhs) {
    using ResultType = std::common_type_t<T, U>;
    poly<ResultType, N> result = lhs;
    result *= rhs;
    return result;
}

template<typename T, typename U, std::size_t M>
constexpr auto operator*(const T &lhs, const poly<U, M> &rhs) {
    using ResultType = std::common_type_t<T, U>;
    poly<ResultType, M> result = rhs;
    result *= lhs;
    return result;
}

template<typename T, std::size_t N, typename U, std::size_t M>
constexpr auto operator*(const poly<T, N> &lhs, const poly<U, M> &rhs) {
    using ResultType = std::common_type_t<T, U>;
    constexpr std::size_t ResultSize = (N + M > 0) ? (N + M - 1) : 0;
    poly<ResultType, ResultSize> result;

    for (std::size_t i = 0; i < N; ++i) {
        for (std::size_t j = 0; j < M; ++j) {
            result[i + j] += lhs[i] * rhs[j];
        }
    }

    return result;
}

// Jednoargumentowy (-)
template<typename T, std::size_t N>
constexpr poly<T, N> operator-(const poly<T, N> &p) {
    poly<T, N> result;
    for (std::size_t i = 0; i < N; ++i) {
        result[i] = -p[i];
    }
    return result;
}
#endif // POLY_H_