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

Starting on the model.h, but need to make layer structs and structs for loss and optimizers

Browse Source
This commit is contained in:
Michelle
2026-05-30 09:13:52 +02:00
parent cb65174cf4
commit edad247227
30 changed files with 1879 additions and 159 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/numerics/greater_or_less.h
+316
View File
@@ -0,0 +1,316 @@
#pragma once
#include "./core/omp_config.h"
#include "detail/greater_or_less_serial.h"
namespace numerics{
//
// ---------------- Greater - Vectors ----------------
//
template <typename T>
inline void inplace_greater(utils::Vector<T>& v, const T c) {
detail::inplace_greater_serial(v, c);
}
template <typename T>
inline utils::Vector<T> greater(const utils::Vector<T>& v, const T c) {
utils::Vector<T> out = v;
inplace_greater(out, c);
return out;
}
template <typename T>
inline void inplace_greater(utils::Vector<T>& v, const utils::Vector<T>& p) {
detail::inplace_greater_serial(v, p);
}
template <typename T>
inline utils::Vector<T> greater(const utils::Vector<T>& v, const utils::Vector<T>& p) {
utils::Vector<T> out = v;
inplace_greater(out, p);
return out;
}
//
// ---------------- Greater - Matrices ----------------
//
template <typename T>
inline void inplace_greater(utils::Matrix<T>& A, const T c) {
detail::inplace_greater_serial(A, c);
}
template <typename T>
inline utils::Matrix<T> greater(const utils::Matrix<T>& A, const T c) {
utils::Matrix<T> out = A;
inplace_greater(out, c);
return out;
}
template <typename T>
inline void inplace_greater_rowwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
detail::inplace_greater_rowwise_serial(A, v);
}
template <typename T>
inline utils::Matrix<T> greater_rowwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
utils::Matrix<T> out = A;
inplace_greater_rowwise(out, v);
return out;
}
template <typename T>
inline void inplace_greater_colwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
detail::inplace_greater_colwise_serial(A, v);
}
template <typename T>
inline utils::Matrix<T> greater_colwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
utils::Matrix<T> out = A;
inplace_greater_colwise(out, v);
return out;
}
template <typename T>
inline void inplace_greater(utils::Matrix<T>& A, const utils::Matrix<T> B) {
detail::inplace_greater_serial(A, B);
}
template <typename T>
inline utils::Matrix<T> greater(const utils::Matrix<T>& A, const utils::Matrix<T> B) {
utils::Matrix<T> out = A;
inplace_greater(out, B);
return out;
}
//
// ---------------- Greater or Equal - Vectors ----------------
//
template <typename T>
inline void inplace_greater_equal(utils::Vector<T>& v, const T c) {
detail::inplace_greater_equal_serial(v, c);
}
template <typename T>
inline utils::Vector<T> greater_equal(const utils::Vector<T>& v, const T c) {
utils::Vector<T> out = v;
inplace_greater_equal(out, c);
return out;
}
template <typename T>
inline void inplace_greater_equal(utils::Vector<T>& v, const utils::Vector<T>& p) {
detail::inplace_greater_equal_serial(v, p);
}
template <typename T>
inline utils::Vector<T> greater_equal(const utils::Vector<T>& v, const utils::Vector<T>& p) {
utils::Vector<T> out = v;
inplace_greater_equal(out, p);
return out;
}
//
// ---------------- Greater or Equal - Matrices ----------------
//
template <typename T>
inline void inplace_greater_equal(utils::Matrix<T>& A, const T c) {
detail::inplace_greater_equal_serial(A, c);
}
template <typename T>
inline utils::Matrix<T> greater_equal(const utils::Matrix<T>& A, const T c) {
utils::Matrix<T> out = A;
inplace_greater_equal(out, c);
return out;
}
template <typename T>
inline void inplace_greater_equal_rowwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
detail::inplace_greater_equal_rowwise_serial(A, v);
}
template <typename T>
inline utils::Matrix<T> greater_equal_rowwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
utils::Matrix<T> out = A;
inplace_greater_equal_rowwise(out, v);
return out;
}
template <typename T>
inline void inplace_greater_equal_colwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
detail::inplace_greater_equal_colwise_serial(A, v);
}
template <typename T>
inline utils::Matrix<T> greater_equal_colwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
utils::Matrix<T> out = A;
inplace_greater_equal_colwise(out, v);
return out;
}
template <typename T>
inline void inplace_greater_equal(utils::Matrix<T>& A, const utils::Matrix<T> B) {
detail::inplace_greater_equal_serial(A, B);
}
template <typename T>
inline utils::Matrix<T> greater_euqal(const utils::Matrix<T>& A, const utils::Matrix<T> B) {
utils::Matrix<T> out = A;
inplace_greater_equal(out, B);
return out;
}
//
// ---------------- Less - Vectors ----------------
//
template <typename T>
inline void inplace_less(utils::Vector<T>& v, const T c) {
detail::inplace_less_serial(v, c);
}
template <typename T>
inline utils::Vector<T> less(const utils::Vector<T>& v, const T c) {
utils::Vector<T> out = v;
inplace_less(out, c);
return out;
}
template <typename T>
inline void inplace_less(utils::Vector<T>& v, const utils::Vector<T>& p) {
detail::inplace_less_serial(v, p);
}
template <typename T>
inline utils::Vector<T> less(const utils::Vector<T>& v, const utils::Vector<T>& p) {
utils::Vector<T> out = v;
inplace_less(out, p);
return out;
}
//
// ---------------- Less - Matrices ----------------
//
template <typename T>
inline void inplace_less(utils::Matrix<T>& A, const T c) {
detail::inplace_less_serial(A, c);
}
template <typename T>
inline utils::Matrix<T> less(const utils::Matrix<T>& A, const T c) {
utils::Matrix<T> out = A;
inplace_less(out, c);
return out;
}
template <typename T>
inline void inplace_less_rowwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
detail::inplace_less_rowwise_serial(A, v);
}
template <typename T>
inline utils::Matrix<T> less_rowwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
utils::Matrix<T> out = A;
inplace_less_rowwise(out, v);
return out;
}
template <typename T>
inline void inplace_less_colwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
detail::inplace_less_colwise_serial(A, v);
}
template <typename T>
inline utils::Matrix<T> less_colwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
utils::Matrix<T> out = A;
inplace_less_colwise(out, v);
return out;
}
template <typename T>
inline void inplace_less(utils::Matrix<T>& A, const utils::Matrix<T> B) {
detail::inplace_less_serial(A, B);
}
template <typename T>
inline utils::Matrix<T> less(const utils::Matrix<T>& A, const utils::Matrix<T> B) {
utils::Matrix<T> out = A;
inplace_less(out, B);
return out;
}
//
// ---------------- Less or Equal - Vectors ----------------
//
template <typename T>
inline void inplace_less_equal(utils::Vector<T>& v, const T c) {
detail::inplace_less_equal_serial(v, c);
}
template <typename T>
inline utils::Vector<T> less_equal(const utils::Vector<T>& v, const T c) {
utils::Vector<T> out = v;
inplace_less_equal(out, c);
return out;
}
template <typename T>
inline void inplace_less_equal(utils::Vector<T>& v, const utils::Vector<T>& p) {
detail::inplace_less_equal_serial(v, p);
}
template <typename T>
inline utils::Vector<T> less_equal(const utils::Vector<T>& v, const utils::Vector<T>& p) {
utils::Vector<T> out = v;
inplace_less_equal(out, p);
return out;
}
//
// ---------------- Less or Equal - Matrices ----------------
//
template <typename T>
inline void inplace_less_equal(utils::Matrix<T>& A, const T c) {
detail::inplace_less_equal_serial(A, c);
}
template <typename T>
inline utils::Matrix<T> less_equal(const utils::Matrix<T>& A, const T c) {
utils::Matrix<T> out = A;
inplace_less_equal(out, c);
return out;
}
template <typename T>
inline void inplace_less_equal_rowwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
detail::inplace_less_equal_rowwise_serial(A, v);
}
template <typename T>
inline utils::Matrix<T> less_equal_rowwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
utils::Matrix<T> out = A;
inplace_less_equal_rowwise(out, v);
return out;
}
template <typename T>
inline void inplace_less_equal_colwise(utils::Matrix<T>& A, const utils::Vector<T> v) {
detail::inplace_less_equal_colwise_serial(A, v);
}
template <typename T>
inline utils::Matrix<T> less_equal_colwise(const utils::Matrix<T>& A, const utils::Vector<T> v) {
utils::Matrix<T> out = A;
inplace_less_equal_colwise(out, v);
return out;
}
template <typename T>
inline void inplace_less_equal(utils::Matrix<T>& A, const utils::Matrix<T> B) {
detail::inplace_less_equal_serial(A, B);
}
template <typename T>
inline utils::Matrix<T> less_euqal(const utils::Matrix<T>& A, const utils::Matrix<T> B) {
utils::Matrix<T> out = A;
inplace_less_equal(out, B);
return out;
}
}