623 lines
13 KiB
C++
623 lines
13 KiB
C++
#pragma once
|
|
|
|
#include <cstdint> //uint64_t
|
|
|
|
#include "utils/vector.h"
|
|
#include "utils/matrix.h"
|
|
|
|
|
|
namespace numerics::detail{
|
|
|
|
|
|
//
|
|
// ---------------- Greater - Vectors ----------------
|
|
//
|
|
template <typename T>
|
|
inline void inplace_greater_serial(utils::Vector<T>& v, const T c) {
|
|
const uint64_t n = v.size();
|
|
|
|
if (n == 0){
|
|
throw std::runtime_error("inplace_greater_serial: empty vector");
|
|
}
|
|
|
|
|
|
for (uint64_t i = 0; i < n; ++i){
|
|
if (v[i] < c){
|
|
v[i] = T{0};
|
|
}
|
|
else{
|
|
v[i] = T{1};
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_greater_serial(utils::Vector<T>& v, const utils::Vector<T>& p) {
|
|
const uint64_t n = v.size();
|
|
const uint64_t m = p.size();
|
|
|
|
if (n == 0){
|
|
throw std::runtime_error("inplace_greater_serial: empty vector");
|
|
}
|
|
|
|
if (n != m){
|
|
throw std::runtime_error("inplace_greater_serial: vector size mismatch");
|
|
}
|
|
|
|
|
|
for (uint64_t i = 0; i < n; ++i){
|
|
if (v[i] < p[i]){
|
|
v[i] = T{0};
|
|
}
|
|
else{
|
|
v[i] = T{1};
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// ---------------- Greater - Matrices ----------------
|
|
//
|
|
template <typename T>
|
|
inline void inplace_greater_serial(utils::Matrix<T>& A, const T c) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_greater_serial: empty matrix");
|
|
}
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) < c){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_greater_rowwise_serial(utils::Matrix<T>& A, const utils::Vector<T>& v) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_greater_rowwise_serial: empty matrix");
|
|
}
|
|
|
|
if (rows != v.size()){
|
|
throw std::runtime_error("inplace_greater_rowwise_serial: Matrix-Vector size mismatch");
|
|
}
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) < v[i]){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_greater_colwise_serial(utils::Matrix<T>& A, const utils::Vector<T>& v) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_greater_colwise_serial: empty matrix");
|
|
}
|
|
|
|
if (cols != v.size()){
|
|
throw std::runtime_error("inplace_greater_colwise_serial: Matrix-Vector size mismatch");
|
|
}
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) < v[j]){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_greater_serial(utils::Matrix<T>& A, const utils::Matrix<T>& B) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_greater_serial: empty matrix");
|
|
}
|
|
|
|
if (rows != B.rows() || cols != B.cols()){
|
|
throw std::runtime_error("inplace_greater_serial: Matrix size mismatch");
|
|
}
|
|
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) < B(i,j)){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// ---------------- Greater or Equal - Vectors ----------------
|
|
//
|
|
template <typename T>
|
|
inline void inplace_greater_equal_serial(utils::Vector<T>& v, const T c) {
|
|
const uint64_t n = v.size();
|
|
|
|
if (n == 0){
|
|
throw std::runtime_error("inplace_greater_equal_serial: empty vector");
|
|
}
|
|
|
|
|
|
for (uint64_t i = 0; i < n; ++i){
|
|
if (v[i] <= c){
|
|
v[i] = T{0};
|
|
}
|
|
else{
|
|
v[i] = T{1};
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_greater_equal_serial(utils::Vector<T>& v, const utils::Vector<T>& p) {
|
|
const uint64_t n = v.size();
|
|
const uint64_t m = p.size();
|
|
|
|
if (n == 0){
|
|
throw std::runtime_error("inplace_greater_equal_serial: empty vector");
|
|
}
|
|
|
|
if (n != m){
|
|
throw std::runtime_error("inplace_greater_equal_serial: vector size mismatch");
|
|
}
|
|
|
|
|
|
for (uint64_t i = 0; i < n; ++i){
|
|
if (v[i] <= p[i]){
|
|
v[i] = T{0};
|
|
}
|
|
else{
|
|
v[i] = T{1};
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// ---------------- Greater - Matrices ----------------
|
|
//
|
|
template <typename T>
|
|
inline void inplace_greater_equal_serial(utils::Matrix<T>& A, const T c) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_greater_equal_serial: empty matrix");
|
|
}
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) <= c){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_greater_equal_rowwise_serial(utils::Matrix<T>& A, const utils::Vector<T>& v) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_greater_equal_rowwise_serial: empty matrix");
|
|
}
|
|
|
|
if (rows != v.size()){
|
|
throw std::runtime_error("inplace_greater_equal_rowwise_serial: Matrix-Vector size mismatch");
|
|
}
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) <= v[i]){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_greater_equal_colwise_serial(utils::Matrix<T>& A, const utils::Vector<T>& v) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_greater_equal_colwise_serial: empty matrix");
|
|
}
|
|
|
|
if (cols != v.size()){
|
|
throw std::runtime_error("inplace_greater_equal_colwise_serial: Matrix-Vector size mismatch");
|
|
}
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) <= v[j]){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_greater_equal_serial(utils::Matrix<T>& A, const utils::Matrix<T>& B) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_greater_equal_serial: empty matrix");
|
|
}
|
|
|
|
if (rows != B.rows() || cols != B.cols()){
|
|
throw std::runtime_error("inplace_greater_equal_serial: Matrix size mismatch");
|
|
}
|
|
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) <= B(i,j)){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// ---------------- Less - Vectors ----------------
|
|
//
|
|
template <typename T>
|
|
inline void inplace_less_serial(utils::Vector<T>& v, const T c) {
|
|
const uint64_t n = v.size();
|
|
|
|
if (n == 0){
|
|
throw std::runtime_error("inplace_less_serial: empty vector");
|
|
}
|
|
|
|
|
|
for (uint64_t i = 0; i < n; ++i){
|
|
if (v[i] > c){
|
|
v[i] = T{0};
|
|
}
|
|
else{
|
|
v[i] = T{1};
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_less_serial(utils::Vector<T>& v, const utils::Vector<T>& p) {
|
|
const uint64_t n = v.size();
|
|
const uint64_t m = p.size();
|
|
|
|
if (n == 0){
|
|
throw std::runtime_error("inplace_less_serial: empty vector");
|
|
}
|
|
|
|
if (n != m){
|
|
throw std::runtime_error("inplace_less_serial: vector size mismatch");
|
|
}
|
|
|
|
|
|
for (uint64_t i = 0; i < n; ++i){
|
|
if (v[i] > p[i]){
|
|
v[i] = T{0};
|
|
}
|
|
else{
|
|
v[i] = T{1};
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// ---------------- Greater - Matrices ----------------
|
|
//
|
|
template <typename T>
|
|
inline void inplace_less_serial(utils::Matrix<T>& A, const T c) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_less_serial: empty matrix");
|
|
}
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) > c){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_less_rowwise_serial(utils::Matrix<T>& A, const utils::Vector<T>& v) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_less_rowwise_serial: empty matrix");
|
|
}
|
|
|
|
if (rows != v.size()){
|
|
throw std::runtime_error("inplace_less_rowwise_serial: Matrix-Vector size mismatch");
|
|
}
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) > v[i]){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_less_colwise_serial(utils::Matrix<T>& A, const utils::Vector<T>& v) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_less_colwise_serial: empty matrix");
|
|
}
|
|
|
|
if (cols != v.size()){
|
|
throw std::runtime_error("inplace_less_colwise_serial: Matrix-Vector size mismatch");
|
|
}
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) > v[j]){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_less_serial(utils::Matrix<T>& A, const utils::Matrix<T>& B) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_less_serial: empty matrix");
|
|
}
|
|
|
|
if (rows != B.rows() || cols != B.cols()){
|
|
throw std::runtime_error("inplace_less_serial: Matrix size mismatch");
|
|
}
|
|
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) > B(i,j)){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// ---------------- Less or Equal - Vectors ----------------
|
|
//
|
|
template <typename T>
|
|
inline void inplace_less_equal_serial(utils::Vector<T>& v, const T c) {
|
|
const uint64_t n = v.size();
|
|
|
|
if (n == 0){
|
|
throw std::runtime_error("inplace_less_equal_serial: empty vector");
|
|
}
|
|
|
|
|
|
for (uint64_t i = 0; i < n; ++i){
|
|
if (v[i] >= c){
|
|
v[i] = T{0};
|
|
}
|
|
else{
|
|
v[i] = T{1};
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_less_equal_serial(utils::Vector<T>& v, const utils::Vector<T>& p) {
|
|
const uint64_t n = v.size();
|
|
const uint64_t m = p.size();
|
|
|
|
if (n == 0){
|
|
throw std::runtime_error("inplace_less_equal_serial: empty vector");
|
|
}
|
|
|
|
if (n != m){
|
|
throw std::runtime_error("inplace_less_equal_serial: vector size mismatch");
|
|
}
|
|
|
|
|
|
for (uint64_t i = 0; i < n; ++i){
|
|
if (v[i] >= p[i]){
|
|
v[i] = T{0};
|
|
}
|
|
else{
|
|
v[i] = T{1};
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// ---------------- Greater - Matrices ----------------
|
|
//
|
|
template <typename T>
|
|
inline void inplace_less_equal_serial(utils::Matrix<T>& A, const T c) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_less_equal_serial: empty matrix");
|
|
}
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) >= c){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_less_equal_rowwise_serial(utils::Matrix<T>& A, const utils::Vector<T>& v) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_less_equal_rowwise_serial: empty matrix");
|
|
}
|
|
|
|
if (rows != v.size()){
|
|
throw std::runtime_error("inplace_less_equal_rowwise_serial: Matrix-Vector size mismatch");
|
|
}
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) >= v[i]){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_less_equal_colwise_serial(utils::Matrix<T>& A, const utils::Vector<T>& v) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_less_equal_colwise_serial: empty matrix");
|
|
}
|
|
|
|
if (cols != v.size()){
|
|
throw std::runtime_error("inplace_less_equal_colwise_serial: Matrix-Vector size mismatch");
|
|
}
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) >= v[j]){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
template <typename T>
|
|
inline void inplace_less_equal_serial(utils::Matrix<T>& A, const utils::Matrix<T>& B) {
|
|
const uint64_t rows = A.rows();
|
|
const uint64_t cols = A.cols();
|
|
|
|
|
|
if (rows == 0 || cols == 0){
|
|
throw std::runtime_error("inplace_less_equal_serial: empty matrix");
|
|
}
|
|
|
|
if (rows != B.rows() || cols != B.cols()){
|
|
throw std::runtime_error("inplace_less_equal_serial: Matrix size mismatch");
|
|
}
|
|
|
|
|
|
for (uint64_t i = 0; i < rows; ++i){
|
|
for (uint64_t j = 0; j < cols; ++j){
|
|
if (A(i,j) >= B(i,j)){
|
|
A(i,j) = T{0};
|
|
}
|
|
else{
|
|
A(i,j) = T{1};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
} // namespace numerics
|
|
|