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

Fittet new functions to everying in neural networks. Still need to optimise for uint64_t vs int64_t and vec vs mat in some places.

Browse Source
This commit is contained in:
Michelle
2026-05-16 20:37:05 +02:00
parent 412a854c65
commit d2fe8aa65c
50 changed files with 489 additions and 1482 deletions
Download Patch File Download Diff File Expand all files Collapse all files
include/modules/neural_networks/activation_functions/Activation_ReLU.h
+4 -4
View File
@@ -1,9 +1,9 @@
#pragma once
#include "./core/omp_config.h"
#include "core/omp_config.h"
#include "./utils/vector.h"
#include "./utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace neural_networks{
@@ -18,7 +18,7 @@ namespace neural_networks{
void forward(const utils::Matrix<T>& inputs){
_inputs = inputs;
outputs = numerics::matclip_low(inputs, T{0});
outputs = numerics::clip_low(inputs, T{0});
}
void backward(const utils::Matrix<T>& dvalues){
// Since we need to modify the original variable,
include/modules/neural_networks/activation_functions/Activation_Softmax.h
+9 -9
View File
@@ -1,14 +1,14 @@
#pragma once
#include "./core/omp_config.h"
#include "core/omp_config.h"
#include "./utils/vector.h"
#include "./utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
#include "./numerics/matmax.h"
#include "./numerics/matsubtract.h"
#include "./numerics/matexp.h"
#include "./numerics/matdiv.h"
#include "numerics/max.h"
#include "numerics/sub.h"
#include "numerics/exp.h"
#include "numerics/div.h"
@@ -26,10 +26,10 @@ namespace neural_networks{
void forward(const utils::Matrix<T>& inputs){
// Get unnormalized probabilities
utils::Matrix<T> exp_values = numerics::matexp(numerics::matsubtract(inputs, numerics::matmax(inputs, "rows"), "col"));
utils::Matrix<T> exp_values = numerics::exp(numerics::sub_colwise(inputs, numerics::max_rowwise(inputs)));
// Normalize them for each sample
utils::Matrix<T> probabilities = numerics::matdiv(exp_values, numerics::matsum(exp_values, "col"), "col");
utils::Matrix<T> probabilities = numerics::div_colwise(exp_values, numerics::sum_colwise(exp_values));
outputs = probabilities;
}
include/modules/neural_networks/activation_functions/Activation_Softmax_Loss_CategoricalCrossentropy.h
+9 -9
View File
@@ -1,17 +1,17 @@
#pragma once
#include "./core/omp_config.h"
#include "core/omp_config.h"
#include "./utils/vector.h"
#include "./utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
#include "./numerics/matmax.h"
#include "./numerics/matsubtract.h"
#include "./numerics/matexp.h"
#include "./numerics/matdiv.h"
#include "numerics/max.h"
#include "numerics/sub.h"
#include "numerics/exp.h"
#include "numerics/div.h"
#include "./modules/neural_networks/activation_functions/Activation_Softmax.h"
#include "./modules/neural_networks/loss/Loss_CategoricalCrossentrophy.h"
#include "modules/neural_networks/activation_functions/Activation_Softmax.h"
#include "modules/neural_networks/loss/Loss_CategoricalCrossentrophy.h"
namespace neural_networks{
include/modules/neural_networks/layers/Dense_Layer.h
+9 -6
View File
@@ -1,10 +1,10 @@
#pragma once
#include "./core/omp_config.h"
#include "core/omp_config.h"
#include "./utils/vector.h"
#include "./utils/matrix.h"
#include "./utils/random.h"
#include "utils/vector.h"
#include "utils/matrix.h"
#include "utils/random.h"
namespace neural_networks{
@@ -40,20 +40,23 @@ namespace neural_networks{
Dense_Layer(const uint64_t n_inputs, const uint64_t n_neurons){
weights.random(n_inputs, n_neurons, -1, 1);
//weights = numerics::random_matrix(n_inputs, n_neurons, -1, 1);
biases.resize(n_neurons, T{0});
}
void forward(const utils::Matrix<T>& inputs){
_inputs = inputs;
outputs = numerics::matadd(numerics::matmul_auto(inputs, weights), biases, "row");
//std::cout << "HERE" << std::endl;
outputs = numerics::add_rowwise(numerics::matmul(inputs, weights), biases);
}
void backward(const utils::Matrix<T>& dvalues){
// Gradients on parameters
dweights = numerics::matmul(numerics::transpose(_inputs), dvalues);
dbiases = numerics::matsum(dvalues, "row");
dbiases = numerics::sum_rowwise(dvalues);
//Gradient on values
dinputs = numerics::matmul(dvalues, numerics::transpose(weights));
}
include/modules/neural_networks/loss/Loss.h
+8 -9
View File
@@ -1,13 +1,12 @@
#pragma once
#include "./core/omp_config.h"
#include "core/omp_config.h"
#include "./utils/vector.h"
#include "./utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
#include "numerics/vecmean.h"
#include "numerics/matabs.h"
#include "numerics/matmean.h"
#include "numerics/mean.h"
#include "numerics/abs.h"
namespace neural_networks{
@@ -28,7 +27,7 @@ namespace neural_networks{
sample_losses = forward(output, y);
// Calculate mean loss
data_loss = numerics::vecmean(sample_losses);
data_loss = numerics::mean(sample_losses);
return data_loss;
@@ -42,12 +41,12 @@ namespace neural_networks{
// L1 regularization - weights
// calculate only when factor greater than 0
if (layer.weight_regularizer_l1){
regularization_losss += layer.weight_regularizer_l1 * numerics::matsum_coeff(numerics::matabs(layer.weights));
regularization_losss += layer.weight_regularizer_l1 * numerics::sum(numerics::abs(layer.weights));
}
// L2 regularization - weights
if (layer.weight_regularizer_l2){
regularization_losss += layer.weight_regularizer_l2 * numerics::matsum_coeff(numerics::matmul(layer.weights,layer.weights)); // elementwise!
regularization_losss += layer.weight_regularizer_l2 * numerics::sum(numerics::mul(layer.weights,layer.weights)); // elementwise!
}
// L1 regularization - biases
include/modules/neural_networks/loss/Loss_CategoricalCrossentrophy.h
+16 -12
View File
@@ -1,15 +1,15 @@
#pragma once
#include "./core/omp_config.h"
#include "core/omp_config.h"
#include "./utils/vector.h"
#include "./utils/matrix.h"
#include "./utils/matcast.h"
#include "utils/vector.h"
#include "utils/matrix.h"
#include "utils/matcast.h"
#include "./numerics/matclip.h"
#include "./numerics/veclog.h"
#include "numerics/clip.h"
#include "numerics/log.h"
#include "./Loss.h"
#include "Loss.h"
namespace neural_networks{
@@ -30,7 +30,7 @@ namespace neural_networks{
// Clip data to prevent dividning by 0
// Clip both sides to not drag mean towards any value
utils::Matrix<Td> y_pred_clipped = numerics::matclip(y_pred, Td{1e-7}, Td{1.0} - Td{1e-7});
utils::Matrix<Td> y_pred_clipped = numerics::clip(y_pred, Td{1e-7}, Td{1.0} - Td{1e-7});
// Probabilities for taget values
// only if categorical labes
@@ -40,7 +40,8 @@ namespace neural_networks{
correct_confidences[i] = y_pred_clipped(i, idx);
}
}else{ // Mask values - only for one-hot encoded labels
correct_confidences = numerics::matdot_row(y_pred_clipped, cast_y_true);
correct_confidences = numerics::sum_rowwise(numerics::mul(y_pred_clipped, cast_y_true));
//correct_confidences = numerics::matdot_row(y_pred_clipped, cast_y_true);
}
// Losses
@@ -72,9 +73,12 @@ namespace neural_networks{
// Calculate the gradient
numerics::inplace_matscalar(y_temp,Ti{-1});
dinputs = numerics::matdiv(utils::matcast<Td, Ti>(y_temp), dvalues);
numerics::inplace_matdiv(dinputs, samples);
//numerics::inplace_matscalar(y_temp,Ti{-1});
y_temp = numerics::neg(y_temp);
//dinputs = numerics::matdiv(utils::matcast<Td, Ti>(y_temp), dvalues);
dinputs = numerics::div(utils::matcast<Td, Ti>(y_temp), dvalues);
//numerics::inplace_matdiv(dinputs, samples);
dinputs = numerics::div(dinputs, samples);
}
include/numerics/detail/abs_serial.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
#include <cmath> // std::abs
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/detail/add_serial.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/detail/argmax_serial.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
//#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/detail/argmin_serial.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
//#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/detail/clip_serial.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/detail/div_serial.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/detail/dot_serial.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/detail/equal_serial.h
+46 -4
View File
@@ -3,14 +3,14 @@
#include <cstdint> //uint64_t
//#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
// ---------------- Matrix ----------------
template <typename T>
inline bool equal_serial(const utils::Matrix<T>& A, const utils::Matrix<T> & B) {
inline bool equal_all_serial(const utils::Matrix<T>& A, const utils::Matrix<T> & B) {
const uint64_t rows = A.rows();
const uint64_t cols = A.cols();
@@ -30,7 +30,7 @@ namespace numerics::detail{
// ---------------- Vector ----------------
template <typename T>
inline bool equal_serial(const utils::Vector<T>& v, const utils::Vector<T>& p) {
inline bool equal_all_serial(const utils::Vector<T>& v, const utils::Vector<T>& p) {
const uint64_t N = v.size();
if (N != p.size()){
return false;
@@ -43,5 +43,47 @@ namespace numerics::detail{
return true;
}
// ---------------- Matrix ----------------
template <typename T>
inline utils::Matrix<T> equal_elementwise_serial(const 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("equal_elementwise_serial: Dimention misfit");
}
utils::Matrix<T> C(rows, cols, T{0});
for (uint64_t i = 0; i < rows; ++i){
for (uint64_t j = 0; j < cols; ++j){
if (A(i,j) == B(i,j)){
C(i,j) = T{1};
}
}
}
return C;
}
// ---------------- Vector ----------------
template <typename T>
inline utils::Vector<T> equal_elementwise_serial(const utils::Vector<T>& v, const utils::Vector<T>& p) {
const uint64_t N = v.size();
if (N != p.size()){
throw std::runtime_error("equal_elementwise_serial: Dimention misfit");
}
utils::Vector<T> y(N, T{0});
for (uint64_t i = 0; i < N; ++i){
if ((v[i] == p[i])){
y[i] = T{1};
}
}
return y;
}
} // namespace numerics
include/numerics/detail/exp_serial.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
#include <cmath> // std::exp
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/detail/isclose_serial.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
//#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
#include <cmath> // std::abs
include/numerics/detail/log_serial.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
#include <cmath> // std::log
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/detail/matmul_serial.h
+8 -3
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
@@ -15,7 +15,12 @@ namespace numerics::detail{
const uint64_t n = A.cols(); // also B.rows()
const uint64_t p = B.cols();
if(n != B.rows()){
throw std::runtime_error("matmul: dimension mismatch");
throw std::runtime_error(
"matmul: dimension mismatch: A is " +
std::to_string(A.rows()) + "x" + std::to_string(A.cols()) +
", B is " +
std::to_string(B.rows()) + "x" + std::to_string(B.cols())
);
}
T tmp;
utils::Matrix<T> C(m, p, T{0});
include/numerics/detail/max_serial.h
+12 -2
View File
@@ -3,10 +3,19 @@
#include <cstdint> //uint64_t
//#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
// ---------------- (Scalar, Scalar) -> Scalar ----------------
template <typename T>
T max_serial(const T a, const T b) {
if (a >= b){
return a;
}
return b;
}
// ---------------- Matrix -> Scalar ----------------
template <typename T>
@@ -37,6 +46,7 @@ namespace numerics::detail{
return max;
}
// ---------------- Matrix -> Vector ----------------
template <typename T>
utils::Vector<T> max_rowwise_serial(const utils::Matrix<T>& A) {
include/numerics/detail/mean_serial.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
//#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
#include "sum_serial.h"
include/numerics/detail/min_serial.h
+11 -2
View File
@@ -3,11 +3,20 @@
#include <cstdint> //uint64_t
//#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
// ---------------- (Scalar, Scalar) -> Scalar ----------------
template <typename T>
T min_serial(const T a, const T b) {
if (a >= b){
return a;
}
return b;
}
// ---------------- Matrix -> Scalar ----------------
template <typename T>
T min_serial(const utils::Matrix<T>& A) {
include/numerics/detail/mul_serial.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/detail/neg_serial.h
+2 -2
View File
@@ -2,8 +2,8 @@
#include <cstdint> //uint64_t
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/detail/pow_serial.h
+2 -2
View File
@@ -4,8 +4,8 @@
#include <stdexcept> // std::runtime_error
#include <cmath> // std::pow
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/detail/random_serial.h
+2 -2
View File
@@ -6,8 +6,8 @@
#include <type_traits>
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/detail/sqrt_serial.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
#include <cmath> // std::sqrt
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/detail/sub_serial.h
+3 -3
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
@@ -21,7 +21,7 @@ namespace numerics::detail{
}
template <typename T>
void inplace_add_scalar_serial(utils::Vector<T>& v, const T c) {
void inplace_sub_scalar_serial(utils::Vector<T>& v, const T c) {
for (uint64_t i = 0; i < v.size(); ++i){
v[i] -= c;
}
include/numerics/detail/sum_serial.h
+2 -2
View File
@@ -3,8 +3,8 @@
#include <cstdint> //uint64_t
//#include <stdexcept> // std::runtime_error
#include "../utils/vector.h"
#include "../utils/matrix.h"
#include "utils/vector.h"
#include "utils/matrix.h"
namespace numerics::detail{
include/numerics/div.h
+1 -1
View File
@@ -74,7 +74,7 @@ namespace numerics{
}
template <typename T>
inline utils::Matrix<T> dub_colwise(const utils::Matrix<T>& A, const utils::Vector<T>& v) {
inline utils::Matrix<T> div_colwise(const utils::Matrix<T>& A, const utils::Vector<T>& v) {
utils::Matrix<T> out = A;
inplace_div_colwise(out, v);
return out;
include/numerics/equal.h
+14 -5
View File
@@ -1,6 +1,6 @@
#pragma once
#include "./core/omp_config.h"
#include "core/omp_config.h"
#include "detail/equal_serial.h"
@@ -9,14 +9,23 @@ namespace numerics{
// ---------------- equal ----------------
template <typename T>
inline bool equal(const utils::Vector<T>& v, const utils::Vector<T>& p) {
return detail::equal_serial(v, p);
inline bool equal_all(const utils::Vector<T>& v, const utils::Vector<T>& p) {
return detail::equal_all_serial(v, p);
}
template <typename T>
inline bool equal(const utils::Matrix<T>& A, const utils::Matrix<T>& B) {
return detail::equal_serial(A, B);
inline bool equal_all(const utils::Matrix<T>& A, const utils::Matrix<T>& B) {
return detail::equal_all_serial(A, B);
}
template <typename T>
inline utils::Vector<T> equal_elementwise_serial(const utils::Vector<T>& v, const utils::Vector<T>& p){
return detail::equal_elementwise_serial(v, p);
}
template <typename T>
inline utils::Vector<T> equal_elementwise_serial(const utils::Matrix<T>& A, const utils::Matrix<T>& B){
return detail::equal_elementwise_serial(A, B);
}
}
include/numerics/interpolation1d/interpolation1d_base.h
+4 -4
View File
@@ -1,10 +1,10 @@
#pragma once
#include "./numerics/min.h"
#include "./numerics/max.h"
#include "./numerics/abs.h"
#include "numerics/min.h"
#include "numerics/max.h"
#include "numerics/abs.h"
#include "./utils/vector.h"
#include "utils/vector.h"
namespace numerics{
include/numerics/max.h
+8 -1
View File
@@ -1,12 +1,19 @@
#pragma once
#include "./core/omp_config.h"
#include "core/omp_config.h"
#include "detail/max_serial.h"
namespace numerics{
// ---------------- (Scalar, Scalar) -> Scalar ----------------
template <typename T>
inline T max(const T a, const T b) {
return detail::max_serial(a, b);
}
// ---------------- Vector -> Scalar ----------------
template <typename T>
inline T max(const utils::Vector<T>& v) {
include/numerics/mean.h
+2 -2
View File
@@ -1,6 +1,6 @@
#pragma once
#include "./core/omp_config.h"
#include "core/omp_config.h"
#include "detail/mean_serial.h"
@@ -30,4 +30,4 @@ namespace numerics{
inline utils::Vector<T> mean_colwise(const utils::Matrix<T>& A) {
return detail::mean_colwise_serial(A);
}
}
}
include/numerics/min.h
+8 -1
View File
@@ -1,12 +1,19 @@
#pragma once
#include "./core/omp_config.h"
#include "core/omp_config.h"
#include "detail/min_serial.h"
namespace numerics{
// ---------------- (Scalar, Scalar) -> Scalar ----------------
template <typename T>
inline T min(const T a, const T b) {
return detail::min_serial(a, b);
}
// ---------------- Vector -> Scalar ----------------
template <typename T>
inline T min(const utils::Vector<T>& v) {
include/numerics/numerics.h
+28 -32
View File
@@ -1,38 +1,34 @@
// "./numerics/numerics.h"
#pragma once
#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/vecrandom.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/matabs.h"
#include "./numerics/matdiv.h"
#include "./numerics/matvec.h"
#include "./numerics/matadd.h"
#include "./numerics/matrandom.h"
#include "./numerics/matsubtract.h"
#include "./numerics/matsum.h"
#include "./numerics/matclip.h"
#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/add.h"
#include "./numerics/argmax.h"
#include "./numerics/argmin.h"
#include "./numerics/clip.h"
#include "./numerics/div.h"
#include "./numerics/dot.h"
#include "./numerics/equal.h"
#include "./numerics/exp.h"
#include "./numerics/interpolation1d.h" // base
#include "./numerics/inverse.h"
#include "./numerics/isclose.h"
#include "./numerics/log.h"
#include "./numerics/matmul.h"
#include "./numerics/max.h"
#include "./numerics/mean.h"
#include "./numerics/min.h"
#include "./numerics/mul.h"
#include "./numerics/neg.h"
#include "./numerics/pow.h"
#include "./numerics/random.h"
#include "./numerics/sqrt.h"
#include "./numerics/sub.h"
#include "./numerics/sum.h"
#include "./numerics/transpose.h"
include/numerics/sum.h
+1 -1
View File
@@ -1,6 +1,6 @@
#pragma once
#include "./core/omp_config.h"
#include "core/omp_config.h"
#include "detail/sum_serial.h"
include/utils/matcast.h
+2 -2
View File
@@ -1,7 +1,7 @@
#pragma once
#include "./core/omp_config.h"
#include "./utils/matrix.h"
#include "core/omp_config.h"
#include "utils/matrix.h"
namespace utils{
include/utils/utils.h
+1
View File
@@ -6,3 +6,4 @@
#include "./utils/generators.h"
#include "./utils/random.h"
#include "./utils/matcast.h"
#include "./utils/veccast.h"
include/utils/veccast.h
+33
View File
@@ -0,0 +1,33 @@
#pragma once
#include "core/omp_config.h"
#include "utils/matrix.h"
namespace utils{
template <typename To, typename From>
void inplace_veccast(const utils::Vector<From>& a, utils::Vector<To>& b) {
if (a.size() != b.size()){
throw std::runtime_error("inplace_veccast: dimension mismatch");
}
uint64_t n = a.size();
for (uint64_t i = 0; i < n; ++i){
b[i] = static_cast<To>(a[i]);
}
}
template <typename To, typename From>
utils::Vector<To> veccast(const utils::Vector<From>& a) {
utils::Vector<To> b(a.size(), To{0});
inplace_veccast(a,b);
return b;
}
} // end namespace utils