#include <iostream>
#include <array>
#include <vector>
#include <concepts>


// abbreviated function template with constrained auto

constexpr size_t rows{4};
constexpr size_t columns{4};


auto Dot(auto& V, auto& B) {
        auto tmp {V[0]*B[0]};
        for (int i{1}; i < B.size(); i++)
                 tmp+= B[i] * V[i];
        return tmp;
}


void MatVecMul_auto(const auto& A, const auto & V, auto& B){
    if (A[0].size() == V.size() && A.size() == B.size() ){
     for (int i{0}; i < A.size(); i++)
        for (int j{0}; j < A[0].size(); j++)
             B[i]+= A[i][j] * V[j];
    }
    else{
        std::cout << "sizes are not compatible!";
    }
}



void MatVecMul(const std::array<std::array<int, columns>, rows>& A, const std::array<int,columns>& V, std::array<int,rows>& B);

template <typename T, long unsigned int N>
void MatVecMul_template(const std::array<std::array<T, N>, N>& A, const std::array<T,N>& V, std::array<T,N>& B);

template <typename T, typename U>
void MatVecMul_templatefull(const T& A, const U& V, U& B);

template <typename T>
void printArrayTemplate(const T& a);

int main() {
    std::array A{std::array{1, 2, 3}, std::array{4, 5, 6},std::array{4, 5, 0}};
    std::array V{1, 2, 3 };
    std::array <int,3> B{};
    MatVecMul_template(A, B, V);
    Dot(B,V);
   return 0;
}

void MatVecMul(const std::array<std::array<int, columns>, rows>& A, const std::array<int,columns>& V, std::array<int,rows>& B){
     for (int i{0}; i < A.size(); i++)
        for (int j{0}; j < A[0].size(); j++)
             B[i]+= A[i][j] * V[j];
}

template <typename T, long unsigned int N>
void MatVecMul_template(const std::array<std::array<T, N>, N>& A, const std::array<T,N>& V, std::array<T,N>& B){
     for (int i{0}; i < A.size(); i++)
        for (int j{0}; j < A[0].size(); j++)
             B[i]+= A[i][j] * V[j];
}

template <typename T>
void MatVecMul_template(const std::vector<std::vector<T>>& A, const std::vector<T>& V, std::vector<T>& B){
     for (int i{0}; i < A.size(); i++)
        for (int j{0}; j < A[0].size(); j++)
             B[i]+= A[i][j] * V[j];
}

template <typename T, typename U>
void MatVecMul_templatefull(const T& A, const U& V, U& B){
    if (A[0].size() == V.size() && A.size() == B.size() ){
     for (int i{0}; i < A.size(); i++)
        for (int j{0}; j < A[0].size(); j++)
             B[i]+= A[i][j] * V[j];
    }
    else{
        std::cout << "sizes are not compatible!";
    }
}