Skip to content

Commit adfca6a

Browse files
author
Alexandre Hoffmann
committed
compatibility with BIC library
1 parent f8f6c99 commit adfca6a

24 files changed

Lines changed: 168 additions & 278 deletions

‎CMakeLists.txt‎

Lines changed: 17 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -52,6 +52,22 @@ option(FSLinalg_BUILD_TESTS "Build unit tests" OFF)
5252
# === Dependencies ===
5353
find_package(fmt REQUIRED)
5454

55+
include(FetchContent)
56+
57+
FetchContent_Declare(
58+
BIC
59+
GIT_REPOSITORY https://github.com/alexandrehoffmann/BetterIntegralConstant.git
60+
GIT_TAG main
61+
)
62+
63+
if(NOT BetterIntegralConstant_POPULATED)
64+
message(STATUS "Fetching BetterIntegralConstant...")
65+
else()
66+
message(STATUS "BetterIntegralConstant already available, skipping fetch")
67+
endif()
68+
69+
FetchContent_MakeAvailable(BIC)
70+
5571
# === Doxygen ===
5672
if(FSLinalg_BUILD_DOC)
5773
find_package(Doxygen REQUIRED dot)
@@ -105,7 +121,7 @@ target_include_directories(FSLinalg
105121
$<INSTALL_INTERFACE:include>
106122
)
107123

108-
target_link_libraries(FSLinalg INTERFACE fmt::fmt)
124+
target_link_libraries(FSLinalg INTERFACE fmt::fmt BIC)
109125

110126
target_compile_options(FSLinalg INTERFACE
111127
$<$<COMPILE_LANGUAGE:CXX>:${FSLinalg_COMPILE_WARNINGS}>

‎include/FSLinalg/Matrix/KeepBrackets.hpp‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
1-
#ifndef FSLINALG_KEEP_BRACKETING_HPP
2-
#define FSLINALG_KEEP_BRACKETING_HPP
1+
#ifndef FSLINALG_KEEP_BRACKETS_HPP
2+
#define FSLINALG_KEEP_BRACKETS_HPP
33

44
#include <FSLinalg/Matrix/MatrixBase.hpp>
55
#include <FSLinalg/Matrix/MatrixProduct.hpp>
@@ -44,14 +44,14 @@ class KeepBrackets : public MatrixBase< KeepBrackets<Expr> >
4444

4545
template<class Dst> bool isAliasedToImpl(const MatrixBase<Dst>& other) const { return m_expr.isAliasedToImpl(other); }
4646

47-
template<typename Alpha, class Dst, bool checkAliasing>
48-
void assignToImpl(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value) { m_expr.assignToHelper(alpha, dst, bc, std::true_type{}); }
47+
template<typename Bool, typename Alpha, class Dst>
48+
void assignToImpl(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value) { m_expr.assignToHelper(checkAliasing, alpha, dst, BIC::fixed<bool, true>); }
4949

50-
template<typename Alpha, class Dst, bool checkAliasing>
51-
void incrementImpl(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value) { m_expr.incrementHelper(alpha, dst, bc, std::true_type{}); }
50+
template<typename Bool, typename Alpha, class Dst>
51+
void incrementImpl(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value) { m_expr.incrementHelper(checkAliasing, alpha, dst, BIC::fixed<bool, true>); }
5252

53-
template<typename Alpha, class Dst, bool checkAliasing>
54-
void decrementImpl(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value) { m_expr.decrementHelper(alpha, dst, bc, std::true_type{}); }
53+
template<typename Bool, typename Alpha, class Dst>
54+
void decrementImpl(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value) { m_expr.decrementHelper(checkAliasing, alpha, dst, BIC::fixed<bool, true>); }
5555
private:
5656
std::conditional_t<Expr::isLeaf, const Expr&, Expr> m_expr;
5757
};
@@ -61,4 +61,4 @@ KeepBrackets<Expr> keepBrackets(const MatrixBase<Expr>& expr) { return KeepBrack
6161

6262
} // namespace FSLinalg
6363

64-
#endif // FSLINALG_KEEP_BRACKETING_HPP
64+
#endif // FSLINALG_KEEP_BRACKETS_HPP

‎include/FSLinalg/Matrix/Matrix.hpp‎

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -34,7 +34,7 @@ class Matrix : public MatrixBase< Matrix<T, Nrows, Ncols> >
3434
FSLINALG_DEFINE_MATRIX
3535

3636
template<class Dst>
37-
struct CanBeAlisaedTo : std::bool_constant<
37+
struct CanBeAlisaedTo : BIC::Fixed<bool,
3838
IsMatrix<Dst>::value
3939
and Base::nRows == Dst::nRows
4040
and Base::nCols == Dst::nCols
@@ -53,11 +53,11 @@ class Matrix : public MatrixBase< Matrix<T, Nrows, Ncols> >
5353

5454
Matrix(const Matrix& other) : m_data(other.m_data) {}
5555

56-
template<class Expr> Matrix(const MatrixBase<Expr>& expr) requires(IsConstructibleFrom<Expr>::value) { expr.assignTo(Scalar(1), *this, std::false_type{}); }
56+
template<class Expr> Matrix(const MatrixBase<Expr>& expr) requires(IsConstructibleFrom<Expr>::value) { expr.assignTo(BIC::fixed<bool, false>, Scalar(1), *this); }
5757

58-
template<class Expr> Matrix& operator= (const MatrixBase<Expr>& expr) requires(IsConstructibleFrom<Expr>::value) { expr.assignTo (Scalar(1), *this, std::true_type{}); return *this; }
59-
template<class Expr> Matrix& operator+=(const MatrixBase<Expr>& expr) requires(IsConstructibleFrom<Expr>::value) { expr.increment (Scalar(1), *this, std::true_type{}); return *this; }
60-
template<class Expr> Matrix& operator-=(const MatrixBase<Expr>& expr) requires(IsConstructibleFrom<Expr>::value) { expr.decrement (Scalar(1), *this, std::true_type{}); return *this; }
58+
template<class Expr> Matrix& operator= (const MatrixBase<Expr>& expr) requires(IsConstructibleFrom<Expr>::value) { expr.assignTo (BIC::fixed<bool, true>, Scalar(1), *this); return *this; }
59+
template<class Expr> Matrix& operator+=(const MatrixBase<Expr>& expr) requires(IsConstructibleFrom<Expr>::value) { expr.increment (BIC::fixed<bool, true>, Scalar(1), *this); return *this; }
60+
template<class Expr> Matrix& operator-=(const MatrixBase<Expr>& expr) requires(IsConstructibleFrom<Expr>::value) { expr.decrement (BIC::fixed<bool, true>, Scalar(1), *this); return *this; }
6161

6262
Matrix& operator*=(const RealScalar& alpha) requires(isScalarComplex) { for (Size i=0; i!=size; ++i) { m_data[i] *= alpha; } return *this; }
6363
Matrix& operator/=(const RealScalar& alpha) requires(isScalarComplex) { for (Size i=0; i!=size; ++i) { m_data[i] /= alpha; } return *this; }

‎include/FSLinalg/Matrix/MatrixBase.hpp‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -24,13 +24,13 @@ class MatrixBase : public CRTPBase<Derived>
2424
using Size = typename DerivedTraits::Size;
2525

2626
template<class Dst>
27-
struct IsConvertibleTo : std::bool_constant<
27+
struct IsConvertibleTo : BIC::Fixed<bool,
2828
std::is_base_of<MatrixBase<Dst>, Dst>::value
2929
and Dst::hasWriteRandomAccess
3030
and std::is_convertible<Scalar, typename Dst::Scalar>::value> {};
3131

3232
template<class Src>
33-
struct IsConstructibleFrom : std::bool_constant<
33+
struct IsConstructibleFrom : BIC::Fixed<bool,
3434
std::is_base_of<MatrixBase<Src>, Src>::value
3535
and DerivedTraits::hasWriteRandomAccess
3636
and std::is_convertible<typename Src::Scalar, Scalar>::value> {};
@@ -61,17 +61,17 @@ class MatrixBase : public CRTPBase<Derived>
6161

6262
template<class Dst> bool isAliasedTo(const MatrixBase<Dst>& other) const { return Base::derived().isAliasedToImpl(other); }
6363

64-
template<typename Alpha, class Dst, bool checkAliasing>
65-
void assignTo(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value);
64+
template<typename Bool, typename Alpha, class Dst>
65+
void assignTo(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value);
6666

67-
template<typename Alpha, class Dst, bool checkAliasing>
68-
void increment(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value);
67+
template<typename Bool, typename Alpha, class Dst>
68+
void increment(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value);
6969

70-
template<typename Alpha, class Dst, bool checkAliasing>
71-
void decrement(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value);
70+
template<typename Bool, typename Alpha, class Dst>
71+
void decrement(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value);
7272
};
7373

74-
template<typename Expr> struct IsMatrix : std::bool_constant< std::is_base_of<MatrixBase<Expr>, Expr>::value > {};
74+
template<typename Expr> struct IsMatrix : BIC::Fixed<bool, std::is_base_of<MatrixBase<Expr>, Expr>::value > {};
7575

7676
template<typename Expr> concept Matrix_concept = IsMatrix<Expr>::value;
7777
template<typename Expr> concept ReadableMatrix_concept = IsMatrix<Expr>::value and Expr::hasReadRandomAccess;

‎include/FSLinalg/Matrix/MatrixBase_impl.hpp‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -7,8 +7,8 @@
77
namespace FSLinalg
88
{
99

10-
template<class Derived> template<typename Alpha, class Dst, bool checkAliasing>
11-
void MatrixBase<Derived>::assignTo(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value)
10+
template<class Derived> template<typename Bool, typename Alpha, class Dst>
11+
void MatrixBase<Derived>::assignTo(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value)
1212
{
1313
static_assert(Dst::nRows == nRows, "Matrix sizes must match");
1414
static_assert(Dst::nCols == nCols, "Matrix sizes must match");
@@ -42,12 +42,12 @@ void MatrixBase<Derived>::assignTo(const Alpha& alpha, MatrixBase<Dst>& dst, std
4242
}
4343
else
4444
{
45-
Base::derived().assignToImpl(alpha, dst, bc);
45+
Base::derived().assignToImpl(checkAliasing, alpha, dst);
4646
}
4747
}
4848

49-
template<class Derived> template<typename Alpha, class Dst, bool checkAliasing>
50-
void MatrixBase<Derived>::increment(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value)
49+
template<class Derived> template<typename Bool, typename Alpha, class Dst>
50+
void MatrixBase<Derived>::increment(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value)
5151
{
5252
static_assert(Dst::nRows == nRows, "Matrix sizes must match");
5353
static_assert(Dst::nCols == nCols, "Matrix sizes must match");
@@ -81,12 +81,12 @@ void MatrixBase<Derived>::increment(const Alpha& alpha, MatrixBase<Dst>& dst, st
8181
}
8282
else
8383
{
84-
Base::derived().incrementImpl(alpha, dst, bc);
84+
Base::derived().incrementImpl(checkAliasing, alpha, dst);
8585
}
8686
}
8787

88-
template<class Derived> template<typename Alpha, class Dst, bool checkAliasing>
89-
void MatrixBase<Derived>::decrement(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value)
88+
template<class Derived> template<typename Bool, typename Alpha, class Dst>
89+
void MatrixBase<Derived>::decrement(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value)
9090
{
9191
static_assert(Dst::nRows == nRows, "Matrix sizes must match");
9292
static_assert(Dst::nCols == nCols, "Matrix sizes must match");
@@ -120,7 +120,7 @@ void MatrixBase<Derived>::decrement(const Alpha& alpha, MatrixBase<Dst>& dst, st
120120
}
121121
else
122122
{
123-
Base::derived().decrementImpl(alpha, dst, bc);
123+
Base::derived().decrementImpl(checkAliasing, alpha, dst);
124124
}
125125
}
126126

‎include/FSLinalg/Matrix/MatrixConj.hpp‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -46,14 +46,14 @@ class MatrixConj : public MatrixBase< MatrixConj<Expr> >
4646

4747
template<class Dst> bool isAliasedToImpl(const MatrixBase<Dst>& other) const { return m_expr.isAliasedToImpl(other); }
4848

49-
template<typename Alpha, class Dst, bool checkAliasing>
50-
void assignToImpl(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value);
49+
template<typename Bool, typename Alpha, class Dst>
50+
void assignToImpl(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value);
5151

52-
template<typename Alpha, class Dst, bool checkAliasing>
53-
void incrementImpl(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value);
52+
template<typename Bool, typename Alpha, class Dst>
53+
void incrementImpl(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value);
5454

55-
template<typename Alpha, class Dst, bool checkAliasing>
56-
void decrementImpl(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value);
55+
template<typename Bool, typename Alpha, class Dst>
56+
void decrementImpl(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value);
5757
private:
5858
std::conditional_t<Expr::isLeaf, const Expr&, Expr> m_expr;
5959
};

‎include/FSLinalg/Matrix/MatrixConj_impl.hpp‎

Lines changed: 9 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -6,10 +6,10 @@
66
namespace FSLinalg
77
{
88

9-
template<class Expr> template<typename Alpha, class Dst, bool checkAliasing>
10-
void MatrixConj<Expr>::assignToImpl(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value)
9+
template<class Expr> template<typename Bool, typename Alpha, class Dst>
10+
void MatrixConj<Expr>::assignToImpl(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value)
1111
{
12-
m_expr.assignTo(conj(alpha), dst, bc);
12+
m_expr.assignTo(checkAliasing, conj(alpha), dst);
1313
if constexpr (IsComplexScalar<Scalar>::value)
1414
{
1515
if constexpr (Dst::hasFlatRandomAccess)
@@ -32,12 +32,12 @@ void MatrixConj<Expr>::assignToImpl(const Alpha& alpha, MatrixBase<Dst>& dst, st
3232
}
3333
}
3434

35-
template<class Expr> template<typename Alpha, class Dst, bool checkAliasing>
36-
void MatrixConj<Expr>::incrementImpl(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value)
35+
template<class Expr> template<typename Bool, typename Alpha, class Dst>
36+
void MatrixConj<Expr>::incrementImpl(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value)
3737
{
3838
if constexpr (IsRealScalar<Scalar>::value)
3939
{
40-
m_expr.increment(alpha, dst, bc);
40+
m_expr.increment(checkAliasing, alpha, dst);
4141
}
4242
else
4343
{
@@ -62,12 +62,12 @@ void MatrixConj<Expr>::incrementImpl(const Alpha& alpha, MatrixBase<Dst>& dst, s
6262
}
6363
}
6464

65-
template<class Expr> template<typename Alpha, class Dst, bool checkAliasing>
66-
void MatrixConj<Expr>::decrementImpl(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value)
65+
template<class Expr> template<typename Bool, typename Alpha, class Dst>
66+
void MatrixConj<Expr>::decrementImpl(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value)
6767
{
6868
if constexpr (IsRealScalar<Scalar>::value)
6969
{
70-
m_expr.decrement(alpha, dst, bc);
70+
m_expr.decrement(checkAliasing, alpha, dst);
7171
}
7272
else
7373
{

‎include/FSLinalg/Matrix/MatrixMinus.hpp‎

Lines changed: 6 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -46,14 +46,14 @@ class MatrixMinus : public MatrixBase< MatrixMinus<Expr> >
4646

4747
template<class Dst> bool isAliasedToImpl(const MatrixBase<Dst>& other) const { return m_expr.isAliasedToImpl(other); }
4848

49-
template<typename Alpha, class Dst, bool checkAliasing>
50-
void assignToImpl(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value) { m_expr.assignTo(-alpha, dst, bc); }
49+
template<typename Bool, typename Alpha, class Dst>
50+
void assignToImpl(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value) { m_expr.assignTo(checkAliasing, -alpha, dst); }
5151

52-
template<typename Alpha, class Dst, bool checkAliasing>
53-
void incrementImpl(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value) { m_expr.decrement(alpha, dst, bc); }
52+
template<typename Bool, typename Alpha, class Dst>
53+
void incrementImpl(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value) { m_expr.decrement(checkAliasing, alpha, dst); }
5454

55-
template<typename Alpha, class Dst, bool checkAliasing>
56-
void decrementImpl(const Alpha& alpha, MatrixBase<Dst>& dst, std::bool_constant<checkAliasing> bc) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value) { m_expr.increment(alpha, dst, bc); }
55+
template<typename Bool, typename Alpha, class Dst>
56+
void decrementImpl(const Bool checkAliasing, const Alpha& alpha, MatrixBase<Dst>& dst) const requires(IsConvertibleTo<Dst>::value and IsScalar<Alpha>::value) { m_expr.increment(checkAliasing, alpha, dst); }
5757
private:
5858
std::conditional_t<Expr::isLeaf, const Expr&, Expr> m_expr;
5959
};

0 commit comments

Comments
 (0)