int k = 0;
    `MaxLocColumnWise(A,k)`;
    std::cout << k <<"n";

void MaxLocColumnWise(Matrix A, int &idx){
    int n = A.size();
    int col = idx;

    double currentAbsMax = abs(A[col][col]);

    for (int i=(col+1); i<n; i++){
        double currentVal = abs(A[i][col]);
        if (currentVal > currentAbsMax){
            currentAbsMax = currentVal;
            idx = i;
        }
    }
}

void GaussElimPartialPivot(Matrix& A, Vector& b){
    int n = A.size();

    for (int j=0; j<(n-1); j++){
        int index = j;
        MaxLocColumnWise(A, index);
        SwapMatrixRows(A, j, index);
        SwapVector(b, j, index);

        // main loop
        for (int i=(j+1); i<n; i++){
            double m = A[i][j]/A[j][j];
            b[i] -= m*b[j];
            for(int k=j; k<n; k++){
                A[i][k] -= m*A[j][k];
            }
        }
    }
}

int MaxLocColumnWise(const Matrix &A, int idx);

#ifndef GAUSS_H
#define GAUSS_H
#include <vector>
typedef std::vector<double> Vector;
typedef std::vector<Vector> Matrix;
std::size_t MaxLocColumnWise(const Matrix &A, std::size_t idx);
#endif // GAUSS_H

#include "Gauss.h"
#include <cmath>

std::size_t MaxLocColumnWise(const Matrix &A, std::size_t idx){
    auto maxIndex{idx};
    const auto col{idx};
    for (double maxValue{-1}; idx < A.size(); ++idx)  {
        auto currentVal{std::abs(A[idx][col])};
        if (currentVal > maxValue){
                maxValue = currentVal;
                maxIndex = idx;
        }
    }
    return maxIndex;
}

#include "Gauss.h"
#include <iostream>
#include <numeric>

int main() {
    constexpr size_t n{1000};
    Matrix m;
    m.reserve(n);
    int startval{1};
    for (size_t i{0}; i < n; ++i) {
        Vector v(n);
        std::iota(v.begin(), v.end(), startval);
        m.push_back(v);
        startval += n;
    }
    for (int i=0; i < n; ++i) {
        auto max{MaxLocColumnWise(m, i)};
        if (max != n-1) {
            std::cout << "Error:" << i << ", " << MaxLocColumnWise(m, i) << 'n';
        }
    }
}