apaam/mlpack
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

I had been approaching the wrong solution to the issue because they keep

Browse Source 
bringing me drinks.
This commit is contained in:
Ryan Curtin
2011-12-12 19:13:17 +00:00
parent ded6707e2f
commit acada435af
5 changed files with 212 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/mlpack/core/arma_extend/CMakeLists.txt
+3
View File
@@ -9,6 +9,9 @@ set(SOURCES
glue_ccov_proto.hpp
op_ccov_meat.hpp
op_ccov_proto.hpp
promote_type.hpp
traits.hpp
typedef.hpp
)
# add directory name to sources
src/mlpack/core/arma_extend/arma_extend.hpp
+5
View File
@@ -71,6 +71,11 @@ namespace arma {
#endif
namespace arma {
// u64
#include "typedef.hpp"
#include "traits.hpp"
#include "promote_type.hpp"
// ccov()
#include "op_ccov_proto.hpp"
#include "op_ccov_meat.hpp"
src/mlpack/core/arma_extend/promote_type.hpp
+109
View File
@@ -0,0 +1,109 @@
// Extra promote_type definitions until 64-bit index support is added to
// Armadillo. The syntax was changed for 2.1.91, so we need to be careful about
// how we do that.
#if ((ARMA_VERSION_MAJOR > 2)) || \
((ARMA_VERSION_MAJOR == 2) && (ARMA_VERSION_MINOR > 1)) || \
((ARMA_VERSION_MAJOR == 2) && (ARMA_VERSION_MINOR == 1) && \
(ARMA_VERSION_PATCH >= 91))
// The new syntax changed the name of 'promote_type' to 'is_promotable'. We
// have to update accordingly...
template<typename T> struct is_promotable<std::complex<T>, s64> : public is_promotable_ok { typedef std::complex<T> result; };
template<typename T> struct is_promotable<std::complex<T>, u64> : public is_promotable_ok { typedef std::complex<T> result; };
template<> struct is_promotable<double, s64 > : public is_promotable_ok { typedef double result; };
template<> struct is_promotable<double, u64 > : public is_promotable_ok { typedef double result; };
template<> struct is_promotable<float, s64> : public is_promotable_ok { typedef float result; };
template<> struct is_promotable<float, u64> : public is_promotable_ok { typedef float result; };
template<> struct is_promotable<s64, u64> : public is_promotable_ok { typedef s64 result; };
template<> struct is_promotable<s64, s32> : public is_promotable_ok { typedef s64 result; };
template<> struct is_promotable<s64, u32> : public is_promotable_ok { typedef s64 result; }; // float ?
template<> struct is_promotable<s64, s16> : public is_promotable_ok { typedef s64 result; };
template<> struct is_promotable<s64, u16> : public is_promotable_ok { typedef s64 result; };
template<> struct is_promotable<s64, s8 > : public is_promotable_ok { typedef s64 result; };
template<> struct is_promotable<s64, u8 > : public is_promotable_ok { typedef s64 result; };
template<> struct is_promotable<u64, s32> : public is_promotable_ok { typedef s64 result; }; // float ?
template<> struct is_promotable<u64, u32> : public is_promotable_ok { typedef u64 result; };
template<> struct is_promotable<u64, s16> : public is_promotable_ok { typedef s64 result; }; // float ?
template<> struct is_promotable<u64, u16> : public is_promotable_ok { typedef u64 result; };
template<> struct is_promotable<u64, s8 > : public is_promotable_ok { typedef s64 result; }; // float ?
template<> struct is_promotable<u64, u8 > : public is_promotable_ok { typedef u64 result; };
template<typename T> struct is_promotable<s64, std::complex<T> > : public is_promotable_ok { typedef std::complex<T> result; };
template<typename T> struct is_promotable<u64, std::complex<T> > : public is_promotable_ok { typedef std::complex<T> result; };
template<> struct is_promotable<s64 , double> : public is_promotable_ok { typedef double result; };
template<> struct is_promotable<u64 , double> : public is_promotable_ok { typedef double result; };
template<> struct is_promotable<s64, float> : public is_promotable_ok { typedef float result; };
template<> struct is_promotable<u64, float> : public is_promotable_ok { typedef float result; };
template<> struct is_promotable<u64, s64> : public is_promotable_ok { typedef s64 result; }; // float ?
template<> struct is_promotable<s32, s64> : public is_promotable_ok { typedef s64 result; };
template<> struct is_promotable<u32, s64> : public is_promotable_ok { typedef s64 result; }; // float ?
template<> struct is_promotable<s16, s64> : public is_promotable_ok { typedef s64 result; };
template<> struct is_promotable<u16, s64> : public is_promotable_ok { typedef s64 result; };
template<> struct is_promotable<s8 , s64> : public is_promotable_ok { typedef s64 result; };
template<> struct is_promotable<u8 , s64> : public is_promotable_ok { typedef s64 result; };
template<> struct is_promotable<s32, u64> : public is_promotable_ok { typedef s64 result; }; // float ?
template<> struct is_promotable<u32, u64> : public is_promotable_ok { typedef u64 result; };
template<> struct is_promotable<s16, u64> : public is_promotable_ok { typedef s64 result; }; // float ?
template<> struct is_promotable<u16, u64> : public is_promotable_ok { typedef u64 result; };
template<> struct is_promotable<s8 , u64> : public is_promotable_ok { typedef s64 result; }; // float ?
template<> struct is_promotable<u8 , u64> : public is_promotable_ok { typedef u64 result; };
#else
// The old syntax used the 'promote_type' struct. We just define all of these
// for u64 and s64.
template<typename T> struct promote_type<std::complex<T>, s64> : public promote_type_ok { typedef std::complex<T> result; };
template<typename T> struct promote_type<std::complex<T>, u64> : public promote_type_ok { typedef std::complex<T> result; };
template<> struct promote_type<double, s64 > : public promote_type_ok { typedef double result; };
template<> struct promote_type<double, u64 > : public promote_type_ok { typedef double result; };
template<> struct promote_type<float, s64> : public promote_type_ok { typedef float result; };
template<> struct promote_type<float, u64> : public promote_type_ok { typedef float result; };
template<> struct promote_type<s64, u64> : public promote_type_ok { typedef s64 result; };
template<> struct promote_type<s64, s32> : public promote_type_ok { typedef s64 result; };
template<> struct promote_type<s64, u32> : public promote_type_ok { typedef s64 result; }; // float ?
template<> struct promote_type<s64, s16> : public promote_type_ok { typedef s64 result; };
template<> struct promote_type<s64, u16> : public promote_type_ok { typedef s64 result; };
template<> struct promote_type<s64, s8 > : public promote_type_ok { typedef s64 result; };
template<> struct promote_type<s64, u8 > : public promote_type_ok { typedef s64 result; };
template<> struct promote_type<u64, s32> : public promote_type_ok { typedef s64 result; }; // float ?
template<> struct promote_type<u64, u32> : public promote_type_ok { typedef u64 result; };
template<> struct promote_type<u64, s16> : public promote_type_ok { typedef s64 result; }; // float ?
template<> struct promote_type<u64, u16> : public promote_type_ok { typedef u64 result; };
template<> struct promote_type<u64, s8 > : public promote_type_ok { typedef s64 result; }; // float ?
template<> struct promote_type<u64, u8 > : public promote_type_ok { typedef u64 result; };
template<typename T> struct promote_type<s64, std::complex<T> > : public promote_type_ok { typedef std::complex<T> result; };
template<typename T> struct promote_type<u64, std::complex<T> > : public promote_type_ok { typedef std::complex<T> result; };
template<> struct promote_type<s64 , double> : public promote_type_ok { typedef double result; };
template<> struct promote_type<u64 , double> : public promote_type_ok { typedef double result; };
template<> struct promote_type<s64, float> : public promote_type_ok { typedef float result; };
template<> struct promote_type<u64, float> : public promote_type_ok { typedef float result; };
template<> struct promote_type<u64, s64> : public promote_type_ok { typedef s64 result; }; // float ?
template<> struct promote_type<s32, s64> : public promote_type_ok { typedef s64 result; };
template<> struct promote_type<u32, s64> : public promote_type_ok { typedef s64 result; }; // float ?
template<> struct promote_type<s16, s64> : public promote_type_ok { typedef s64 result; };
template<> struct promote_type<u16, s64> : public promote_type_ok { typedef s64 result; };
template<> struct promote_type<s8 , s64> : public promote_type_ok { typedef s64 result; };
template<> struct promote_type<u8 , s64> : public promote_type_ok { typedef s64 result; };
template<> struct promote_type<s32, u64> : public promote_type_ok { typedef s64 result; }; // float ?
template<> struct promote_type<u32, u64> : public promote_type_ok { typedef u64 result; };
template<> struct promote_type<s16, u64> : public promote_type_ok { typedef s64 result; }; // float ?
template<> struct promote_type<u16, u64> : public promote_type_ok { typedef u64 result; };
template<> struct promote_type<s8 , u64> : public promote_type_ok { typedef s64 result; }; // float ?
template<> struct promote_type<u8 , u64> : public promote_type_ok { typedef u64 result; };
#endif
src/mlpack/core/arma_extend/traits.hpp
+26
View File
@@ -0,0 +1,26 @@
// Extra traits to support u64 and s64 until that patch is applied to the
// Armadillo sources.
#if ARMA_VERSION_MAJOR < 1 || \
(ARMA_VERSION_MAJOR == 1 && ARMA_VERSION_MINOR <= 2)
// For old Armadillo versions ( <= 1.2.0 ), all we have to do is define these
// two structs which say these element types are supported.
template<> struct isnt_supported_elem_type< u64 > : public isnt_supported_elem_type_false {};
template<> struct isnt_supported_elem_type< s64 > : public isnt_supported_elem_type_false {};
#else
// For new Armadillo versions ( > 1.2.0 ) we have to get a little bit more
// tricky. We will overload the values for the is_supported_elem_type
// structure, allowing us to redefine it to report success for u64s and s64s.
template<>
struct is_supported_elem_type<u64>
{
static const bool value = true;
};
template<>
struct is_supported_elem_type<s64>
{
static const bool value = true;
};
#endif
src/mlpack/core/arma_extend/typedef.hpp
+69
View File
@@ -0,0 +1,69 @@
// Extensions to typedef u64 and s64 until that support is added into
// Armadillo. We only need to typedef s64 on Armadillo > 1.2.0.
#if ((ARMA_VERSION_MAJOR > 1)) || \
((ARMA_VERSION_MAJOR == 1) && (ARMA_VERSION_MINOR > 2)) || \
((ARMA_VERSION_MAJOR == 1) && (ARMA_VERSION_MINOR == 2) && \
(ARMA_VERSION_PATCH > 0))
#ifndef ARMA_64BIT_WORD
// An unincluded header file typedefs u64 for us.
template<const bool size_t_is_greater_or_equal_to_8_bytes>
struct deduce_u64
{
};
template<>
struct deduce_u64<true>
{
typedef std::size_t u64;
static const u64 max = (sizeof(u64) >= 8) ? 0xFFFFFFFFFFFFFFFF : 0xFFFFFFFF; // check required for silly compilers
static const bool trunc = false;
};
template<>
struct deduce_u64<false>
{
#if (ULONG_MAX >= 0xFFFFFFFFFFFFFFFF)
typedef unsigned long u64;
static const u64 max = 0xFFFFFFFFFFFFFFFF;
static const bool trunc = false;
#elif defined(ULLONG_MAX)
typedef unsigned long long u64;
static const u64 max = 0xFFFFFFFFFFFFFFFF;
static const bool trunc = false;
#elif (_MSC_VER >= 1200)
//#elif (_MSC_VER >= 1310) && defined(_MSC_EXTENSIONS)
typedef unsigned __int64 u64;
static const u64 max = 0xFFFFFFFFFFFFFFFF;
static const bool trunc = false;
#else
#error "don't know how to typedef 'u64' on this system"
#endif
};
typedef deduce_u64<(sizeof(std::size_t) >= 8)>::u64 u64;
#endif
// We only need to typedef s64.
#if ULONG_MAX >= 0xffffffffffffffff
typedef long s64;
#elif ULLONG_MAX >= 0xffffffffffffffff
typedef long s64;
#else
#error "don't know how to typedef 's64' on this system"
#endif
#else
// We must typedef both u64 and s64.
#if ULONG_MAX >= 0xffffffffffffffff
typedef unsigned long u64;
typedef long s64;
#elif ULLONG_MAX >= 0xffffffffffffffff
typedef unsigned long long u64;
typedef long long s64;
#else
#error "don't know how to typedef 'u64' on this system"
#endif
#endif