316 lines
8.5 KiB
C++
316 lines
8.5 KiB
C++
#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;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
} |