Undo move to numpy_numarray.

1 files changed, 0 insertions, 449 deletions

diff --git a/numpy/numarray/numpy_numarray/nummacro.h b/numpy/numarray/numpy_numarray/nummacro.h
deleted file mode 100644
index 7bcc250a9..000000000
--- a/numpy/numarray/numpy_numarray/nummacro.h
+++ /dev/null
@@ -1,449 +0,0 @@
-/* Primarily for compatibility with numarray C-API */
-
-#if !defined(_ndarraymacro)
-#define _ndarraymacro
-
-/* The structs defined here are private implementation details of numarray
-which are subject to change w/o notice.
-*/
- 
-#define PY_BOOL_CHAR "b"
-#define PY_INT8_CHAR "b"
-#define PY_INT16_CHAR "h"
-#define PY_INT32_CHAR "i"
-#define PY_FLOAT32_CHAR "f"
-#define PY_FLOAT64_CHAR "d"
-#define PY_UINT8_CHAR "h"
-#define PY_UINT16_CHAR "i"
-#define PY_UINT32_CHAR "i" /* Unless longer int available */
-#define PY_COMPLEX64_CHAR "D"
-#define PY_COMPLEX128_CHAR "D"
-
-#define PY_LONG_CHAR "l"
-#define PY_LONG_LONG_CHAR "L"
-
-#define pyFPE_DIVIDE_BY_ZERO  1
-#define pyFPE_OVERFLOW        2
-#define pyFPE_UNDERFLOW       4
-#define pyFPE_INVALID         8
-
-#define isNonZERO(x) (x != 0) /* to convert values to boolean 1's or 0's */
-
-typedef enum
-{
-	NUM_CONTIGUOUS=1,
-	NUM_NOTSWAPPED=2,
-	NUM_ALIGNED=4,
-	NUM_WRITABLE=8,
-	NUM_COPY=16,
-
-	NUM_C_ARRAY  = (NUM_CONTIGUOUS | NUM_ALIGNED | NUM_NOTSWAPPED),
-	NUM_UNCONVERTED = 0
-} NumRequirements;
-
-#define UNCONVERTED 0
-#define C_ARRAY     (NUM_CONTIGUOUS | NUM_NOTSWAPPED | NUM_ALIGNED)
-
-#define MUST_BE_COMPUTED 2   
-
-#define NUM_FLOORDIVIDE(a,b,out) (out) = floor((a)/(b))
-
-#define NA_Begin() Py_Initialize(); import_libnumarray();
-#define NA_End()   NA_Done(); Py_Finalize();
-
-#define NA_OFFSETDATA(num) ((void *) PyArray_DATA(num))
-
-/* unaligned NA_COPY functions */
-#define NA_COPY1(i, o)  (*(o) = *(i))
-#define NA_COPY2(i, o)  NA_COPY1(i, o), NA_COPY1(i+1, o+1)
-#define NA_COPY4(i, o)  NA_COPY2(i, o), NA_COPY2(i+2, o+2)
-#define NA_COPY8(i, o)  NA_COPY4(i, o), NA_COPY4(i+4, o+4)
-#define NA_COPY16(i, o) NA_COPY8(i, o), NA_COPY8(i+8, o+8)
-
-/* byteswapping macros: these fail if i==o */
-#define NA_SWAP1(i, o)  NA_COPY1(i, o)
-#define NA_SWAP2(i, o)  NA_SWAP1(i, o+1), NA_SWAP1(i+1, o)
-#define NA_SWAP4(i, o)  NA_SWAP2(i, o+2), NA_SWAP2(i+2, o)
-#define NA_SWAP8(i, o)  NA_SWAP4(i, o+4), NA_SWAP4(i+4, o)
-#define NA_SWAP16(i, o) NA_SWAP8(i, o+8), NA_SWAP8(i+8, o)
-
-/* complex byteswaps must swap each part (real, imag) independently */
-#define NA_COMPLEX_SWAP8(i, o)  NA_SWAP4(i, o), NA_SWAP4(i+4, o+4)
-#define NA_COMPLEX_SWAP16(i, o) NA_SWAP8(i, o), NA_SWAP8(i+8, o+8)
-
-/* byteswapping macros:  these work even if i == o */
-#define NA_TSWAP1(i, o, t) NA_COPY1(i, t), NA_SWAP1(t, o)
-#define NA_TSWAP2(i, o, t) NA_COPY2(i, t), NA_SWAP2(t, o)
-#define NA_TSWAP4(i, o, t) NA_COPY4(i, t), NA_SWAP4(t, o)
-#define NA_TSWAP8(i, o, t) NA_COPY8(i, t), NA_SWAP8(t, o)
-
-/* fast copy functions for %N aligned i and o */
-#define NA_ACOPY1(i, o) (((Int8    *)o)[0]   = ((Int8    *)i)[0])
-#define NA_ACOPY2(i, o) (((Int16   *)o)[0]   = ((Int16   *)i)[0])
-#define NA_ACOPY4(i, o) (((Int32   *)o)[0]   = ((Int32   *)i)[0])
-#define NA_ACOPY8(i, o) (((Float64 *)o)[0]   = ((Float64 *)i)[0])
-#define NA_ACOPY16(i, o) (((Complex64 *)o)[0]   = ((Complex64 *)i)[0])
-
-/* from here down, type("ai") is NDInfo*  */
-
-#define NA_PTR(ai)   ((char *) NA_OFFSETDATA((ai)))
-#define NA_PTR1(ai, i)       (NA_PTR(ai) +                                   \
-                              (i)*(ai)->strides[0])
-#define NA_PTR2(ai, i, j)    (NA_PTR(ai) +                                   \
-                              (i)*(ai)->strides[0] +                         \
-                              (j)*(ai)->strides[1])
-#define NA_PTR3(ai, i, j, k) (NA_PTR(ai) +                                   \
-                              (i)*(ai)->strides[0] +                         \
-                              (j)*(ai)->strides[1] +                         \
-                              (k)*(ai)->strides[2])
-
-#define NA_SET_TEMP(ai, type, v) (((type *) &__temp__)[0] = v)
-
-#define NA_SWAPComplex64 NA_COMPLEX_SWAP16
-#define NA_SWAPComplex64_ NA_COMPLEX_SWAP16
-#define NA_SWAPComplex32 NA_COMPLEX_SWAP8
-#define NA_SWAPFloat64   NA_SWAP8
-#define NA_SWAPFloat32   NA_SWAP4
-#define NA_SWAPInt64     NA_SWAP8
-#define NA_SWAPUInt64    NA_SWAP8
-#define NA_SWAPInt32     NA_SWAP4
-#define NA_SWAPUInt32    NA_SWAP4
-#define NA_SWAPInt16     NA_SWAP2
-#define NA_SWAPUInt16    NA_SWAP2
-#define NA_SWAPInt8      NA_SWAP1
-#define NA_SWAPUInt8     NA_SWAP1
-#define NA_SWAPBool      NA_SWAP1
-
-#define NA_COPYComplex64 NA_COPY16
-#define NA_COPYComplex64_ NA_COPY16
-#define NA_COPYComplex32 NA_COPY8
-#define NA_COPYFloat64   NA_COPY8
-#define NA_COPYFloat32   NA_COPY4
-#define NA_COPYInt64     NA_COPY8
-#define NA_COPYUInt64    NA_COPY8
-#define NA_COPYInt32     NA_COPY4
-#define NA_COPYUInt32    NA_COPY4
-#define NA_COPYInt16     NA_COPY2
-#define NA_COPYUInt16    NA_COPY2
-#define NA_COPYInt8      NA_COPY1
-#define NA_COPYUInt8     NA_COPY1
-#define NA_COPYBool      NA_COPY1
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-#define _makeGetPb(type)		\
-static type _NA_GETPb_##type(char *ptr)	\
-{						\
-	type temp;				\
-	NA_SWAP##type(ptr, (char *)&temp);	\
-	return temp;				\
-}
-
-#define _makeGetPa(type)	             	\
-static type _NA_GETPa_##type(char *ptr)         \
-{						\
-	type temp;				\
-	NA_COPY##type(ptr, (char *)&temp);	\
-	return temp;				\
-}
-
-_makeGetPb(Complex64_)
-_makeGetPb(Complex32)
-_makeGetPb(Float64)
-_makeGetPb(Float32)
-_makeGetPb(Int64)
-_makeGetPb(UInt64)
-_makeGetPb(Int32)
-_makeGetPb(UInt32)
-_makeGetPb(Int16)
-_makeGetPb(UInt16)
-_makeGetPb(Int8)
-_makeGetPb(UInt8)
-_makeGetPb(Bool)
-
-_makeGetPa(Complex64_)
-_makeGetPa(Complex32)
-_makeGetPa(Float64)
-_makeGetPa(Float32)
-_makeGetPa(Int64)
-_makeGetPa(UInt64)
-_makeGetPa(Int32)
-_makeGetPa(UInt32)
-_makeGetPa(Int16)
-_makeGetPa(UInt16)
-_makeGetPa(Int8)
-_makeGetPa(UInt8)
-_makeGetPa(Bool)
-
-#undef _makeGetPb
-#undef _makeGetPa
-
-#define _makeSetPb(type)		\
-static void _NA_SETPb_##type(char *ptr, type v)	\
-{						\
-	NA_SWAP##type(((char *)&v), ptr);	\
-	return;					\
-}
-
-#define _makeSetPa(type) \
-static void _NA_SETPa_##type(char *ptr, type v)	\
-{						\
-	NA_COPY##type(((char *)&v), ptr);	\
-	return;					\
-}
-
-_makeSetPb(Complex64_)
-_makeSetPb(Complex32)
-_makeSetPb(Float64)
-_makeSetPb(Float32)
-_makeSetPb(Int64)
-_makeSetPb(UInt64)
-_makeSetPb(Int32)
-_makeSetPb(UInt32)
-_makeSetPb(Int16)
-_makeSetPb(UInt16)
-_makeSetPb(Int8)
-_makeSetPb(UInt8)
-_makeSetPb(Bool)
-
-_makeSetPa(Complex64_)
-_makeSetPa(Complex32)
-_makeSetPa(Float64)
-_makeSetPa(Float32)
-_makeSetPa(Int64)
-_makeSetPa(UInt64)
-_makeSetPa(Int32)
-_makeSetPa(UInt32)
-_makeSetPa(Int16)
-_makeSetPa(UInt16)
-_makeSetPa(Int8)
-_makeSetPa(UInt8)
-_makeSetPa(Bool)
-
-#undef _makeSetPb
-#undef _makeSetPa
-
-#ifdef __cplusplus
-	}
-#endif
-
-/* ========================== ptr get/set ================================ */
-
-/* byteswapping */
-#define NA_GETPb(ai, type, ptr) _NA_GETPb_##type(ptr)
-
-/* aligning */
-#define NA_GETPa(ai, type, ptr) _NA_GETPa_##type(ptr)
-
-/* fast (aligned, !byteswapped) */
-#define NA_GETPf(ai, type, ptr) (*((type *) (ptr)))
-
-#define NA_GETP(ai, type, ptr)                                                \
-   (PyArray_ISCARRAY(ai) ? NA_GETPf(ai, type, ptr)                            \
-                   : (PyArray_ISBYTESWAPPED(ai) ?                             \
-                                      NA_GETPb(ai, type, ptr)                 \
-                                    : NA_GETPa(ai, type, ptr)))
-
-/* NOTE:  NA_SET* macros cannot be used as values. */
-
-/* byteswapping */
-#define NA_SETPb(ai, type, ptr, v) _NA_SETPb_##type(ptr, v)
-
-/* aligning */
-#define NA_SETPa(ai, type, ptr, v) _NA_SETPa_##type(ptr, v)
-
-/* fast (aligned, !byteswapped) */
-#define NA_SETPf(ai, type, ptr, v) ((*((type *) ptr)) = (v))
-
-#define NA_SETP(ai, type, ptr, v)                                             \
-    if (PyArray_ISCARRAY(ai)) {                                               \
-         NA_SETPf((ai), type, (ptr), (v));                                    \
-    } else if (PyArray_ISBYTESWAPPED(ai)) {                                   \
-	 NA_SETPb((ai), type, (ptr), (v));                                    \
-    } else                                                                    \
-         NA_SETPa((ai), type, (ptr), (v))
-
-/* ========================== 1 index get/set ============================ */
-
-/* byteswapping */
-#define NA_GET1b(ai, type, i)    NA_GETPb(ai, type, NA_PTR1(ai, i))
-/* aligning */
-#define NA_GET1a(ai, type, i)    NA_GETPa(ai, type, NA_PTR1(ai, i))
-/* fast (aligned, !byteswapped) */
-#define NA_GET1f(ai, type, i)    NA_GETPf(ai, type, NA_PTR1(ai, i))
-/* testing */
-#define NA_GET1(ai, type, i)     NA_GETP(ai, type, NA_PTR1(ai, i))
-
-/* byteswapping */
-#define NA_SET1b(ai, type, i, v) NA_SETPb(ai, type, NA_PTR1(ai, i), v)
-/* aligning */
-#define NA_SET1a(ai, type, i, v) NA_SETPa(ai, type, NA_PTR1(ai, i), v)
-/* fast (aligned, !byteswapped) */
-#define NA_SET1f(ai, type, i, v) NA_SETPf(ai, type, NA_PTR1(ai, i), v)
-/* testing */
-#define NA_SET1(ai, type, i, v)  NA_SETP(ai, type,  NA_PTR1(ai, i), v)
-
-/* ========================== 2 index get/set ============================= */
-
-/* byteswapping */
-#define NA_GET2b(ai, type, i, j)    NA_GETPb(ai, type, NA_PTR2(ai, i, j))
-/* aligning */
-#define NA_GET2a(ai, type, i, j)    NA_GETPa(ai, type, NA_PTR2(ai, i, j))
-/* fast (aligned, !byteswapped) */
-#define NA_GET2f(ai, type, i, j)    NA_GETPf(ai, type, NA_PTR2(ai, i, j))
-/* testing */
-#define NA_GET2(ai, type, i, j)     NA_GETP(ai, type, NA_PTR2(ai, i, j))
-
-/* byteswapping */
-#define NA_SET2b(ai, type, i, j, v) NA_SETPb(ai, type, NA_PTR2(ai, i, j), v)
-/* aligning */
-#define NA_SET2a(ai, type, i, j, v) NA_SETPa(ai, type, NA_PTR2(ai, i, j), v)
-/* fast (aligned, !byteswapped) */
-#define NA_SET2f(ai, type, i, j, v) NA_SETPf(ai, type, NA_PTR2(ai, i, j), v)
-
-#define NA_SET2(ai, type, i, j,  v)  NA_SETP(ai, type,  NA_PTR2(ai, i, j), v)
-
-/* ========================== 3 index get/set ============================= */
-
-/* byteswapping */
-#define NA_GET3b(ai, type, i, j, k)    NA_GETPb(ai, type, NA_PTR3(ai, i, j, k))
-/* aligning */
-#define NA_GET3a(ai, type, i, j, k)    NA_GETPa(ai, type, NA_PTR3(ai, i, j, k))
-/* fast (aligned, !byteswapped) */
-#define NA_GET3f(ai, type, i, j, k)    NA_GETPf(ai, type, NA_PTR3(ai, i, j, k))
-/* testing */
-#define NA_GET3(ai, type, i, j, k)     NA_GETP(ai, type, NA_PTR3(ai, i, j, k))
-
-/* byteswapping */
-#define NA_SET3b(ai, type, i, j, k, v)                                        \
-        NA_SETPb(ai, type, NA_PTR3(ai, i, j, k), v)
-/* aligning */
-#define NA_SET3a(ai, type, i, j, k, v)                                        \
-        NA_SETPa(ai, type, NA_PTR3(ai, i, j, k), v)
-/* fast (aligned, !byteswapped) */
-#define NA_SET3f(ai, type, i, j, k, v)                                        \
-        NA_SETPf(ai, type, NA_PTR3(ai, i, j, k), v)
-#define NA_SET3(ai, type, i, j, k, v)                                         \
-        NA_SETP(ai, type,  NA_PTR3(ai, i, j, k), v)
-
-/* ========================== 1D get/set ================================== */
-
-#define NA_GET1Db(ai, type, base, cnt, out)                                   \
-        { int i, stride = ai->strides[ai->nd-1];                              \
-           for(i=0; i<cnt; i++) {                                             \
-               out[i] = NA_GETPb(ai, type, base);                             \
-               base += stride;                                                \
-           }                                                                  \
-        } 
-
-#define NA_GET1Da(ai, type, base, cnt, out)                                   \
-        { int i, stride = ai->strides[ai->nd-1];                              \
-           for(i=0; i<cnt; i++) {                                             \
-               out[i] = NA_GETPa(ai, type, base);                             \
-               base += stride;                                                \
-           }                                                                  \
-        } 
-
-#define NA_GET1Df(ai, type, base, cnt, out)                                   \
-        { int i, stride = ai->strides[ai->nd-1];                              \
-           for(i=0; i<cnt; i++) {                                             \
-               out[i] = NA_GETPf(ai, type, base);                             \
-               base += stride;                                                \
-           }                                                                  \
-        } 
-
-#define NA_GET1D(ai, type, base, cnt, out)                                    \
-        if (PyArray_ISCARRAY(ai)) {                                           \
-	      NA_GET1Df(ai, type, base, cnt, out);                            \
-        } else if (PyArray_ISBYTESWAPPED(ai)) {                               \
-              NA_GET1Db(ai, type, base, cnt, out);                            \
-        } else {                                                              \
-              NA_GET1Da(ai, type, base, cnt, out);                            \
-	}
-        
-#define NA_SET1Db(ai, type, base, cnt, in)                                    \
-        { int i, stride = ai->strides[ai->nd-1];                              \
-           for(i=0; i<cnt; i++) {                                             \
-               NA_SETPb(ai, type, base, in[i]);                               \
-               base += stride;                                                \
-           }                                                                  \
-        }
-
-#define NA_SET1Da(ai, type, base, cnt, in)                                    \
-        { int i, stride = ai->strides[ai->nd-1];                              \
-           for(i=0; i<cnt; i++) {                                             \
-               NA_SETPa(ai, type, base, in[i]);                               \
-               base += stride;                                                \
-           }                                                                  \
-        }
-
-#define NA_SET1Df(ai, type, base, cnt, in)                                    \
-        { int i, stride = ai->strides[ai->nd-1];                              \
-           for(i=0; i<cnt; i++) {                                             \
-               NA_SETPf(ai, type, base, in[i]);                               \
-               base += stride;                                                \
-           }                                                                  \
-        }
-
-#define NA_SET1D(ai, type, base, cnt, out)                                    \
-        if (PyArray_ISCARRAY(ai)) {                                           \
-              NA_SET1Df(ai, type, base, cnt, out);                            \
-        } else if (PyArray_ISBYTESWAPPED(ai)) {                               \
-              NA_SET1Db(ai, type, base, cnt, out);                            \
-        } else {                                                              \
-	      NA_SET1Da(ai, type, base, cnt, out);                            \
-	}
-        
-/* ========================== utilities ================================== */
-
-#if !defined(MIN)
-#define MIN(x,y) (((x)<=(y)) ? (x) : (y))
-#endif
-
-#if !defined(MAX)
-#define MAX(x,y) (((x)>=(y)) ? (x) : (y))
-#endif
-
-#if !defined(ABS)
-#define ABS(x) (((x) >= 0) ? (x) : -(x))
-#endif
-
-#define ELEM(x)  (sizeof(x)/sizeof(x[0]))
-
-#define BOOLEAN_BITWISE_NOT(x) ((x) ^ 1)
-
-#define NA_NBYTES(a) (a->descr->elsize * NA_elements(a))
-
-#if defined(NA_SMP)
-#define BEGIN_THREADS Py_BEGIN_ALLOW_THREADS
-#define END_THREADS Py_END_ALLOW_THREADS
-#else
-#define BEGIN_THREADS
-#define END_THREADS
-#endif
-
-#if !defined(NA_isnan)
-
-#define U32(u) (* (Int32 *) &(u) )
-#define U64(u) (* (Int64 *) &(u) )
-
-#define NA_isnan32(u) \
-  ( (( U32(u) & 0x7f800000) == 0x7f800000)  && ((U32(u) & 0x007fffff) != 0)) ? 1:0
-
-#if !defined(_MSC_VER)
-#define NA_isnan64(u) \
-  ( (( U64(u) & 0x7ff0000000000000LL) == 0x7ff0000000000000LL)  && ((U64(u) & 0x000fffffffffffffLL) != 0)) ? 1:0
-#else
-#define NA_isnan64(u) \
-  ( (( U64(u) & 0x7ff0000000000000i64) == 0x7ff0000000000000i64)  && ((U64(u) & 0x000fffffffffffffi64) != 0)) ? 1:0
-#endif
-
-#define NA_isnanC32(u) (NA_isnan32(((Complex32 *)&(u))->r) || NA_isnan32(((Complex32 *)&(u))->i))
-#define NA_isnanC64(u) (NA_isnan64(((Complex64 *)&(u))->r) || NA_isnan64(((Complex64 *)&(u))->i))
-
-#endif /* NA_isnan */
-
-
-#endif /* _ndarraymacro */