devtools/eigen
1
0
Fork 0
mirror of https://gitlab.com/libeigen/eigen.git synced 2026-04-10 11:34:33 +08:00
Code Issues Packages Projects Releases Wiki Activity

fixups for clean QCC compilation (add std:: in front of size_t, memcpy, etc.)

Browse Source
This commit is contained in:
Piotr Trojanek
2010-03-05 11:21:11 +01:00
parent 47a61bbd80
commit 1625a5e3f8
15 changed files with 84 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
Eigen/src/Sparse/AmbiVector.h
View File

@@ -98,7 +98,7 @@ template<typename _Scalar> class AmbiVector
int allocSize = m_allocatedElements * sizeof(ListEl);
allocSize = allocSize/sizeof(Scalar) + (allocSize%sizeof(Scalar)>0?1:0);
Scalar* newBuffer = new Scalar[allocSize];
memcpy(newBuffer, m_buffer, copyElements * sizeof(ListEl));
std::memcpy(newBuffer, m_buffer, copyElements * sizeof(ListEl));
delete[] m_buffer;
m_buffer = newBuffer;
}

60
Eigen/src/Sparse/CompressedStorage.h
View File

@@ -37,7 +37,7 @@ class CompressedStorage
: m_values(0), m_indices(0), m_size(0), m_allocatedSize(0)
{}
CompressedStorage(size_t size)
CompressedStorage(std::size_t size)
: m_values(0), m_indices(0), m_size(0), m_allocatedSize(0)
{
resize(size);
@@ -52,8 +52,8 @@ class CompressedStorage
CompressedStorage& operator=(const CompressedStorage& other)
{
resize(other.size());
memcpy(m_values, other.m_values, m_size * sizeof(Scalar));
memcpy(m_indices, other.m_indices, m_size * sizeof(int));
std::memcpy(m_values, other.m_values, m_size * sizeof(Scalar));
std::memcpy(m_indices, other.m_indices, m_size * sizeof(int));
return *this;
}
@@ -71,9 +71,9 @@ class CompressedStorage
delete[] m_indices;
}
void reserve(size_t size)
void reserve(std::size_t size)
{
size_t newAllocatedSize = m_size + size;
std::size_t newAllocatedSize = m_size + size;
if (newAllocatedSize > m_allocatedSize)
reallocate(newAllocatedSize);
}
@@ -84,10 +84,10 @@ class CompressedStorage
reallocate(m_size);
}
void resize(size_t size, float reserveSizeFactor = 0)
void resize(std::size_t size, float reserveSizeFactor = 0)
{
if (m_allocatedSize<size)
reallocate(size + size_t(reserveSizeFactor*size));
reallocate(size + std::size_t(reserveSizeFactor*size));
m_size = size;
}
@@ -99,17 +99,17 @@ class CompressedStorage
m_indices[id] = i;
}
inline size_t size() const { return m_size; }
inline size_t allocatedSize() const { return m_allocatedSize; }
inline std::size_t size() const { return m_size; }
inline std::size_t allocatedSize() const { return m_allocatedSize; }
inline void clear() { m_size = 0; }
inline Scalar& value(size_t i) { return m_values[i]; }
inline const Scalar& value(size_t i) const { return m_values[i]; }
inline Scalar& value(std::size_t i) { return m_values[i]; }
inline const Scalar& value(std::size_t i) const { return m_values[i]; }
inline int& index(size_t i) { return m_indices[i]; }
inline const int& index(size_t i) const { return m_indices[i]; }
inline int& index(std::size_t i) { return m_indices[i]; }
inline const int& index(std::size_t i) const { return m_indices[i]; }
static CompressedStorage Map(int* indices, Scalar* values, size_t size)
static CompressedStorage Map(int* indices, Scalar* values, std::size_t size)
{
CompressedStorage res;
res.m_indices = indices;
@@ -125,11 +125,11 @@ class CompressedStorage
}
/** \returns the largest \c k in [start,end) such that for all \c j in [start,k) index[\c j]\<\a key */
inline int searchLowerIndex(size_t start, size_t end, int key) const
inline int searchLowerIndex(std::size_t start, std::size_t end, int key) const
{
while(end>start)
{
size_t mid = (end+start)>>1;
std::size_t mid = (end+start)>>1;
if (m_indices[mid]<key)
start = mid+1;
else
@@ -148,12 +148,12 @@ class CompressedStorage
return m_values[m_size-1];
// ^^ optimization: let's first check if it is the last coefficient
// (very common in high level algorithms)
const size_t id = searchLowerIndex(0,m_size-1,key);
const std::size_t id = searchLowerIndex(0,m_size-1,key);
return ((id<m_size) && (m_indices[id]==key)) ? m_values[id] : defaultValue;
}
/** Like at(), but the search is performed in the range [start,end) */
inline Scalar atInRange(size_t start, size_t end, int key, Scalar defaultValue = Scalar(0)) const
inline Scalar atInRange(std::size_t start, std::size_t end, int key, Scalar defaultValue = Scalar(0)) const
{
if (start==end)
return Scalar(0);
@@ -161,7 +161,7 @@ class CompressedStorage
return m_values[end-1];
// ^^ optimization: let's first check if it is the last coefficient
// (very common in high level algorithms)
const size_t id = searchLowerIndex(start,end-1,key);
const std::size_t id = searchLowerIndex(start,end-1,key);
return ((id<end) && (m_indices[id]==key)) ? m_values[id] : defaultValue;
}
@@ -170,11 +170,11 @@ class CompressedStorage
* such that the keys are sorted. */
inline Scalar& atWithInsertion(int key, Scalar defaultValue = Scalar(0))
{
size_t id = searchLowerIndex(0,m_size,key);
std::size_t id = searchLowerIndex(0,m_size,key);
if (id>=m_size || m_indices[id]!=key)
{
resize(m_size+1,1);
for (size_t j=m_size-1; j>id; --j)
for (std::size_t j=m_size-1; j>id; --j)
{
m_indices[j] = m_indices[j-1];
m_values[j] = m_values[j-1];
@@ -187,9 +187,9 @@ class CompressedStorage
void prune(Scalar reference, RealScalar epsilon = precision<RealScalar>())
{
size_t k = 0;
size_t n = size();
for (size_t i=0; i<n; ++i)
std::size_t k = 0;
std::size_t n = size();
for (std::size_t i=0; i<n; ++i)
{
if (!ei_isMuchSmallerThan(value(i), reference, epsilon))
{
@@ -203,14 +203,14 @@ class CompressedStorage
protected:
inline void reallocate(size_t size)
inline void reallocate(std::size_t size)
{
Scalar* newValues = new Scalar[size];
int* newIndices = new int[size];
size_t copySize = std::min(size, m_size);
std::size_t copySize = std::min(size, m_size);
// copy
memcpy(newValues, m_values, copySize * sizeof(Scalar));
memcpy(newIndices, m_indices, copySize * sizeof(int));
std::memcpy(newValues, m_values, copySize * sizeof(Scalar));
std::memcpy(newIndices, m_indices, copySize * sizeof(int));
// delete old stuff
delete[] m_values;
delete[] m_indices;
@@ -222,8 +222,8 @@ class CompressedStorage
protected:
Scalar* m_values;
int* m_indices;
size_t m_size;
size_t m_allocatedSize;
std::size_t m_size;
std::size_t m_allocatedSize;
};

2
Eigen/src/Sparse/DynamicSparseMatrix.h
View File

@@ -212,7 +212,7 @@ class DynamicSparseMatrix
// remove all coefficients with innerCoord>=innerSize
// TODO
std::cerr << "not implemented yet\n";
exit(2);
std::exit(2);
}
if (m_data.size() != outerSize)
{

16
Eigen/src/Sparse/SparseMatrix.h
View File

@@ -122,7 +122,7 @@ class SparseMatrix
{
m_data.clear();
//if (m_outerSize)
memset(m_outerIndex, 0, (m_outerSize+1)*sizeof(int));
std::memset(m_outerIndex, 0, (m_outerSize+1)*sizeof(int));
// for (int i=0; i<m_outerSize; ++i)
// m_outerIndex[i] = 0;
// if (m_outerSize)
@@ -164,7 +164,7 @@ class SparseMatrix
{
ei_assert(m_data.index(m_data.size()-1)<inner && "wrong sorted insertion");
}
assert(size_t(m_outerIndex[outer+1]) == m_data.size());
assert(std::size_t(m_outerIndex[outer+1]) == m_data.size());
int id = m_outerIndex[outer+1];
++m_outerIndex[outer+1];
@@ -190,10 +190,10 @@ class SparseMatrix
}
m_outerIndex[outer+1] = m_outerIndex[outer];
}
assert(size_t(m_outerIndex[outer+1]) == m_data.size() && "invalid outer index");
size_t startId = m_outerIndex[outer];
// FIXME let's make sure sizeof(long int) == sizeof(size_t)
size_t id = m_outerIndex[outer+1];
assert(std::size_t(m_outerIndex[outer+1]) == m_data.size() && "invalid outer index");
std::size_t startId = m_outerIndex[outer];
// FIXME let's make sure sizeof(long int) == sizeof(std::size_t)
std::size_t id = m_outerIndex[outer+1];
++m_outerIndex[outer+1];
float reallocRatio = 1;
@@ -273,7 +273,7 @@ class SparseMatrix
m_outerIndex = new int [outerSize+1];
m_outerSize = outerSize;
}
memset(m_outerIndex, 0, (m_outerSize+1)*sizeof(int));
std::memset(m_outerIndex, 0, (m_outerSize+1)*sizeof(int));
}
void resizeNonZeros(int size)
{
@@ -324,7 +324,7 @@ class SparseMatrix
else
{
resize(other.rows(), other.cols());
memcpy(m_outerIndex, other.m_outerIndex, (m_outerSize+1)*sizeof(int));
std::memcpy(m_outerIndex, other.m_outerIndex, (m_outerSize+1)*sizeof(int));
m_data = other.m_data;
}
return *this;