Bausager/Flux-openbuild
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Sync public subset from Flux

Browse Source
This commit is contained in:
Gitea CI
2025-10-08 16:08:04 +00:00
parent 35023cb7e1
commit 1c93024ff2
10 changed files with 260 additions and 133 deletions
Download Patch File Download Diff File Expand all files Collapse all files

160
include/numerics/matadd.h
View File

@@ -7,6 +7,39 @@
namespace numerics{
template <typename T>
void inplace_matadd_mat(utils::Matrix<T>& A, const utils::Matrix<T>& B) {
const uint64_t rows = A.rows();
const uint64_t cols = A.cols();
if (rows != B.rows() || cols != B.cols()) {
throw std::runtime_error("inplace_matadd: dimension mismatch");
}
for (uint64_t i = 0; i < cols; ++i) {
for (uint64_t j = 0; j < rows; ++j) {
A(j, i) += B(j, i);
}
}
}
template <typename T>
utils::Matrix<T> matadd_mat(const utils::Matrix<T>& A, const utils::Matrix<T>& B) {
const uint64_t rows = A.rows();
const uint64_t cols = A.cols();
utils::Matrix<T> C = A;
if (rows != B.rows() || cols != B.cols()) {
throw std::runtime_error("inplace_matadd: dimension mismatch");
}
inplace_matadd_mat(C, B);
return C;
}
template <typename T>
void inplace_matadd_colvec(utils::Matrix<T>& A, const utils::Vector<T>& x) {
@@ -94,133 +127,6 @@ namespace numerics{
}
}
/*
// -------------- Collapse(2) OpenMP ----------------
template <typename T>
utils::Vector<T> matvec_omp(const utils::Matrix<T>& A, const utils::Vector<T>& x) {
if (A.cols() != x.size()) {
throw std::runtime_error("matvec: dimension mismatch");
}
const uint64_t m = A.rows();
const uint64_t n = A.cols();
utils::Vector<T> y(m, T{0}); // <-- y has length m (rows)
const T* xptr = x.data();
const T* Aptr = A.data(); // row-major: A(i,j) == Aptr[i*n + j]
// Each row i is an independent dot product: y[i] = dot(A[i,*], x)
#pragma omp parallel for schedule(static)
for (uint64_t i = 0; i < m; ++i) {
const T* row = Aptr + i * n; // contiguous row i
T acc = T{0};
#pragma omp simd reduction(+:acc)
for (uint64_t j = 0; j < n; ++j) {
acc += row[j] * xptr[j];
}
y[i] = acc;
}
return y;
}
// -------------- Auto OpenMP ----------------
template <typename T>
utils::Vector<T> matvec_auto(const utils::Matrix<T>& A,
const utils::Vector<T>& x) {
uint64_t work = A.rows() * A.cols();
bool can_parallel = omp_config::omp_parallel_allowed();
#ifdef _OPENMP
int threads = omp_get_max_threads();
#else
int threads = 1;
#endif
if (can_parallel || work > static_cast<uint64_t>(threads) * 4ull) {
return matvec_omp(A,x);
}
else{
// Safe fallback
return matvec(A,x);
}
}
// =================================================
// y = x * A (Vector–Matrix product)
// =================================================
template <typename T>
utils::Vector<T> vecmat(const utils::Vector<T>& x, const utils::Matrix<T>& A) {
if (x.size() != A.rows()) {
throw std::runtime_error("vecmat: dimension mismatch");
}
const uint64_t m = A.rows();
const uint64_t n = A.cols();
utils::Vector<T> y(n, T{0});
for (uint64_t j = 0; j < n; ++j) {
for (uint64_t i = 0; i < m; ++i) {
y[j] += x[i] * A(i, j);
}
}
return y;
}
// -------------- Collapse(2) OpenMP ----------------
template <typename T>
utils::Vector<T> vecmat_omp(const utils::Vector<T>& x, const utils::Matrix<T>& A) {
if (x.size() != A.rows()) {
throw std::runtime_error("vecmat: dimension mismatch");
}
const uint64_t m = A.rows();
const uint64_t n = A.cols();
utils::Vector<T> y(n, T{0});
#pragma omp parallel for schedule(static)
for (uint64_t j = 0; j < n; ++j) {
T acc = T{0};
for (uint64_t i = 0; i < m; ++i) {
acc += x[i] * A(i, j);
}
y[j] = acc;
}
return y;
}
// -------------- Auto OpenMP ----------------
template <typename T>
utils::Vector<T> vecmat_auto(const utils::Vector<T>& x,
const utils::Matrix<T>& A) {
uint64_t work = A.rows() * A.cols();
bool can_parallel = omp_config::omp_parallel_allowed();
#ifdef _OPENMP
int threads = omp_get_max_threads();
#else
int threads = 1;
#endif
if (can_parallel || work > static_cast<uint64_t>(threads) * 4ull) {
return vecmat_omp(x,A);
}
else{
// Safe fallback
return vecmat(x,A);
}
}
*/
} // namespace numerics
#endif // _matadd_n_

62
include/numerics/matargmax.h Normal file
View File

@@ -0,0 +1,62 @@
#pragma once
#include "./utils/matrix.h"
namespace numerics{
template <typename Ti, typename Td>
void inplace_matargmax_row(const utils::Matrix<Td>& A, utils::Vector<Ti>& b){
if (b.size() != A.rows()){
b.resize(A.rows(), Ti{0});
}
Td value;
for (uint64_t i = 0; i < A.rows(); ++i){
value = Td{0};
for (uint64_t j = 0; j < A.cols(); ++j){
if (value < A(i,j)){
value = A(i,j);
b[i] = j;
}
}
}
}
template <typename Ti, typename Td>
void inplace_matargmax_col(const utils::Matrix<Td>& A, utils::Vector<Ti>& b){
if (b.size() != A.cols()){
b(A.cols(), Ti{0});
}
Td value;
for (uint64_t j = 0; j < A.cols(); ++j){
value = Td{0};
for (uint64_t i = 0; i < A.cols(); ++i){
if (value < A(i,j)){
value = A(i,j);
b[j] = i;
}
}
}
}
template <typename Ti, typename Td>
utils::Vector<Ti> matargmax_row(const utils::Matrix<Td>& A){
utils::Vector<Ti> b(A.rows(), Ti{0});
inplace_matargmax_row(A, b);
return b;
}
template <typename Ti, typename Td>
utils::Vector<Ti> matargmax_col(const utils::Matrix<Td>& A){
utils::Vector<Ti> b(A.rows(), Ti{0});
inplace_matargmax_col(A, b);
return b;
}
} // namespace numerics

32
include/numerics/matscalar.h Normal file
View File

@@ -0,0 +1,32 @@
#pragma once
#include "./utils/matrix.h"
namespace numerics{
template <typename T>
void inplace_matscalar(utils::Matrix<T>& A, const T scalar){
const uint64_t rows = A.rows();
const uint64_t cols = A.cols();
for (uint64_t i = 0; i < rows; ++i){
for (uint64_t j = 0; j < cols; ++j){
A(i,j) *= scalar;
}
}
}
template <typename T>
utils::Matrix<T> matscalar(const utils::Matrix<T>& A, T scalar){
utils::Matrix<T> B = A;
inplace_matscalar(B, scalar);
return B;
}
} // namespace numerics

12
include/numerics/numerics.h
View File

@@ -3,11 +3,17 @@
#include "./numerics/max.h"
#include "./numerics/exp.h"
#include "./numerics/log.h"
#include "./numerics/vecclip.h"
#include "./numerics/vecexp.h"
#include "./numerics/vecmax.h"
#include "./numerics/veclog.h"
#include "./numerics/vecargmax.h"
#include "./numerics/initializers/eye.h"
#include "./numerics/matequal.h"
#include "./numerics/transpose.h"
#include "./numerics/inverse.h"
#include "./numerics/matmul.h"
#include "./numerics/matscalar.h"
#include "./numerics/matmax.h"
#include "./numerics/matdiv.h"
#include "./numerics/matvec.h"
@@ -18,12 +24,10 @@
#include "./numerics/matexp.h"
#include "./numerics/matlog.h"
#include "./numerics/matdot.h"
#include "./numerics/matargmax.h"
#include "./numerics/min.h"
#include "./numerics/abs.h"
#include "./numerics/vecclip.h"
#include "./numerics/vecexp.h"
#include "./numerics/vecmax.h"
#include "./numerics/veclog.h"
#include "./numerics/interpolation1d.h" // base

26
include/numerics/vecargmax.h Normal file
View File

@@ -0,0 +1,26 @@
#pragma once
#include "./utils/vector.h"
namespace numerics{
template <typename T>
T vecarmax(const utils::Vector<T>& a){
const uint64_t N = a.size();
uint64_t idx = 0;
T value;
for (uint64_t i = 0; i < N; ++i){
if (value > a[i]){
value = a[i];
idx = i;
}
}
return idx;
}
} // namespace numerics

38
include/numerics/vecmean.h
View File

@@ -22,6 +22,44 @@ namespace numerics{
return mean;
}
template <typename T>
T vecmean_isequal(utils::Vector<T>& a, utils::Vector<T>& b, T tol=1e-12) {
uint64_t count = T{0};
const uint64_t N = a.size();
if (a.size() != b.size()){
throw std::runtime_error("vecmean_equal: dimension mismatch");
}
for (uint64_t i = 0; i < N; ++i) {
if ((a[i]-b[i]) < tol){
count += 1;
}
}
return static_cast<T>(count)/static_cast<T>(N);
}
template <typename Td, typename Ti>
Td vecmean_equal(utils::Vector<Ti>& a, utils::Vector<Ti>& b) {
Ti count = Ti{0};
const uint64_t N = a.size();
if (a.size() != b.size()){
throw std::runtime_error("vecmean_equal: dimension mismatch");
}
for (uint64_t i = 0; i < N; ++i) {
if (a[i]==b[i]){
count += Ti{1};
}
}
return static_cast<Td>(count)/static_cast<Td>(N);
}
} // namespace numerics