diff options
author | Piotr Trojanek <piotr.trojanek@gmail.com> | 2010-02-10 13:24:47 +0100 |
---|---|---|
committer | Piotr Trojanek <piotr.trojanek@gmail.com> | 2010-02-10 13:24:47 +0100 |
commit | 1701a5d1f83028100799c7dabe55fcd767028e3d (patch) | |
tree | 85cdd84216d7c11adf4d6410f838568ee677defb /Eigen | |
parent | ae0a17d30be41bf66a2915ce7b059f818a820241 (diff) |
std:: namespace fixup for more restricive compilers such as QNX's QCC
Diffstat (limited to 'Eigen')
-rw-r--r-- | Eigen/src/Core/MathFunctions.h | 4 | ||||
-rw-r--r-- | Eigen/src/Core/MatrixStorage.h | 2 | ||||
-rw-r--r-- | Eigen/src/Core/products/SelfadjointMatrixVector.h | 14 | ||||
-rw-r--r-- | Eigen/src/Core/util/Memory.h | 46 |
4 files changed, 33 insertions, 33 deletions
diff --git a/Eigen/src/Core/MathFunctions.h b/Eigen/src/Core/MathFunctions.h index 1a4561555..c97a68e50 100644 --- a/Eigen/src/Core/MathFunctions.h +++ b/Eigen/src/Core/MathFunctions.h @@ -52,7 +52,7 @@ inline int ei_real(int x) { return x; } inline int& ei_real_ref(int& x) { return x; } inline int ei_imag(int) { return 0; } inline int ei_conj(int x) { return x; } -inline int ei_abs(int x) { return abs(x); } +inline int ei_abs(int x) { return std::abs(x); } inline int ei_abs2(int x) { return x*x; } inline int ei_sqrt(int) { ei_assert(false); return 0; } inline int ei_exp(int) { ei_assert(false); return 0; } @@ -78,7 +78,7 @@ inline int ei_pow(int x, int y) template<> inline int ei_random(int a, int b) { // We can't just do rand()%n as only the high-order bits are really random - return a + static_cast<int>((b-a+1) * (rand() / (RAND_MAX + 1.0))); + return a + static_cast<int>((b-a+1) * (std::rand() / (RAND_MAX + 1.0))); } template<> inline int ei_random() { diff --git a/Eigen/src/Core/MatrixStorage.h b/Eigen/src/Core/MatrixStorage.h index 046670452..22da59f3b 100644 --- a/Eigen/src/Core/MatrixStorage.h +++ b/Eigen/src/Core/MatrixStorage.h @@ -53,7 +53,7 @@ struct ei_matrix_array #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) #else #define EIGEN_MAKE_UNALIGNED_ARRAY_ASSERT(sizemask) \ - ei_assert((reinterpret_cast<size_t>(array) & sizemask) == 0 \ + ei_assert((reinterpret_cast<std::size_t>(array) & sizemask) == 0 \ && "this assertion is explained here: " \ "http://eigen.tuxfamily.org/dox/UnalignedArrayAssert.html" \ " **** READ THIS WEB PAGE !!! ****"); diff --git a/Eigen/src/Core/products/SelfadjointMatrixVector.h b/Eigen/src/Core/products/SelfadjointMatrixVector.h index 1c48208b3..8fd09ac95 100644 --- a/Eigen/src/Core/products/SelfadjointMatrixVector.h +++ b/Eigen/src/Core/products/SelfadjointMatrixVector.h @@ -83,10 +83,10 @@ static EIGEN_DONT_INLINE void ei_product_selfadjoint_vector( Scalar t3 = 0; Packet ptmp3 = ei_pset1(t3); - size_t starti = FirstTriangular ? 0 : j+2; - size_t endi = FirstTriangular ? j : size; - size_t alignedEnd = starti; - size_t alignedStart = (starti) + ei_first_aligned(&res[starti], endi-starti); + std::size_t starti = FirstTriangular ? 0 : j+2; + std::size_t endi = FirstTriangular ? j : size; + std::size_t alignedEnd = starti; + std::size_t alignedStart = (starti) + ei_first_aligned(&res[starti], endi-starti); alignedEnd = alignedStart + ((endi-alignedStart)/(PacketSize))*(PacketSize); res[j] += cj0.pmul(A0[j], t0); @@ -102,7 +102,7 @@ static EIGEN_DONT_INLINE void ei_product_selfadjoint_vector( t2 += cj1.pmul(A0[j+1], rhs[j+1]); } - for (size_t i=starti; i<alignedStart; ++i) + for (std::size_t i=starti; i<alignedStart; ++i) { res[i] += t0 * A0[i] + t1 * A1[i]; t2 += ei_conj(A0[i]) * rhs[i]; @@ -114,7 +114,7 @@ static EIGEN_DONT_INLINE void ei_product_selfadjoint_vector( const Scalar* EIGEN_RESTRICT a1It = A1 + alignedStart; const Scalar* EIGEN_RESTRICT rhsIt = rhs + alignedStart; Scalar* EIGEN_RESTRICT resIt = res + alignedStart; - for (size_t i=alignedStart; i<alignedEnd; i+=PacketSize) + for (std::size_t i=alignedStart; i<alignedEnd; i+=PacketSize) { Packet A0i = ei_ploadu(a0It); a0It += PacketSize; Packet A1i = ei_ploadu(a1It); a1It += PacketSize; @@ -126,7 +126,7 @@ static EIGEN_DONT_INLINE void ei_product_selfadjoint_vector( ptmp3 = cj1.pmadd(A1i, Bi, ptmp3); ei_pstore(resIt,Xi); resIt += PacketSize; } - for (size_t i=alignedEnd; i<endi; i++) + for (std::size_t i=alignedEnd; i<endi; i++) { res[i] += cj0.pmul(A0[i], t0) + cj0.pmul(A1[i],t1); t2 += cj1.pmul(A0[i], rhs[i]); diff --git a/Eigen/src/Core/util/Memory.h b/Eigen/src/Core/util/Memory.h index bfc6ff686..ebc367424 100644 --- a/Eigen/src/Core/util/Memory.h +++ b/Eigen/src/Core/util/Memory.h @@ -59,10 +59,10 @@ * Fast, but wastes 16 additional bytes of memory. * Does not throw any exception. */ -inline void* ei_handmade_aligned_malloc(size_t size) +inline void* ei_handmade_aligned_malloc(std::size_t size) { - void *original = malloc(size+16); - void *aligned = reinterpret_cast<void*>((reinterpret_cast<size_t>(original) & ~(size_t(15))) + 16); + void *original = std::malloc(size+16); + void *aligned = reinterpret_cast<void*>((reinterpret_cast<std::size_t>(original) & ~(std::size_t(15))) + 16); *(reinterpret_cast<void**>(aligned) - 1) = original; return aligned; } @@ -71,13 +71,13 @@ inline void* ei_handmade_aligned_malloc(size_t size) inline void ei_handmade_aligned_free(void *ptr) { if(ptr) - free(*(reinterpret_cast<void**>(ptr) - 1)); + std::free(*(reinterpret_cast<void**>(ptr) - 1)); } /** \internal allocates \a size bytes. The returned pointer is guaranteed to have 16 bytes alignment. * On allocation error, the returned pointer is null, and if exceptions are enabled then a std::bad_alloc is thrown. */ -inline void* ei_aligned_malloc(size_t size) +inline void* ei_aligned_malloc(std::size_t size) { #ifdef EIGEN_NO_MALLOC ei_assert(false && "heap allocation is forbidden (EIGEN_NO_MALLOC is defined)"); @@ -108,18 +108,18 @@ inline void* ei_aligned_malloc(size_t size) /** allocates \a size bytes. If Align is true, then the returned ptr is 16-byte-aligned. * On allocation error, the returned pointer is null, and if exceptions are enabled then a std::bad_alloc is thrown. */ -template<bool Align> inline void* ei_conditional_aligned_malloc(size_t size) +template<bool Align> inline void* ei_conditional_aligned_malloc(std::size_t size) { return ei_aligned_malloc(size); } -template<> inline void* ei_conditional_aligned_malloc<false>(size_t size) +template<> inline void* ei_conditional_aligned_malloc<false>(std::size_t size) { #ifdef EIGEN_NO_MALLOC ei_assert(false && "heap allocation is forbidden (EIGEN_NO_MALLOC is defined)"); #endif - void *result = malloc(size); + void *result = std::malloc(size); #ifdef EIGEN_EXCEPTIONS if(!result) throw std::bad_alloc(); #endif @@ -129,9 +129,9 @@ template<> inline void* ei_conditional_aligned_malloc<false>(size_t size) /** \internal construct the elements of an array. * The \a size parameter tells on how many objects to call the constructor of T. */ -template<typename T> inline T* ei_construct_elements_of_array(T *ptr, size_t size) +template<typename T> inline T* ei_construct_elements_of_array(T *ptr, std::size_t size) { - for (size_t i=0; i < size; ++i) ::new (ptr + i) T; + for (std::size_t i=0; i < size; ++i) ::new (ptr + i) T; return ptr; } @@ -139,13 +139,13 @@ template<typename T> inline T* ei_construct_elements_of_array(T *ptr, size_t siz * On allocation error, the returned pointer is undefined, but if exceptions are enabled then a std::bad_alloc is thrown. * The default constructor of T is called. */ -template<typename T> inline T* ei_aligned_new(size_t size) +template<typename T> inline T* ei_aligned_new(std::size_t size) { T *result = reinterpret_cast<T*>(ei_aligned_malloc(sizeof(T)*size)); return ei_construct_elements_of_array(result, size); } -template<typename T, bool Align> inline T* ei_conditional_aligned_new(size_t size) +template<typename T, bool Align> inline T* ei_conditional_aligned_new(std::size_t size) { T *result = reinterpret_cast<T*>(ei_conditional_aligned_malloc<Align>(sizeof(T)*size)); return ei_construct_elements_of_array(result, size); @@ -179,13 +179,13 @@ template<bool Align> inline void ei_conditional_aligned_free(void *ptr) template<> inline void ei_conditional_aligned_free<false>(void *ptr) { - free(ptr); + std::free(ptr); } /** \internal destruct the elements of an array. * The \a size parameters tells on how many objects to call the destructor of T. */ -template<typename T> inline void ei_destruct_elements_of_array(T *ptr, size_t size) +template<typename T> inline void ei_destruct_elements_of_array(T *ptr, std::size_t size) { // always destruct an array starting from the end. while(size) ptr[--size].~T(); @@ -194,7 +194,7 @@ template<typename T> inline void ei_destruct_elements_of_array(T *ptr, size_t si /** \internal delete objects constructed with ei_aligned_new * The \a size parameters tells on how many objects to call the destructor of T. */ -template<typename T> inline void ei_aligned_delete(T *ptr, size_t size) +template<typename T> inline void ei_aligned_delete(T *ptr, std::size_t size) { ei_destruct_elements_of_array<T>(ptr, size); ei_aligned_free(ptr); @@ -203,7 +203,7 @@ template<typename T> inline void ei_aligned_delete(T *ptr, size_t size) /** \internal delete objects constructed with ei_conditional_aligned_new * The \a size parameters tells on how many objects to call the destructor of T. */ -template<typename T, bool Align> inline void ei_conditional_aligned_delete(T *ptr, size_t size) +template<typename T, bool Align> inline void ei_conditional_aligned_delete(T *ptr, std::size_t size) { ei_destruct_elements_of_array<T>(ptr, size); ei_conditional_aligned_free<Align>(ptr); @@ -282,23 +282,23 @@ inline static Integer ei_first_aligned(const Scalar* array, Integer size) #if EIGEN_ALIGN #ifdef EIGEN_EXCEPTIONS #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \ - void* operator new(size_t size, const std::nothrow_t&) throw() { \ + void* operator new(std::size_t size, const std::nothrow_t&) throw() { \ try { return Eigen::ei_conditional_aligned_malloc<NeedsToAlign>(size); } \ catch (...) { return 0; } \ return 0; \ } #else #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \ - void* operator new(size_t size, const std::nothrow_t&) throw() { \ + void* operator new(std::size_t size, const std::nothrow_t&) throw() { \ return Eigen::ei_conditional_aligned_malloc<NeedsToAlign>(size); \ } #endif #define EIGEN_MAKE_ALIGNED_OPERATOR_NEW_IF(NeedsToAlign) \ - void *operator new(size_t size) { \ + void *operator new(std::size_t size) { \ return Eigen::ei_conditional_aligned_malloc<NeedsToAlign>(size); \ } \ - void *operator new[](size_t size) { \ + void *operator new[](std::size_t size) { \ return Eigen::ei_conditional_aligned_malloc<NeedsToAlign>(size); \ } \ void operator delete(void * ptr) throw() { Eigen::ei_conditional_aligned_free<NeedsToAlign>(ptr); } \ @@ -306,7 +306,7 @@ inline static Integer ei_first_aligned(const Scalar* array, Integer size) /* in-place new and delete. since (at least afaik) there is no actual */ \ /* memory allocated we can safely let the default implementation handle */ \ /* this particular case. */ \ - static void *operator new(size_t size, void *ptr) { return ::operator new(size,ptr); } \ + static void *operator new(std::size_t size, void *ptr) { return ::operator new(size,ptr); } \ void operator delete(void * memory, void *ptr) throw() { return ::operator delete(memory,ptr); } \ /* nothrow-new (returns zero instead of std::bad_alloc) */ \ EIGEN_MAKE_ALIGNED_OPERATOR_NEW_NOTHROW(NeedsToAlign) \ @@ -340,8 +340,8 @@ template<class T> class aligned_allocator { public: - typedef size_t size_type; - typedef ptrdiff_t difference_type; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; typedef T* pointer; typedef const T* const_pointer; typedef T& reference; |