xmake run 会报错 failed(-1073740940)，但是直接运行可执行文件不会。

[luyiyun]

xmake版本：xmake v2.9.8+HEAD.13fc39238
问题描述：xmake编译后，xmake r运行可执行文件会报错：error: execv(C:\Users\admin\Documents\linalg-cpp\build\windows\x64\release\linalg-cpp.exe ) failed(-1073740940)
但是如果我直接运行可执行文件：./build/windows/x64/release/linalg-cpp.exe则不会报这个错误。

下面是代码：
xmake.lua

add_rules("mode.debug", "mode.release")
set_languages("c++20")
set_toolchains("clang-cl")

target("linalg-cpp")
  set_warnings("all", "error")
  set_kind("binary")
  add_files("src/*.cpp")

main.cpp

#include "linear_regression.h"
#include "matrix.h"

int main() {
  int n = 10;
  int m = 2;

  auto X = Matrix::random(n, m);
  auto theta = Matrix::random(m, 1);
  theta.print();
  auto Y = X.matmul(theta);
  auto eps = Matrix::random_normal(n, 1, 0.0, 0.01);
  // eps.print();
  Y.add_(eps);

  auto lr = LinearRegression();
  lr.fit(X, Y);
  return 0;
}

matrix.h

#ifndef MATRIX_H
#define MATRIX_H

class Matrix {
public:
  Matrix() = default;
  Matrix(int rows, int cols);
  Matrix(const Matrix &other);
  // Matrix &operator=(const Matrix &other);
  ~Matrix();

  static Matrix identity(int size);
  static Matrix zeros(int rows, int cols);
  static Matrix random(int rows, int cols, double min = 0.0, double max = 1.0);
  static Matrix random_normal(int rows, int cols, double mean = 0.0,
                              double stddev = 1.0);

  int rows() const { return rows_; };
  int cols() const { return cols_; };

  void set(int row, int col, double value) {
    data_[row * cols_ + col] = value;
  };
  double get(int row, int col) const { return data_[row * cols_ + col]; }
  Matrix slice(int start_row = 0, int end_row = 0, int start_col = 0,
               int end_col = 0) const;

  Matrix transpose() const;
  Matrix add(const Matrix &other) const;
  void add_(const Matrix &other);
  Matrix matmul(const Matrix &other) const;
  // double &operator()(int row, int col);
  // const double &operator()(int row, int col) const;

  Matrix inverse() const;

  void print() const;

private:
  int rows_;
  int cols_;
  double *data_ = nullptr;
};
#endif // MATRIX_H

matrix.cpp

#include "matrix.h"
#include <iomanip>
#include <iostream>
#include <random>

double uniformSample(double a, double b) {
  static std::random_device rd;
  static std::mt19937 gen(rd());
  static std::uniform_real_distribution<> dis(a, b);
  return dis(gen);
}

double normalSample(double mean, double stddev) {
  static std::random_device rd;
  static std::mt19937 gen(rd());
  static std::normal_distribution<> dis(mean, stddev);
  return dis(gen);
}

Matrix::Matrix(int rows, int cols) : rows_(rows), cols_(cols) {
  data_ = new double[rows * cols];
}

Matrix::Matrix(const Matrix &other) {
  rows_ = other.rows_;
  cols_ = other.cols_;
  data_ = new double[rows_ * cols_];
  for (int i = 0; i < rows_ * cols_; i++) {
    data_[i] = other.data_[i];
  }
}

Matrix::~Matrix() { delete[] data_; }

void Matrix::print() const {
  for (int i = 0; i < rows_; i++) {
    for (int j = 0; j < cols_; j++) {
      std::cout << std::fixed << std::setprecision(3) << data_[i * cols_ + j]
                << " ";
    }
    std::cout << std::endl;
  }
}

Matrix Matrix::identity(int size) {
  Matrix result(size, size);
  for (int i = 0; i < size; i++) {
    result.data_[i * size + i] = 1;
  }
  return result;
}

Matrix Matrix::zeros(int rows, int cols) {
  Matrix result(rows, cols);
  for (int i = 0; i < rows * cols; i++) {
    result.data_[i] = 0;
  }
  return result;
}

Matrix Matrix::random(int rows, int cols, double min, double max) {
  Matrix result(rows, cols);
  for (int i = 0; i < rows * cols; i++) {
    result.data_[i] = uniformSample(min, max);
  }
  return result;
}

Matrix Matrix::random_normal(int rows, int cols, double mean, double stddev) {
  Matrix result(rows, cols);
  std::normal_distribution<double> dist(mean, stddev);
  for (int i = 0; i < rows * cols; i++) {
    result.data_[i] = normalSample(mean, stddev);
  }
  return result;
}

Matrix Matrix::transpose() const {
  Matrix result(cols_, rows_);
  for (int i = 0; i < rows_; i++) {
    for (int j = 0; j < cols_; j++) {
      result.data_[j * rows_ + i] = data_[i * cols_ + j];
    }
  }
  return result;
}

Matrix Matrix::matmul(const Matrix &other) const {
  if (cols_ != other.rows_) {
    throw std::invalid_argument(
        "Matrix dimensions do not match for multiplication");
  }
  Matrix result(rows_, other.cols_);
  for (int i = 0; i < rows_; i++) {
    for (int j = 0; j < other.cols_; j++) {
      double sum = 0;
      for (int k = 0; k < cols_; k++) {
        sum += data_[i * cols_ + k] * other.data_[k * other.cols_ + j];
      }
      result.data_[i * other.cols_ + j] = sum;
    }
  }
  return result;
}

Matrix Matrix::add(const Matrix &other) const {
  if (rows_ != other.rows_ || cols_ != other.cols_) {
    throw std::invalid_argument("Matrix dimensions do not match for addition");
  }
  Matrix result(rows_, cols_);
  for (int i = 0; i < rows_ * cols_; i++) {
    result.data_[i] = data_[i] + other.data_[i];
  }
  return result;
}

void Matrix::add_(const Matrix &other) {
  if (rows_ != other.rows_ || cols_ != other.cols_) {
    throw std::invalid_argument("Matrix dimensions do not match for addition");
  }
  for (int i = 0; i < rows_ * cols_; i++) {
    data_[i] += other.data_[i];
  }
}

Matrix Matrix::inverse() const {
  if (rows_ != cols_) {
    throw std::invalid_argument("Matrix is not square for inversion");
  }

  Matrix result = identity(rows_);

  // 高斯消元法求逆
  for (int i = 0; i < rows_; i++) {
    // 找出对角线元素
    double pivot = data_[i * cols_ + i];
    if (pivot == 0) {
      // 找不到主元，矩阵不可逆
      throw std::invalid_argument("Matrix is singular and cannot be inverted");
    }
    // 缩放对角线元素为 1
    for (int j = 0; j < cols_; j++) {
      data_[i * cols_ + j] /= pivot;
      result.data_[i * cols_ + j] /= pivot;
    }
    // 处理其他元素
    for (int k = 0; k < rows_; k++) {
      if (k != i) {
        double factor = data_[k * cols_ + i];
        for (int j = 0; j < cols_; j++) {
          result.data_[k * cols_ + j] -= factor * result.data_[i * cols_ + j];
          data_[k * cols_ + j] -= factor * data_[i * cols_ + j];
        }
      }
    }
  }
  return result;
}

Matrix Matrix::slice(int row_start, int row_end, int col_start,
                     int col_end) const {
  if (row_start < 0)
    row_start += rows_;
  if (col_start < 0)
    col_start += cols_;
  if (row_end <= 0)
    row_end += rows_;
  if (col_end <= 0)
    col_end += cols_;

  if (row_start < 0 || row_start >= rows_ || row_end < 0 || row_end > rows_ ||
      col_start < 0 || col_start >= cols_ || col_end < 0 || col_end > cols_) {
    throw std::invalid_argument("Slice indices out of range");
  }

  int rows = row_end - row_start;
  int cols = col_end - col_start;
  if (rows <= 0 || cols <= 0) {
    throw std::invalid_argument("Slice dimensions are invalid");
  }

  Matrix result(rows, cols);
  for (int i = 0; i < rows; i++) {
    for (int j = 0; j < cols; j++) {
      result.data_[i * cols + j] =
          data_[(row_start + i) * cols_ + col_start + j];
    }
  }
  return result;
}

linear_regression.h

#ifndef LINEAR_REGRESSION_H
#define LINEAR_REGRESSION_H
#include "matrix.h"

class LinearRegression {
public:
  LinearRegression() {};
  ~LinearRegression() {};
  void fit(const Matrix &X, const Matrix &y);
  Matrix predict(const Matrix &X) const;
  Matrix slope() const { return beta_.slice(1, 0, 0, 0); };
  double intercept() const { return beta_.get(0, 0); };

private:
  Matrix beta_;
};
#endif // LINEAR_REGRESSION_H

linear_regression.cpp

#include "linear_regression.h"
#include "matrix.h"
#include <stdexcept>

void LinearRegression::fit(const Matrix &X, const Matrix &y) {
  if (X.rows() != y.rows()) {
    throw std::invalid_argument("X and y must have the same number of rows.");
  }
  if (y.cols() != 1) {
    throw std::invalid_argument("y must have exactly one column.");
  }
  beta_ = X.transpose().matmul(X).inverse().matmul(X.transpose()).matmul(y);
}

Matrix LinearRegression::predict(const Matrix &X) const {
  return X.matmul(beta_);
}

[waruqi]

可以切 debug 断点调下。。

xmake f -m debug
xmake run -d