[Numpy-svn] r3575 - trunk/numpy/doc/swig

numpy-svn@scip... numpy-svn@scip...
Wed Mar 14 14:57:30 CDT 2007


Author: wfspotz@sandia.gov
Date: 2007-03-14 14:57:23 -0500 (Wed, 14 Mar 2007)
New Revision: 3575

Modified:
   trunk/numpy/doc/swig/README
   trunk/numpy/doc/swig/Series.i
   trunk/numpy/doc/swig/numpy.i
   trunk/numpy/doc/swig/numpy_swig.html
   trunk/numpy/doc/swig/numpy_swig.txt
   trunk/numpy/doc/swig/series.cxx
   trunk/numpy/doc/swig/series.h
   trunk/numpy/doc/swig/testSeries.py
Log:
Added typemap signatures where the dimensions come before the data pointer

Modified: trunk/numpy/doc/swig/README
===================================================================
--- trunk/numpy/doc/swig/README	2007-03-14 15:47:12 UTC (rev 3574)
+++ trunk/numpy/doc/swig/README	2007-03-14 19:57:23 UTC (rev 3575)
@@ -1,4 +1,4 @@
-Notes for the swig_numpy/new directory
+Notes for the numpy/doc/swig directory
 ======================================
 
 This set of files is for developing and testing file numpy.i, which is
@@ -21,8 +21,12 @@
 
     (type* IN_ARRAY1, int DIM1)
     (type* IN_ARRAY2, int DIM1, int DIM2)
+    (int DIM1, type* IN_ARRAY1)``
+    (int DIM1, int DIM2, type* IN_ARRAY2)``
     (type* INPLACE_ARRAY1, int DIM1)
     (type* INPLACE_ARRAY2, int DIM1, int DIM2)
+    (int DIM1, type* INPLACE_ARRAY1)
+    (int DIM1, int DIM2, type* INPLACE_ARRAY2)
 
 which take a pointer to an array of type "type", whose length is
 specified by the integer(s) DIM1 (and DIM2).
@@ -30,10 +34,10 @@
 The objective for the IN_ARRAY signatures is for SWIG to generate
 python wrappers that take a container that constitutes a valid
 argument to the numpy array constructor, and can be used to build an
-array of type "type".  Currently, types "char", "unsigned char",
-"signed char", "short", "int", "long", "float", "double" and
-"PyObject" are supported, although only the types "short", "int",
-"long", "float" and "double" are tested.
+array of type "type".  Currently, types "signed char", "unsigned
+char", "short", "unsigned short", "int", "unsigned int", "long",
+"unsigned long", "long long", "unsigned long long", "float", "double",
+"PyObject" and "char" are supported and tested.
 
 The objective for the INPLACE_ARRAY signatures is for SWIG to generate
 python wrappers that accept a numpy array of any of the above-listed

Modified: trunk/numpy/doc/swig/Series.i
===================================================================
--- trunk/numpy/doc/swig/Series.i	2007-03-14 15:47:12 UTC (rev 3574)
+++ trunk/numpy/doc/swig/Series.i	2007-03-14 19:57:23 UTC (rev 3575)
@@ -6,124 +6,38 @@
 #include "series.h"
 %}
 
-// Get the Numeric typemaps
+// Get the NumPy typemaps
 %include "numpy.i"
 
 %init %{
   import_array();
 %}
 
-// Apply the Numeric typemaps for 1D input arrays
-%apply (signed char*        IN_ARRAY1, int DIM1)
-      {(signed char*        series,    int size)};
-%apply (unsigned char*      IN_ARRAY1, int DIM1)
-      {(unsigned char*      series,    int size)};
-%apply (short*              IN_ARRAY1, int DIM1)
-      {(short*              series,    int size)};
-%apply (unsigned short*     IN_ARRAY1, int DIM1)
-      {(unsigned short*     series,    int size)};
-%apply (int*                IN_ARRAY1, int DIM1)
-      {(int*                series,    int size)};
-%apply (unsigned int*       IN_ARRAY1, int DIM1)
-      {(unsigned int*       series,    int size)};
-%apply (long*               IN_ARRAY1, int DIM1)
-      {(long*               series,    int size)};
-%apply (unsigned long*      IN_ARRAY1, int DIM1)
-      {(unsigned long*      series,    int size)};
-%apply (long long*          IN_ARRAY1, int DIM1)
-      {(long long*          series,    int size)};
-%apply (unsigned long long* IN_ARRAY1, int DIM1)
-      {(unsigned long long* series,    int size)};
-%apply (float*              IN_ARRAY1, int DIM1)
-      {(float*              series,    int size)};
-%apply (double*             IN_ARRAY1, int DIM1)
-      {(double*             series,    int size)};
-%apply (long double*        IN_ARRAY1, int DIM1)
-      {(long double*        series,    int size)};
+%define %apply_numpy_typemaps(TYPE)
 
-// Apply the Numeric typemaps for 1D input/output arrays
-%apply (signed char*        INPLACE_ARRAY1, int DIM1)
-      {(signed char*        array,          int size)};
-%apply (unsigned char*      INPLACE_ARRAY1, int DIM1)
-      {(unsigned char*      array,          int size)};
-%apply (short*              INPLACE_ARRAY1, int DIM1)
-      {(short*              array,          int size)};
-%apply (unsigned short*     INPLACE_ARRAY1, int DIM1)
-      {(unsigned short*     array,          int size)};
-%apply (int*                INPLACE_ARRAY1, int DIM1)
-      {(int*                array,          int size)};
-%apply (unsigned int*       INPLACE_ARRAY1, int DIM1)
-      {(unsigned int*       array,          int size)};
-%apply (long*               INPLACE_ARRAY1, int DIM1)
-      {(long*               array,          int size)};
-%apply (unsigned long*      INPLACE_ARRAY1, int DIM1)
-      {(unsigned long*      array,          int size)};
-%apply (long long*          INPLACE_ARRAY1, int DIM1)
-      {(long long*          array,          int size)};
-%apply (unsigned long long* INPLACE_ARRAY1, int DIM1)
-      {(unsigned long long* array,          int size)};
-%apply (float*              INPLACE_ARRAY1, int DIM1)
-      {(float*              array,          int size)};
-%apply (double*             INPLACE_ARRAY1, int DIM1)
-      {(double*             array,          int size)};
-%apply (long double*        INPLACE_ARRAY1, int DIM1)
-      {(long double*        array,          int size)};
+%apply (TYPE* IN_ARRAY1, int DIM1) {(TYPE* series, int size)};
+%apply (TYPE* IN_ARRAY2, int DIM1, int DIM2) {(TYPE* matrix, int rows, int cols)};
+%apply (TYPE* INPLACE_ARRAY1, int DIM1) {(TYPE* array, int size)};
+%apply (TYPE* INPLACE_ARRAY2, int DIM1, int DIM2) {(TYPE* array, int rows, int cols)};
+%apply (int DIM1, TYPE* IN_ARRAY1) {(int size, TYPE* series)};
+%apply (int DIM1, int DIM2, TYPE* IN_ARRAY2) {(int rows, int cols, TYPE* matrix)};
+%apply (int DIM1, TYPE* INPLACE_ARRAY1) {(int size, TYPE* array)};
+%apply (int DIM1, int DIM2, TYPE* INPLACE_ARRAY2) {(int rows, int cols, TYPE* array)};
 
-// Apply the Numeric typemaps for 2D input arrays
-%apply (signed char*        IN_ARRAY2, int DIM1, int DIM2)
-      {(signed char*        matrix,    int rows, int cols)};
-%apply (unsigned char*      IN_ARRAY2, int DIM1, int DIM2)
-      {(unsigned char*      matrix,    int rows, int cols)};
-%apply (short*              IN_ARRAY2, int DIM1, int DIM2)
-      {(short*              matrix,    int rows, int cols)};
-%apply (unsigned short*     IN_ARRAY2, int DIM1, int DIM2)
-      {(unsigned short*     matrix,    int rows, int cols)};
-%apply (int*                IN_ARRAY2, int DIM1, int DIM2)
-      {(int*                matrix,    int rows, int cols)};
-%apply (unsigned int*       IN_ARRAY2, int DIM1, int DIM2)
-      {(unsigned int*       matrix,    int rows, int cols)};
-%apply (long*               IN_ARRAY2, int DIM1, int DIM2)
-      {(long*               matrix,    int rows, int cols)};
-%apply (unsigned long*      IN_ARRAY2, int DIM1, int DIM2)
-      {(unsigned long*      matrix,    int rows, int cols)};
-%apply (long long*          IN_ARRAY2, int DIM1, int DIM2)
-      {(long long*          matrix,    int rows, int cols)};
-%apply (unsigned long long* IN_ARRAY2, int DIM1, int DIM2)
-      {(unsigned long long* matrix,    int rows, int cols)};
-%apply (float*              IN_ARRAY2, int DIM1, int DIM2)
-      {(float*              matrix,    int rows, int cols)};
-%apply (double*             IN_ARRAY2, int DIM1, int DIM2)
-      {(double*             matrix,    int rows, int cols)};
-%apply (long double*        IN_ARRAY2, int DIM1, int DIM2)
-      {(long double*        matrix,    int rows, int cols)};
+%enddef    /* %apply_numpy_typemaps() macro */
 
-// Apply the Numeric typemaps for 2D input/output arrays
-%apply (signed char*        INPLACE_ARRAY2, int DIM1, int DIM2)
-      {(signed char*        array,          int rows, int cols)};
-%apply (unsigned char*      INPLACE_ARRAY2, int DIM1, int DIM2)
-      {(unsigned char*      array,          int rows, int cols)};
-%apply (short*              INPLACE_ARRAY2, int DIM1, int DIM2)
-      {(short*              array,          int rows, int cols)};
-%apply (unsigned short*     INPLACE_ARRAY2, int DIM1, int DIM2)
-      {(unsigned short*     array,          int rows, int cols)};
-%apply (int*                INPLACE_ARRAY2, int DIM1, int DIM2)
-      {(int*                array,          int rows, int cols)};
-%apply (unsigned int*       INPLACE_ARRAY2, int DIM1, int DIM2)
-      {(unsigned int*       array,          int rows, int cols)};
-%apply (long*               INPLACE_ARRAY2, int DIM1, int DIM2)
-      {(long*               array,          int rows, int cols)};
-%apply (unsigned long*      INPLACE_ARRAY2, int DIM1, int DIM2)
-      {(unsigned long*      array,          int rows, int cols)};
-%apply (long long*          INPLACE_ARRAY2, int DIM1, int DIM2)
-      {(long long*          array,          int rows, int cols)};
-%apply (unsigned long long* INPLACE_ARRAY2, int DIM1, int DIM2)
-      {(unsigned long long* array,          int rows, int cols)};
-%apply (float*              INPLACE_ARRAY2, int DIM1, int DIM2)
-      {(float*              array,          int rows, int cols)};
-%apply (double*             INPLACE_ARRAY2, int DIM1, int DIM2)
-      {(double*             array,          int rows, int cols)};
-%apply (long double*        INPLACE_ARRAY2, int DIM1, int DIM2)
-      {(long double*        array,          int rows, int cols)};
+%apply_numpy_typemaps(signed char       )
+%apply_numpy_typemaps(unsigned char     )
+%apply_numpy_typemaps(short             )
+%apply_numpy_typemaps(unsigned short    )
+%apply_numpy_typemaps(int               )
+%apply_numpy_typemaps(unsigned int      )
+%apply_numpy_typemaps(long              )
+%apply_numpy_typemaps(unsigned long     )
+%apply_numpy_typemaps(long long         )
+%apply_numpy_typemaps(unsigned long long)
+%apply_numpy_typemaps(float             )
+%apply_numpy_typemaps(double            )
 
 // Include the header file to be wrapped
 %include "series.h"

Modified: trunk/numpy/doc/swig/numpy.i
===================================================================
--- trunk/numpy/doc/swig/numpy.i	2007-03-14 15:47:12 UTC (rev 3574)
+++ trunk/numpy/doc/swig/numpy.i	2007-03-14 19:57:23 UTC (rev 3575)
@@ -304,6 +304,10 @@
  *     (TYPE* ARGOUT_ARRAY1[ANY])
  *     (TYPE* ARGOUT_ARRAY2[ANY][ANY])
  *
+ *     (int DIM1, TYPE* IN_ARRAY1)
+ *     (int DIM1, int DIM2, TYPE* IN_ARRAY2)
+ *     (int DIM1, TYPE* INPLACE_ARRAY1)
+ *
  * where "TYPE" is any type supported by the NumPy module.  In python,
  * the dimensions will not need to be specified.  The IN_ARRAYs can be
  * a numpy array or any sequence that can be converted to a numpy
@@ -314,32 +318,45 @@
  * These typemaps can be applied to existing functions using the
  * %apply directive:
  *
- *     %apply (double* IN_ARRAY1, int DIM1) {double* series, int length};
- *     double sum(double* series, int length);
+ *     %apply (double* IN_ARRAY1, int DIM1) {(double* series, int length)};
+ *     double prod(double* series, int length);
  *
- *     %apply (double* IN_ARRAY2, int DIM1, int DIM2) {double* mx, int rows, int cols};
+ *     %apply (double* IN_ARRAY2, int DIM1, int DIM2) {(double* mx, int rows, int cols)};
  *     double max(double* mx, int rows, int cols);
  *
- *     %apply (double* INPLACE_ARRAY1, int DIM1) {double* series, int length};
- *     void negate(double* series, int length);
+ *     %apply (double* INPLACE_ARRAY1, int DIM1) {(double* series, int length)};
+ *     void ones(double* series, int length);
  *
- *     %apply (double* INPLACE_ARRAY2, int DIM1, int DIM2) {double* mx, int rows, int cols};
- *     void normalize(double* mx, int rows, int cols);
+ *     %apply (double* INPLACE_ARRAY2, int DIM1, int DIM2) {(double* mx, int rows, int cols)};
+ *     void floor(double* mx, int rows, int cols);
  *
- *     %apply (double* ARGOUT_ARRAY1[ANY] {double series, int length};
+ *     %apply (double* ARGOUT_ARRAY1[ANY] {(double series, int length)};
  *     void negate(double* series, int length);
  *
- *     %apply (double* ARGOUT_ARRAY2[ANY][ANY]) {double* mx, int rows, int cols};
+ *     %apply (double* ARGOUT_ARRAY2[ANY][ANY]) {(double* mx, int rows, int cols)};
  *     void normalize(double* mx, int rows, int cols);
  *
+ *     %apply (int DIM1, double* IN_ARRAY1) {(int length, double* series)}
+ *     double sum(int length, double* series)
+ *
+ *     %apply (int DIM1, int DIM2, double* IN_ARRAY2) {(int rows, int cols, double* matrix)}
+ *     double min(int length, double* series)
+ *
+ *     %apply (int DIM1, double* INPLACE_ARRAY1) {(int length, double* series)}
+ *     double zeros(int length, double* series)
+ *
  * or directly with
  *
- *     double sum(double* IN_ARRAY1, int DIM1);
+ *     double prod(double* IN_ARRAY1, int DIM1);
  *     double max(double* IN_ARRAY2, int DIM1, int DIM2);
- *     void sum(double* INPLACE_ARRAY1, int DIM1);
- *     void sum(double* INPLACE_ARRAY2, int DIM1, int DIM2);
- *     void sum(double* ARGOUT_ARRAY1[ANY]);
- *     void sum(double* ARGOUT_ARRAY2[ANY][ANY]);
+ *     void ones(double* INPLACE_ARRAY1, int DIM1);
+ *     void floor(double* INPLACE_ARRAY2, int DIM1, int DIM2);
+ *     void negate(double* ARGOUT_ARRAY1[ANY]);
+ *     void normalize(double* ARGOUT_ARRAY2[ANY][ANY]);
+ *
+ *     double sum(int DIM1, double* IN_ARRAY1)
+ *     double min(int DIM1, int DIM2, double* IN_ARRAY2)
+ *     void zeros(int DIM1, double* INPLACE_ARRAY1)
  */
 
 %define %numpy_typemaps(TYPE, TYPECODE)
@@ -441,6 +458,55 @@
   }
 }
 
+/* Typemap suite for (int DIM1, TYPE* IN_ARRAY1)
+ */
+%typemap(in) (int DIM1, TYPE* IN_ARRAY1)
+             (PyArrayObject* array=NULL, int is_new_object=0) {
+  array = obj_to_array_contiguous_allow_conversion($input, TYPECODE, &is_new_object);
+  npy_intp size[1] = {-1};
+  if (!array || !require_dimensions(array, 1) || !require_size(array, size, 1)) SWIG_fail;
+  $1 = (int) array->dimensions[0];
+  $2 = (TYPE*) array->data;
+}
+%typemap(freearg) (int DIM1, TYPE* IN_ARRAY1) {
+  if (is_new_object$argnum && array$argnum) Py_DECREF(array$argnum);
+}
+
+/* Typemap suite for (int DIM1, int DIM2, TYPE* IN_ARRAY2)
+ */
+%typemap(in) (int DIM1, int DIM2, TYPE* IN_ARRAY2)
+             (PyArrayObject* array=NULL, int is_new_object=0) {
+  array = obj_to_array_contiguous_allow_conversion($input, TYPECODE, &is_new_object);
+  npy_intp size[2] = {-1,-1};
+  if (!array || !require_dimensions(array, 2) || !require_size(array, size, 1)) SWIG_fail;
+  $1 = (int) array->dimensions[0];
+  $2 = (int) array->dimensions[1];
+  $3 = (TYPE*) array->data;
+}
+%typemap(freearg) (int DIM1, int DIM2, TYPE* IN_ARRAY2) {
+  if (is_new_object$argnum && array$argnum) Py_DECREF(array$argnum);
+}
+
+/* Typemap suite for (int DIM1, TYPE* INPLACE_ARRAY1)
+ */
+%typemap(in) (int DIM1, TYPE* INPLACE_ARRAY1) (PyArrayObject* temp=NULL) {
+  temp = obj_to_array_no_conversion($input, TYPECODE);
+  if (!temp  || !require_contiguous(temp)) SWIG_fail;
+  $1 = 1;
+  for (int i=0; i<temp->nd; ++i) $1 *= temp->dimensions[i];
+  $2 = (TYPE*) temp->data;
+}
+
+/* Typemap suite for (int DIM1, int DIM2, TYPE* INPLACE_ARRAY2)
+ */
+%typemap(in) (int DIM1, int DIM2, TYPE* INPLACE_ARRAY2) (PyArrayObject* temp=NULL) {
+  temp = obj_to_array_no_conversion($input, TYPECODE);
+  if (!temp || !require_contiguous(temp)) SWIG_fail;
+  $1 = (int) temp->dimensions[0];
+  $2 = (int) temp->dimensions[1];
+  $3 = (TYPE*) temp->data;
+}
+
 %enddef    /* %numpy_typemaps() macro */
 
 

Modified: trunk/numpy/doc/swig/numpy_swig.html
===================================================================
--- trunk/numpy/doc/swig/numpy_swig.html	2007-03-14 15:47:12 UTC (rev 3574)
+++ trunk/numpy/doc/swig/numpy_swig.html	2007-03-14 19:57:23 UTC (rev 3575)
@@ -351,9 +351,16 @@
 <a class="reference" href="http://www.swig.org">SWIG</a> interface file would need the following:</p>
 <pre class="literal-block">
 %{
+#define SWIG_FILE_WITH_INIT
 #include &quot;rms.h&quot;
 %}
+
 %include &quot;numpy.i&quot;
+
+%init %{
+import_array();
+%}
+
 %apply (double* IN_ARRAY1, int DIM1) {(double* seq, int n)};
 %include &quot;rms.h&quot;
 </pre>
@@ -365,19 +372,30 @@
 is an input array of one dimension and that the <tt class="docutils literal"><span class="pre">int</span></tt> represents
 that dimension.  This is precisely the pattern in the <tt class="docutils literal"><span class="pre">rms</span></tt>
 prototype.</p>
-<p>Hopefully, no actual prototypes to be wrapped will have the names
+<p>Most likely, no actual prototypes to be wrapped will have the names
 <tt class="docutils literal"><span class="pre">IN_ARRAY1</span></tt> and <tt class="docutils literal"><span class="pre">DIM1</span></tt>.  We use the <tt class="docutils literal"><span class="pre">%apply</span></tt> directive to apply
 the typemap for one-dimensional input arrays of type <tt class="docutils literal"><span class="pre">double</span></tt> to the
 actual prototype used by <tt class="docutils literal"><span class="pre">rms</span></tt>.  Using <tt class="docutils literal"><span class="pre">numpy.i</span></tt> effectively,
 therefore, requires knowing what typemaps are available and what they
 do.</p>
+<p>Note that if the C function signature was in a different order:</p>
+<pre class="literal-block">
+double rms(int n, double* seq);
+</pre>
+<p>that <a class="reference" href="http://www.swig.org">SWIG</a> would not match the typemap signature given above with
+the argument list for <tt class="docutils literal"><span class="pre">rms</span></tt>.  Fortunately, <tt class="docutils literal"><span class="pre">numpy.i</span></tt> has a set of
+typemaps with the data pointer given last:</p>
+<pre class="literal-block">
+%apply (int DIM1, double* IN_ARRAY1) {(int n, double* seq)};
+</pre>
 </div>
 <div class="section">
 <h1><a id="using-numpy-i" name="using-numpy-i">Using numpy.i</a></h1>
 <p>The <tt class="docutils literal"><span class="pre">numpy.i</span></tt> file is currently located in the <tt class="docutils literal"><span class="pre">numpy/docs/swig</span></tt>
 sub-directory under the <tt class="docutils literal"><span class="pre">numpy</span></tt> installation directory.  Typically,
 you will want to copy it to the directory where you are developing
-your wrappers.</p>
+your wrappers.  If it is ever adopted by <a class="reference" href="http://www.swig.org">SWIG</a> developers, then it
+will be installed in a standard place where <a class="reference" href="http://www.swig.org">SWIG</a> can find it.</p>
 <p>A simple module that only uses a single <a class="reference" href="http://www.swig.org">SWIG</a> interface file should
 include the following:</p>
 <pre class="literal-block">
@@ -389,17 +407,22 @@
 import_array();
 %}
 </pre>
-<p>Only one interface file should call <tt class="docutils literal"><span class="pre">import_array()</span></tt>.  If you have
-more than one <a class="reference" href="http://www.swig.org">SWIG</a> interface file, then subsequent files should not
-<tt class="docutils literal"><span class="pre">#define</span> <span class="pre">SWIG_FILE_WITH_INIT</span></tt> and should not call
-<tt class="docutils literal"><span class="pre">import_array()</span></tt>.</p>
+<p>Within a compiled python module, <tt class="docutils literal"><span class="pre">import_array()</span></tt> should only get
+called once.  This could be in a C/C++ file that you have written and
+is linked to the module.  If this is the case, then none of your
+interface files should <tt class="docutils literal"><span class="pre">#define</span> <span class="pre">SWIG_FILE_WITH_INIT</span></tt> or call
+<tt class="docutils literal"><span class="pre">import_array()</span></tt>.  Or, this initialization call could be in a
+wrapper file generated by <a class="reference" href="http://www.swig.org">SWIG</a> from an interface file that has the
+<tt class="docutils literal"><span class="pre">%init</span></tt> block as above.  If this is the case, and you have more than
+one <a class="reference" href="http://www.swig.org">SWIG</a> interface file, then only one interface file should
+<tt class="docutils literal"><span class="pre">#define</span> <span class="pre">SWIG_FILE_WITH_INIT</span></tt> and call <tt class="docutils literal"><span class="pre">import_array()</span></tt>.</p>
 </div>
 <div class="section">
 <h1><a id="available-typemaps" name="available-typemaps">Available Typemaps</a></h1>
 <p>The typemap directives provided by <tt class="docutils literal"><span class="pre">numpy.i</span></tt> for arrays of different
 data types, say <tt class="docutils literal"><span class="pre">double</span></tt> and <tt class="docutils literal"><span class="pre">int</span></tt>, are identical to one another
 except for the C and <a class="reference" href="http://numpy.scipy.org">NumPy</a> type specifications.  The typemaps are
-therefore implemented via a macro:</p>
+therefore implemented (typically behind the scenes) via a macro:</p>
 <pre class="literal-block">
 %numpy_typemaps(TYPE, TYPECODE)
 </pre>
@@ -442,7 +465,7 @@
 %numpy_typemaps(bool, NPY_UINT)
 </pre>
 <p>to fix the data length problem, and <a class="reference" href="#input-arrays">Input Arrays</a> will work fine,
-but <a class="reference" href="#in-place-arrays">In-place Arrays</a> will fail type-checking.</p>
+but <a class="reference" href="#in-place-arrays">In-place Arrays</a> might fail type-checking.</p>
 <p>In the following descriptions, we reference a generic <tt class="docutils literal"><span class="pre">TYPE</span></tt>, which
 could be any of the C-types listed above.</p>
 <div class="section">
@@ -456,6 +479,8 @@
 <ul class="simple">
 <li><tt class="docutils literal"><span class="pre">(TYPE*</span> <span class="pre">IN_ARRAY1,</span> <span class="pre">int</span> <span class="pre">DIM1)</span></tt></li>
 <li><tt class="docutils literal"><span class="pre">(TYPE*</span> <span class="pre">IN_ARRAY2,</span> <span class="pre">int</span> <span class="pre">DIM1,</span> <span class="pre">int</span> <span class="pre">DIM2)</span></tt></li>
+<li><tt class="docutils literal"><span class="pre">(int</span> <span class="pre">DIM1,</span> <span class="pre">TYPE*</span> <span class="pre">IN_ARRAY1)</span></tt></li>
+<li><tt class="docutils literal"><span class="pre">(int</span> <span class="pre">DIM1,</span> <span class="pre">int</span> <span class="pre">DIM2,</span> <span class="pre">TYPE*</span> <span class="pre">IN_ARRAY2)</span></tt></li>
 </ul>
 </blockquote>
 </div>
@@ -470,6 +495,8 @@
 <ul class="simple">
 <li><tt class="docutils literal"><span class="pre">(TYPE*</span> <span class="pre">INPLACE_ARRAY1,</span> <span class="pre">int</span> <span class="pre">DIM1)</span></tt></li>
 <li><tt class="docutils literal"><span class="pre">(TYPE*</span> <span class="pre">INPLACE_ARRAY2,</span> <span class="pre">int</span> <span class="pre">DIM1,</span> <span class="pre">int</span> <span class="pre">DIM2)</span></tt></li>
+<li><tt class="docutils literal"><span class="pre">(int</span> <span class="pre">DIM1,</span> <span class="pre">TYPE*</span> <span class="pre">INPLACE_ARRAY1)</span></tt></li>
+<li><tt class="docutils literal"><span class="pre">(int</span> <span class="pre">DIM1,</span> <span class="pre">int</span> <span class="pre">DIM2,</span> <span class="pre">TYPE*</span> <span class="pre">INPLACE_ARRAY2)</span></tt></li>
 </ul>
 </blockquote>
 </div>
@@ -481,9 +508,9 @@
 therefore not sufficient.  In python, the convential way to return
 multiple arguments is to pack them into a tuple and return the tuple.
 This is what the argout typemaps do.  If a wrapped function that uses
-argout these argout typemaps has more than one return argument, they
-are so packed.  The python user does not pass these arrays in, they
-simply get returned.  The argout signatures are</p>
+these argout typemaps has more than one return argument, they are so
+packed.  The python user does not pass these arrays in, they simply
+get returned.  The argout signatures are</p>
 <blockquote>
 <ul class="simple">
 <li><tt class="docutils literal"><span class="pre">(TYPE</span> <span class="pre">ARGOUT_ARRAY1[ANY])</span></tt></li>
@@ -596,7 +623,7 @@
 </div>
 <div class="footer">
 <hr class="footer" />
-Generated on: 2007-03-14 15:24 UTC.
+Generated on: 2007-03-14 19:50 UTC.
 Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
 
 </div>

Modified: trunk/numpy/doc/swig/numpy_swig.txt
===================================================================
--- trunk/numpy/doc/swig/numpy_swig.txt	2007-03-14 15:47:12 UTC (rev 3574)
+++ trunk/numpy/doc/swig/numpy_swig.txt	2007-03-14 19:57:23 UTC (rev 3575)
@@ -57,9 +57,16 @@
 `SWIG`_ interface file would need the following::
 
     %{
+    #define SWIG_FILE_WITH_INIT
     #include "rms.h"
     %}
+
     %include "numpy.i"
+
+    %init %{
+    import_array();
+    %}
+
     %apply (double* IN_ARRAY1, int DIM1) {(double* seq, int n)};
     %include "rms.h"
 
@@ -72,20 +79,31 @@
 that dimension.  This is precisely the pattern in the ``rms``
 prototype.
 
-Hopefully, no actual prototypes to be wrapped will have the names
+Most likely, no actual prototypes to be wrapped will have the names
 ``IN_ARRAY1`` and ``DIM1``.  We use the ``%apply`` directive to apply
 the typemap for one-dimensional input arrays of type ``double`` to the
 actual prototype used by ``rms``.  Using ``numpy.i`` effectively,
 therefore, requires knowing what typemaps are available and what they
 do.
 
+Note that if the C function signature was in a different order::
+
+    double rms(int n, double* seq);
+
+that `SWIG`_ would not match the typemap signature given above with
+the argument list for ``rms``.  Fortunately, ``numpy.i`` has a set of
+typemaps with the data pointer given last::
+
+    %apply (int DIM1, double* IN_ARRAY1) {(int n, double* seq)};
+
 Using numpy.i
 =============
 
 The ``numpy.i`` file is currently located in the ``numpy/docs/swig``
 sub-directory under the ``numpy`` installation directory.  Typically,
 you will want to copy it to the directory where you are developing
-your wrappers.
+your wrappers.  If it is ever adopted by `SWIG`_ developers, then it
+will be installed in a standard place where `SWIG`_ can find it.
 
 A simple module that only uses a single `SWIG`_ interface file should
 include the following::
@@ -98,10 +116,15 @@
     import_array();
     %}
 
-Only one interface file should call ``import_array()``.  If you have
-more than one `SWIG`_ interface file, then subsequent files should not
-``#define SWIG_FILE_WITH_INIT`` and should not call
-``import_array()``.
+Within a compiled python module, ``import_array()`` should only get
+called once.  This could be in a C/C++ file that you have written and
+is linked to the module.  If this is the case, then none of your
+interface files should ``#define SWIG_FILE_WITH_INIT`` or call
+``import_array()``.  Or, this initialization call could be in a
+wrapper file generated by `SWIG`_ from an interface file that has the
+``%init`` block as above.  If this is the case, and you have more than
+one `SWIG`_ interface file, then only one interface file should
+``#define SWIG_FILE_WITH_INIT`` and call ``import_array()``.
 
 Available Typemaps
 ==================
@@ -109,7 +132,7 @@
 The typemap directives provided by ``numpy.i`` for arrays of different
 data types, say ``double`` and ``int``, are identical to one another
 except for the C and `NumPy`_ type specifications.  The typemaps are
-therefore implemented via a macro::
+therefore implemented (typically behind the scenes) via a macro::
 
     %numpy_typemaps(TYPE, TYPECODE)
 
@@ -150,7 +173,7 @@
     %numpy_typemaps(bool, NPY_UINT)
 
 to fix the data length problem, and `Input Arrays`_ will work fine,
-but `In-place Arrays`_ will fail type-checking.
+but `In-place Arrays`_ might fail type-checking.
 
 In the following descriptions, we reference a generic ``TYPE``, which
 could be any of the C-types listed above.
@@ -166,6 +189,8 @@
 
   * ``(TYPE* IN_ARRAY1, int DIM1)``
   * ``(TYPE* IN_ARRAY2, int DIM1, int DIM2)``
+  * ``(int DIM1, TYPE* IN_ARRAY1)``
+  * ``(int DIM1, int DIM2, TYPE* IN_ARRAY2)``
 
 In-place Arrays
 ---------------
@@ -178,6 +203,8 @@
 
   * ``(TYPE* INPLACE_ARRAY1, int DIM1)``
   * ``(TYPE* INPLACE_ARRAY2, int DIM1, int DIM2)``
+  * ``(int DIM1, TYPE* INPLACE_ARRAY1)``
+  * ``(int DIM1, int DIM2, TYPE* INPLACE_ARRAY2)``
 
 Argout Arrays
 -------------
@@ -188,9 +215,9 @@
 therefore not sufficient.  In python, the convential way to return
 multiple arguments is to pack them into a tuple and return the tuple.
 This is what the argout typemaps do.  If a wrapped function that uses
-argout these argout typemaps has more than one return argument, they
-are so packed.  The python user does not pass these arrays in, they
-simply get returned.  The argout signatures are
+these argout typemaps has more than one return argument, they are so
+packed.  The python user does not pass these arrays in, they simply
+get returned.  The argout signatures are
 
   * ``(TYPE ARGOUT_ARRAY1[ANY])``
   * ``(TYPE ARGOUT_ARRAY2[ANY][ANY])``

Modified: trunk/numpy/doc/swig/series.cxx
===================================================================
--- trunk/numpy/doc/swig/series.cxx	2007-03-14 15:47:12 UTC (rev 3574)
+++ trunk/numpy/doc/swig/series.cxx	2007-03-14 19:57:23 UTC (rev 3575)
@@ -9,6 +9,10 @@
 //     void SNAMEOnes( TYPE * array,  int size);
 //     TYPE SNAMEMax(  TYPE * matrix, int rows, int cols);
 //     void SNAMEFloor(TYPE * array,  int rows, int cols, TYPE floor);
+//     TYPE SNAMESum(  int size, TYPE * series);
+//     void SNAMEZeros(int size, TYPE * array);
+//     TYPE SNAMEMin(  int rows, int cols, TYPE * matrix);
+//     void SNAMECeil( int rows, int cols, TYPE * array, TYPE ceil);
 //
 // for any specified type TYPE (for example: short, unsigned int, long
 // long, etc.) with given short name SNAME (for example: short, uint,
@@ -20,6 +24,10 @@
 //  * 1D in-place arrays
 //  * 2D input arrays
 //  * 2D in-place arrays
+//  * 1D input arrays, data last
+//  * 1D in-place arrays, data last
+//  * 2D input arrays, data last
+//  * 2D in-place arrays, data last
 //
 #define TEST_FUNCS(TYPE, SNAME) \
 \
@@ -46,13 +54,45 @@
 }                                                         \
 \
 void SNAME ## Floor(TYPE * array, int rows, int cols, TYPE floor) { \
-  int i, j, index;                                                    \
-  for (j=0; j<cols; ++j) {                                            \
-    for (i=0; i<rows; ++i) {                                          \
-      index = j*rows + i;                                             \
-      if (array[index] < floor) array[index] = 0;                     \
-    }                                                                 \
-  }                                                                   \
+  int i, j, index;                                                  \
+  for (j=0; j<cols; ++j) {                                          \
+    for (i=0; i<rows; ++i) {                                        \
+      index = j*rows + i;                                           \
+      if (array[index] < floor) array[index] = floor;               \
+    }                                                               \
+  }                                                                 \
+}                                                                   \
+\
+TYPE SNAME ## Sum(int size, TYPE * series) {      \
+  TYPE result = 0;                                \
+  for (int i=0; i<size; ++i) result += series[i]; \
+  return result;                                  \
+}                                                 \
+\
+void SNAME ## Zeros(int size, TYPE * array) { \
+  for (int i=0; i<size; ++i) array[i] = 0;    \
+}                                             \
+\
+TYPE SNAME ## Min(int rows, int cols, TYPE * matrix) {    \
+  int i, j, index;                                        \
+  TYPE result = matrix[0];                                \
+  for (j=0; j<cols; ++j) {                                \
+    for (i=0; i<rows; ++i) {                              \
+      index = j*rows + i;                                 \
+      if (matrix[index] < result) result = matrix[index]; \
+    }                                                     \
+  }                                                       \
+  return result;                                          \
+}                                                         \
+\
+void SNAME ## Ceil(int rows, int cols, TYPE * array, TYPE ceil) { \
+  int i, j, index;                                                \
+  for (j=0; j<cols; ++j) {                                        \
+    for (i=0; i<rows; ++i) {                                      \
+      index = j*rows + i;                                         \
+      if (array[index] > ceil) array[index] = ceil;               \
+    }                                                             \
+  }                                                               \
 }
 
 TEST_FUNCS(signed char       , schar     )
@@ -67,4 +107,3 @@
 TEST_FUNCS(unsigned long long, ulongLong )
 TEST_FUNCS(float             , float     )
 TEST_FUNCS(double            , double    )
-TEST_FUNCS(long double       , longDouble)

Modified: trunk/numpy/doc/swig/series.h
===================================================================
--- trunk/numpy/doc/swig/series.h	2007-03-14 15:47:12 UTC (rev 3574)
+++ trunk/numpy/doc/swig/series.h	2007-03-14 19:57:23 UTC (rev 3575)
@@ -8,6 +8,10 @@
 //     void SNAMEOnes( TYPE * array,  int size);
 //     TYPE SNAMEMax(  TYPE * matrix, int rows, int cols);
 //     void SNAMEFloor(TYPE * array,  int rows, int cols, TYPE floor);
+//     TYPE SNAMESum(  int size, TYPE * series);
+//     void SNAMEZeros(int size, TYPE * array);
+//     TYPE SNAMEMin(  int rows, int cols, TYPE * matrix);
+//     void SNAMECeil( int rows, int cols, TYPE * array,  TYPE ceil);
 //
 // for any specified type TYPE (for example: short, unsigned int, long
 // long, etc.) with given short name SNAME (for example: short, uint,
@@ -19,13 +23,21 @@
 //  * 1D in-place arrays
 //  * 2D input arrays
 //  * 2D in-place arrays
+//  * 1D input arrays, data last
+//  * 1D in-place arrays, data last
+//  * 2D input arrays, data last
+//  * 2D in-place arrays, data last
 //
 #define TEST_FUNC_PROTOS(TYPE, SNAME) \
 \
 TYPE SNAME ## Prod( TYPE * series, int size); \
 void SNAME ## Ones( TYPE * array,  int size); \
 TYPE SNAME ## Max(  TYPE * matrix, int rows, int cols); \
-void SNAME ## Floor(TYPE * array,  int rows, int cols, TYPE floor);
+void SNAME ## Floor(TYPE * array,  int rows, int cols, TYPE floor); \
+TYPE SNAME ## Sum(  int size, TYPE * series); \
+void SNAME ## Zeros(int size, TYPE * array); \
+TYPE SNAME ## Min(  int rows, int cols, TYPE * matrix); \
+void SNAME ## Ceil( int rows, int cols, TYPE * array, TYPE ceil);
 
 TEST_FUNC_PROTOS(signed char       , schar     )
 TEST_FUNC_PROTOS(unsigned char     , uchar     )
@@ -39,6 +51,5 @@
 TEST_FUNC_PROTOS(unsigned long long, ulongLong )
 TEST_FUNC_PROTOS(float             , float     )
 TEST_FUNC_PROTOS(double            , double    )
-TEST_FUNC_PROTOS(long double       , longDouble)
 
 #endif

Modified: trunk/numpy/doc/swig/testSeries.py
===================================================================
--- trunk/numpy/doc/swig/testSeries.py	2007-03-14 15:47:12 UTC (rev 3574)
+++ trunk/numpy/doc/swig/testSeries.py	2007-03-14 19:57:23 UTC (rev 3575)
@@ -25,450 +25,682 @@
     ####################################################
     ### Test functions that take arrays of type BYTE ###
     def testScharProd(self):
-        "Test the scharProd function"
+        "Test scharProd function"
         self.assertEquals(Series.scharProd([1,2,3,4]), 24)
 
     def testScharProdNonContainer(self):
-        "Test the scharProd function with None"
+        "Test scharProd function with None"
         self.assertRaises(TypeError, Series.scharProd, None)
 
     def testScharOnes(self):
-        "Test the scharOnes function"
+        "Test scharOnes function"
         myArray = N.zeros(5,'b')
         Series.scharOnes(myArray)
         N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
 
     def testScharMax(self):
-        "Test the scharMax function"
+        "Test scharMax function"
         matrix = [[-6,5,-4],[3,-2,1]]
         self.assertEquals(Series.scharMax(matrix), 5)
 
     def testScharMaxNonContainer(self):
-        "Test the scharMax function with None"
+        "Test scharMax function with None"
         self.assertRaises(TypeError, Series.scharMax, None)
 
     def testScharMaxWrongDim(self):
-        "Test the scharMax function with a 1D array"
+        "Test scharMax function with a 1D array"
         self.assertRaises(TypeError, Series.scharMax, [0, -1, 2, -3])
 
     def testScharFloor(self):
-        "Test the scharFloor function"
+        "Test scharFloor function"
         matrix = N.array([[10,-2],[-6,7]],'b')
         Series.scharFloor(matrix,0)
         N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
 
+    def testScharSum(self):
+        "Test scharSum function"
+        self.assertEquals(Series.scharSum([-5,6,-7,8]), 2)
+
+    def testScharZeros(self):
+        "Test scharZeros function"
+        myArray = N.ones(5,'b')
+        Series.scharZeros(myArray)
+        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
+
+    def testScharMin(self):
+        "Test scharMin function"
+        matrix = [[9,8],[7,6],[5,4]]
+        self.assertEquals(Series.scharMin(matrix), 4)
+
+    def testScharCeil(self):
+        "Test scharCeil function"
+        matrix = N.array([[10,-2],[-6,7]],'b')
+        Series.scharCeil(matrix,5)
+        N.testing.assert_array_equal(matrix, N.array([[5,-2],[-6,5]]))
+
     #####################################################
     ### Test functions that take arrays of type UBYTE ###
     def testUcharProd(self):
-        "Test the ucharProd function"
+        "Test ucharProd function"
         self.assertEquals(Series.ucharProd([1,2,3,4]), 24)
 
     def testUcharProdNonContainer(self):
-        "Test the ucharProd function with None"
+        "Test ucharProd function with None"
         self.assertRaises(TypeError, Series.ucharProd, None)
 
     def testUcharOnes(self):
-        "Test the ucharOnes function"
+        "Test ucharOnes function"
         myArray = N.zeros(5,'B')
         Series.ucharOnes(myArray)
         N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
 
     def testUcharMax(self):
-        "Test the ucharMax function"
+        "Test ucharMax function"
         matrix = [[6,5,4],[3,2,1]]
         self.assertEquals(Series.ucharMax(matrix), 6)
 
     def testUcharMaxNonContainer(self):
-        "Test the ucharMax function with None"
+        "Test ucharMax function with None"
         self.assertRaises(TypeError, Series.ucharMax, None)
 
     def testUcharMaxWrongDim(self):
-        "Test the ucharMax function with a 1D array"
+        "Test ucharMax function with a 1D array"
         self.assertRaises(TypeError, Series.ucharMax, [0, 1, 2, 3])
 
     def testUcharFloor(self):
-        "Test the ucharFloor function"
+        "Test ucharFloor function"
         matrix = N.array([[10,2],[6,7]],'B')
         Series.ucharFloor(matrix,7)
-        N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
+        N.testing.assert_array_equal(matrix, N.array([[10,7],[7,7]]))
 
+    def testUcharSum(self):
+        "Test ucharSum function"
+        self.assertEquals(Series.ucharSum([5,6,7,8]), 26)
+
+    def testUcharZeros(self):
+        "Test ucharZeros function"
+        myArray = N.ones(5,'B')
+        Series.ucharZeros(myArray)
+        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
+
+    def testUcharMin(self):
+        "Test ucharMin function"
+        matrix = [[9,8],[7,6],[5,4]]
+        self.assertEquals(Series.ucharMin(matrix), 4)
+
+    def testUcharCeil(self):
+        "Test ucharCeil function"
+        matrix = N.array([[10,2],[6,7]],'B')
+        Series.ucharCeil(matrix,5)
+        N.testing.assert_array_equal(matrix, N.array([[5,2],[5,5]]))
+
     #####################################################
     ### Test functions that take arrays of type SHORT ###
     def testShortProd(self):
-        "Test the shortProd function"
+        "Test shortProd function"
         self.assertEquals(Series.shortProd([1,2,3,4]), 24)
 
     def testShortProdNonContainer(self):
-        "Test the shortProd function with None"
+        "Test shortProd function with None"
         self.assertRaises(TypeError, Series.shortProd, None)
 
     def testShortOnes(self):
-        "Test the shortOnes function"
+        "Test shortOnes function"
         myArray = N.zeros(5,'h')
         Series.shortOnes(myArray)
         N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
 
     def testShortMax(self):
-        "Test the shortMax function"
+        "Test shortMax function"
         matrix = [[-6,5,-4],[3,-2,1]]
         self.assertEquals(Series.shortMax(matrix), 5)
 
     def testShortMaxNonContainer(self):
-        "Test the shortMax function with None"
+        "Test shortMax function with None"
         self.assertRaises(TypeError, Series.shortMax, None)
 
     def testShortMaxWrongDim(self):
-        "Test the shortMax function with a 1D array"
+        "Test shortMax function with a 1D array"
         self.assertRaises(TypeError, Series.shortMax, [0, -1, 2, -3])
 
     def testShortFloor(self):
-        "Test the shortFloor function"
+        "Test shortFloor function"
         matrix = N.array([[10,-2],[-6,7]],'h')
         Series.shortFloor(matrix,0)
         N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
 
+    def testShortSum(self):
+        "Test shortSum function"
+        self.assertEquals(Series.shortSum([-5,6,-7,8]), 2)
+
+    def testShortZeros(self):
+        "Test shortZeros function"
+        myArray = N.ones(5,'h')
+        Series.shortZeros(myArray)
+        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
+
+    def testShortMin(self):
+        "Test shortMin function"
+        matrix = [[9,8],[7,6],[5,4]]
+        self.assertEquals(Series.shortMin(matrix), 4)
+
+    def testShortCeil(self):
+        "Test shortCeil function"
+        matrix = N.array([[10,-2],[-6,7]],'h')
+        Series.shortCeil(matrix,5)
+        N.testing.assert_array_equal(matrix, N.array([[5,-2],[-6,5]]))
+
     ######################################################
     ### Test functions that take arrays of type USHORT ###
     def testUshortProd(self):
-        "Test the ushortProd function"
+        "Test ushortProd function"
         self.assertEquals(Series.ushortProd([1,2,3,4]), 24)
 
     def testUshortProdNonContainer(self):
-        "Test the ushortProd function with None"
+        "Test ushortProd function with None"
         self.assertRaises(TypeError, Series.ushortProd, None)
 
     def testUshortOnes(self):
-        "Test the ushortOnes function"
+        "Test ushortOnes function"
         myArray = N.zeros(5,'H')
         Series.ushortOnes(myArray)
         N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
 
     def testUshortMax(self):
-        "Test the ushortMax function"
+        "Test ushortMax function"
         matrix = [[6,5,4],[3,2,1]]
         self.assertEquals(Series.ushortMax(matrix), 6)
 
     def testUshortMaxNonContainer(self):
-        "Test the ushortMax function with None"
+        "Test ushortMax function with None"
         self.assertRaises(TypeError, Series.ushortMax, None)
 
     def testUshortMaxWrongDim(self):
-        "Test the ushortMax function with a 1D array"
+        "Test ushortMax function with a 1D array"
         self.assertRaises(TypeError, Series.ushortMax, [0, 1, 2, 3])
 
     def testUshortFloor(self):
-        "Test the ushortFloor function"
+        "Test ushortFloor function"
         matrix = N.array([[10,2],[6,7]],'H')
         Series.ushortFloor(matrix,7)
-        N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
+        N.testing.assert_array_equal(matrix, N.array([[10,7],[7,7]]))
 
+    def testUshortSum(self):
+        "Test ushortSum function"
+        self.assertEquals(Series.ushortSum([5,6,7,8]), 26)
+
+    def testUshortZeros(self):
+        "Test ushortZeros function"
+        myArray = N.ones(5,'H')
+        Series.ushortZeros(myArray)
+        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
+
+    def testUshortMin(self):
+        "Test ushortMin function"
+        matrix = [[9,8],[7,6],[5,4]]
+        self.assertEquals(Series.ushortMin(matrix), 4)
+
+    def testUshortCeil(self):
+        "Test ushortCeil function"
+        matrix = N.array([[10,2],[6,7]],'H')
+        Series.ushortCeil(matrix,5)
+        N.testing.assert_array_equal(matrix, N.array([[5,2],[5,5]]))
+
     ###################################################
     ### Test functions that take arrays of type INT ###
     def testIntProd(self):
-        "Test the intProd function"
+        "Test intProd function"
         self.assertEquals(Series.intProd([1,2,3,4]), 24)
 
     def testIntProdNonContainer(self):
-        "Test the intProd function with None"
+        "Test intProd function with None"
         self.assertRaises(TypeError, Series.intProd, None)
 
     def testIntOnes(self):
-        "Test the intOnes function"
+        "Test intOnes function"
         myArray = N.zeros(5,'i')
         Series.intOnes(myArray)
         N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
 
     def testIntMax(self):
-        "Test the intMax function"
+        "Test intMax function"
         matrix = [[-6,5,-4],[3,-2,1]]
         self.assertEquals(Series.intMax(matrix), 5)
 
     def testIntMaxNonContainer(self):
-        "Test the intMax function with None"
+        "Test intMax function with None"
         self.assertRaises(TypeError, Series.intMax, None)
 
     def testIntMaxWrongDim(self):
-        "Test the intMax function with a 1D array"
+        "Test intMax function with a 1D array"
         self.assertRaises(TypeError, Series.intMax, [0, -1, 2, -3])
 
     def testIntFloor(self):
-        "Test the intFloor function"
+        "Test intFloor function"
         matrix = N.array([[10,-2],[-6,7]],'i')
         Series.intFloor(matrix,0)
         N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
 
+    def testIntSum(self):
+        "Test intSum function"
+        self.assertEquals(Series.intSum([-5,6,-7,8]), 2)
+
+    def testIntZeros(self):
+        "Test intZeros function"
+        myArray = N.ones(5,'i')
+        Series.intZeros(myArray)
+        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
+
+    def testIntMin(self):
+        "Test intMin function"
+        matrix = [[9,8],[7,6],[5,4]]
+        self.assertEquals(Series.intMin(matrix), 4)
+
+    def testIntCeil(self):
+        "Test intCeil function"
+        matrix = N.array([[10,-2],[-6,7]],'i')
+        Series.intCeil(matrix,5)
+        N.testing.assert_array_equal(matrix, N.array([[5,-2],[-6,5]]))
+
     ####################################################
     ### Test functions that take arrays of type UINT ###
     def testUintProd(self):
-        "Test the uintProd function"
+        "Test uintProd function"
         self.assertEquals(Series.uintProd([1,2,3,4]), 24)
 
     def testUintProdNonContainer(self):
-        "Test the uintProd function with None"
+        "Test uintProd function with None"
         self.assertRaises(TypeError, Series.uintProd, None)
 
     def testUintOnes(self):
-        "Test the uintOnes function"
+        "Test uintOnes function"
         myArray = N.zeros(5,'I')
         Series.uintOnes(myArray)
         N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
 
     def testUintMax(self):
-        "Test the uintMax function"
+        "Test uintMax function"
         matrix = [[6,5,4],[3,2,1]]
         self.assertEquals(Series.uintMax(matrix), 6)
 
     def testUintMaxNonContainer(self):
-        "Test the uintMax function with None"
+        "Test uintMax function with None"
         self.assertRaises(TypeError, Series.uintMax, None)
 
     def testUintMaxWrongDim(self):
-        "Test the uintMax function with a 1D array"
+        "Test uintMax function with a 1D array"
         self.assertRaises(TypeError, Series.uintMax, [0, 1, 2, 3])
 
     def testUintFloor(self):
-        "Test the uintFloor function"
+        "Test uintFloor function"
         matrix = N.array([[10,2],[6,7]],'I')
         Series.uintFloor(matrix,7)
-        N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
+        N.testing.assert_array_equal(matrix, N.array([[10,7],[7,7]]))
 
+    def testUintSum(self):
+        "Test uintSum function"
+        self.assertEquals(Series.uintSum([5,6,7,8]), 26)
+
+    def testUintZeros(self):
+        "Test uintZeros function"
+        myArray = N.ones(5,'I')
+        Series.uintZeros(myArray)
+        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
+
+    def testUintMin(self):
+        "Test uintMin function"
+        matrix = [[9,8],[7,6],[5,4]]
+        self.assertEquals(Series.uintMin(matrix), 4)
+
+    def testUintCeil(self):
+        "Test uintCeil function"
+        matrix = N.array([[10,2],[6,7]],'I')
+        Series.uintCeil(matrix,5)
+        N.testing.assert_array_equal(matrix, N.array([[5,2],[5,5]]))
+
     ####################################################
     ### Test functions that take arrays of type LONG ###
     def testLongProd(self):
-        "Test the longProd function"
+        "Test longProd function"
         self.assertEquals(Series.longProd([1,2,3,4]), 24)
 
     def testLongProdNonContainer(self):
-        "Test the longProd function with None"
+        "Test longProd function with None"
         self.assertRaises(TypeError, Series.longProd, None)
 
     def testLongOnes(self):
-        "Test the longOnes function"
+        "Test longOnes function"
         myArray = N.zeros(5,'l')
         Series.longOnes(myArray)
         N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
 
     def testLongMax(self):
-        "Test the longMax function"
+        "Test longMax function"
         matrix = [[-6,5,-4],[3,-2,1]]
         self.assertEquals(Series.longMax(matrix), 5)
 
     def testLongMaxNonContainer(self):
-        "Test the longMax function with None"
+        "Test longMax function with None"
         self.assertRaises(TypeError, Series.longMax, None)
 
     def testLongMaxWrongDim(self):
-        "Test the longMax function with a 1D array"
+        "Test longMax function with a 1D array"
         self.assertRaises(TypeError, Series.longMax, [0, -1, 2, -3])
 
     def testLongFloor(self):
-        "Test the longFloor function"
+        "Test longFloor function"
         matrix = N.array([[10,-2],[-6,7]],'l')
         Series.longFloor(matrix,0)
         N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
 
+    def testLongSum(self):
+        "Test longSum function"
+        self.assertEquals(Series.longSum([-5,6,-7,8]), 2)
+
+    def testLongZeros(self):
+        "Test longZeros function"
+        myArray = N.ones(5,'l')
+        Series.longZeros(myArray)
+        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
+
+    def testLongMin(self):
+        "Test longMin function"
+        matrix = [[9,8],[7,6],[5,4]]
+        self.assertEquals(Series.longMin(matrix), 4)
+
+    def testLongCeil(self):
+        "Test longCeil function"
+        matrix = N.array([[10,-2],[-6,7]],'l')
+        Series.longCeil(matrix,5)
+        N.testing.assert_array_equal(matrix, N.array([[5,-2],[-6,5]]))
+
     #####################################################
     ### Test functions that take arrays of type ULONG ###
     def testUlongProd(self):
-        "Test the ulongProd function"
+        "Test ulongProd function"
         self.assertEquals(Series.ulongProd([1,2,3,4]), 24)
 
     def testUlongProdNonContainer(self):
-        "Test the ulongProd function with None"
+        "Test ulongProd function with None"
         self.assertRaises(TypeError, Series.ulongProd, None)
 
     def testUlongOnes(self):
-        "Test the ulongOnes function"
+        "Test ulongOnes function"
         myArray = N.zeros(5,'L')
         Series.ulongOnes(myArray)
         N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
 
     def testUlongMax(self):
-        "Test the ulongMax function"
+        "Test ulongMax function"
         matrix = [[6,5,4],[3,2,1]]
         self.assertEquals(Series.ulongMax(matrix), 6)
 
     def testUlongMaxNonContainer(self):
-        "Test the ulongMax function with None"
+        "Test ulongMax function with None"
         self.assertRaises(TypeError, Series.ulongMax, None)
 
     def testUlongMaxWrongDim(self):
-        "Test the ulongMax function with a 1D array"
+        "Test ulongMax function with a 1D array"
         self.assertRaises(TypeError, Series.ulongMax, [0, 1, 2, 3])
 
     def testUlongFloor(self):
-        "Test the ulongFloor function"
+        "Test ulongFloor function"
         matrix = N.array([[10,2],[6,7]],'L')
         Series.ulongFloor(matrix,7)
-        N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
+        N.testing.assert_array_equal(matrix, N.array([[10,7],[7,7]]))
 
+    def testUlongSum(self):
+        "Test ulongSum function"
+        self.assertEquals(Series.ulongSum([5,6,7,8]), 26)
+
+    def testUlongZeros(self):
+        "Test ulongZeros function"
+        myArray = N.ones(5,'L')
+        Series.ulongZeros(myArray)
+        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
+
+    def testUlongMin(self):
+        "Test ulongMin function"
+        matrix = [[9,8],[7,6],[5,4]]
+        self.assertEquals(Series.ulongMin(matrix), 4)
+
+    def testUlongCeil(self):
+        "Test ulongCeil function"
+        matrix = N.array([[10,2],[6,7]],'L')
+        Series.ulongCeil(matrix,5)
+        N.testing.assert_array_equal(matrix, N.array([[5,2],[5,5]]))
+
     ########################################################
     ### Test functions that take arrays of type LONGLONG ###
     def testLongLongProd(self):
-        "Test the longLongProd function"
+        "Test longLongProd function"
         self.assertEquals(Series.longLongProd([1,2,3,4]), 24)
 
     def testLongLongProdNonContainer(self):
-        "Test the longLongProd function with None"
+        "Test longLongProd function with None"
         self.assertRaises(TypeError, Series.longLongProd, None)
 
     def testLongLongOnes(self):
-        "Test the longLongOnes function"
+        "Test longLongOnes function"
         myArray = N.zeros(5,'q')
         Series.longLongOnes(myArray)
         N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
 
     def testLongLongMax(self):
-        "Test the longLongMax function"
+        "Test longLongMax function"
         matrix = [[-6,5,-4],[3,-2,1]]
         self.assertEquals(Series.longLongMax(matrix), 5)
 
     def testLongLongMaxNonContainer(self):
-        "Test the longLongMax function with None"
+        "Test longLongMax function with None"
         self.assertRaises(TypeError, Series.longLongMax, None)
 
     def testLongLongMaxWrongDim(self):
-        "Test the longLongMax function with a 1D array"
+        "Test longLongMax function with a 1D array"
         self.assertRaises(TypeError, Series.longLongMax, [0, -1, 2, -3])
 
     def testLongLongFloor(self):
-        "Test the longLongFloor function"
+        "Test longLongFloor function"
         matrix = N.array([[10,-2],[-6,7]],'q')
         Series.longLongFloor(matrix,0)
         N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
 
+    def testLongLongSum(self):
+        "Test longLongSum function"
+        self.assertEquals(Series.longLongSum([-5,6,-7,8]), 2)
+
+    def testLongLongZeros(self):
+        "Test longLongZeros function"
+        myArray = N.ones(5,'q')
+        Series.longLongZeros(myArray)
+        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
+
+    def testLongLongMin(self):
+        "Test longLongMin function"
+        matrix = [[9,8],[7,6],[5,4]]
+        self.assertEquals(Series.longLongMin(matrix), 4)
+
+    def testLongLongCeil(self):
+        "Test longLongCeil function"
+        matrix = N.array([[10,-2],[-6,7]],'q')
+        Series.longLongCeil(matrix,5)
+        N.testing.assert_array_equal(matrix, N.array([[5,-2],[-6,5]]))
+
     #########################################################
     ### Test functions that take arrays of type ULONGLONG ###
     def testUlonglongProd(self):
-        "Test the ulongLongProd function"
+        "Test ulongLongProd function"
         self.assertEquals(Series.ulongLongProd([1,2,3,4]), 24)
 
     def testUlongLongProdNonContainer(self):
-        "Test the ulongLongProd function with None"
+        "Test ulongLongProd function with None"
         self.assertRaises(TypeError, Series.ulongLongProd, None)
 
     def testUlongLongOnes(self):
-        "Test the ulongLongOnes function"
+        "Test ulongLongOnes function"
         myArray = N.zeros(5,'Q')
         Series.ulongLongOnes(myArray)
         N.testing.assert_array_equal(myArray, N.array([1,1,1,1,1]))
 
     def testUlongLongMax(self):
-        "Test the ulongLongMax function"
+        "Test ulongLongMax function"
         matrix = [[6,5,4],[3,2,1]]
         self.assertEquals(Series.ulongLongMax(matrix), 6)
 
     def testUlongLongMaxNonContainer(self):
-        "Test the ulongLongMax function with None"
+        "Test ulongLongMax function with None"
         self.assertRaises(TypeError, Series.ulongLongMax, None)
 
     def testUlongLongMaxWrongDim(self):
-        "Test the ulongLongMax function with a 1D array"
+        "Test ulongLongMax function with a 1D array"
         self.assertRaises(TypeError, Series.ulongLongMax, [0, 1, 2, 3])
 
     def testUlongLongFloor(self):
-        "Test the ulongLongFloor function"
+        "Test ulongLongFloor function"
         matrix = N.array([[10,2],[6,7]],'Q')
         Series.ulongLongFloor(matrix,7)
-        N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
+        N.testing.assert_array_equal(matrix, N.array([[10,7],[7,7]]))
 
+    def testUlongLongSum(self):
+        "Test ulongLongSum function"
+        self.assertEquals(Series.ulongLongSum([5,6,7,8]), 26)
+
+    def testUlongLongZeros(self):
+        "Test ulongLongZeros function"
+        myArray = N.ones(5,'Q')
+        Series.ulongLongZeros(myArray)
+        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
+
+    def testUlongLongMin(self):
+        "Test ulongLongMin function"
+        matrix = [[9,8],[7,6],[5,4]]
+        self.assertEquals(Series.ulongLongMin(matrix), 4)
+
+    def testUlongLongCeil(self):
+        "Test ulongLongCeil function"
+        matrix = N.array([[10,2],[6,7]],'Q')
+        Series.ulongLongCeil(matrix,5)
+        N.testing.assert_array_equal(matrix, N.array([[5,2],[5,5]]))
+
     #####################################################
     ### Test functions that take arrays of type FLOAT ###
     def testFloatProd(self):
-        "Test the floatProd function (to 5 decimal places)"
+        "Test floatProd function (to 5 decimal places)"
         self.assertAlmostEquals(Series.floatProd((1,2.718,3,4)), 32.616, 5)
 
     def testFloatProdBadContainer(self):
-        "Test the floatProd function with an invalid list"
+        "Test floatProd function with an invalid list"
         self.assertRaises(BadListError, Series.floatProd, [3.14, "pi"])
 
     def testFloatOnes(self):
-        "Test the floatOnes function"
+        "Test floatOnes function"
         myArray = N.zeros(5,'f')
         Series.floatOnes(myArray)
         N.testing.assert_array_equal(myArray, N.array([1.,1.,1.,1.,1.]))
 
     def testFloatOnesNonArray(self):
-        "Test the floatOnes function with a list"
+        "Test floatOnes function with a list"
         self.assertRaises(TypeError, Series.floatOnes, [True, 0, 2.718, "pi"])
 
     def testFloatMax(self):
-        "Test the floatMax function"
+        "Test floatMax function"
         matrix = [[-6,5,-4],[3.14,-2.718,1]]
         self.assertEquals(Series.floatMax(matrix), 5.0)
 
     def testFloatMaxNonContainer(self):
-        "Test the floatMax function with None"
+        "Test floatMax function with None"
         self.assertRaises(TypeError, Series.floatMax, None)
 
     def testFloatMaxWrongDim(self):
-        "Test the floatMax function with a 1D array"
+        "Test floatMax function with a 1D array"
         self.assertRaises(TypeError, Series.floatMax, [0.0, -1, 2.718, -3.14])
 
     def testFloatFloor(self):
-        "Test the floatFloor function"
+        "Test floatFloor function"
         matrix = N.array([[10,-2],[-6,7]],'f')
         Series.floatFloor(matrix,0)
         N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
 
+    def testFloatSum(self):
+        "Test floatSum function"
+        self.assertEquals(Series.floatSum([-5,6,-7,8]), 2)
+
+    def testFloatZeros(self):
+        "Test floatZeros function"
+        myArray = N.ones(5,'f')
+        Series.floatZeros(myArray)
+        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
+
+    def testFloatMin(self):
+        "Test floatMin function"
+        matrix = [[9,8],[7,6],[5,4]]
+        self.assertEquals(Series.floatMin(matrix), 4)
+
+    def testFloatCeil(self):
+        "Test floatCeil function"
+        matrix = N.array([[10,-2],[-6,7]],'f')
+        Series.floatCeil(matrix,5)
+        N.testing.assert_array_equal(matrix, N.array([[5,-2],[-6,5]]))
+
     ######################################################
     ### Test functions that take arrays of type DOUBLE ###
     def testDoubleProd(self):
-        "Test the doubleProd function"
+        "Test doubleProd function"
         self.assertEquals(Series.doubleProd((1,2.718,3,4)), 32.616)
 
     def testDoubleProdBadContainer(self):
-        "Test the doubleProd function with an invalid list"
+        "Test doubleProd function with an invalid list"
         self.assertRaises(BadListError, Series.doubleProd, [3.14, "pi"])
 
     def testDoubleOnes(self):
-        "Test the doubleOnes function"
+        "Test doubleOnes function"
         myArray = N.zeros(5,'d')
         Series.doubleOnes(myArray)
         N.testing.assert_array_equal(myArray, N.array([1.,1.,1.,1.,1.]))
 
     def testDoubleOnesNonArray(self):
-        "Test the doubleOnes function with a list"
+        "Test doubleOnes function with a list"
         self.assertRaises(TypeError, Series.doubleOnes, [True, 0, 2.718, "pi"])
 
     def testDoubleMax(self):
-        "Test the doubleMax function"
+        "Test doubleMax function"
         matrix = [[-6,5,-4],[3.14,-2.718,1]]
         self.assertEquals(Series.doubleMax(matrix), 5.0)
 
     def testDoubleMaxNonContainer(self):
-        "Test the doubleMax function with None"
+        "Test doubleMax function with None"
         self.assertRaises(TypeError, Series.doubleMax, None)
 
     def testDoubleMaxWrongDim(self):
-        "Test the doubleMax function with a 1D array"
+        "Test doubleMax function with a 1D array"
         self.assertRaises(TypeError, Series.doubleMax, [0.0, -1, 2.718, -3.14])
 
     def testDoubleFloor(self):
-        "Test the doubleFloor function"
+        "Test doubleFloor function"
         matrix = N.array([[10,-2],[-6,7]],'d')
         Series.doubleFloor(matrix,0)
         N.testing.assert_array_equal(matrix, N.array([[10,0],[0,7]]))
 
-    # ##########################################################
-    # ### Test functions that take arrays of type LONGDOUBLE ###
-    # def testLongDoubleProd(self):
-    #     "Test the longDoubleProd function"
-    #     self.assertEquals(Series.longDoubleProd((1,2.718,3,4)), 32.616)
+    def testDoubleSum(self):
+        "Test doubleSum function"
+        self.assertEquals(Series.doubleSum([-5,6,-7,8]), 2)
 
-    # def testLongDoubleProdBadContainer(self):
-    #     "Test the longDoubleProd function with an invalid list"
-    #     self.assertRaises(BadListError, Series.longDoubleProd, [3.14, "pi"])
+    def testDoubleZeros(self):
+        "Test doubleZeros function"
+        myArray = N.ones(5,'d')
+        Series.doubleZeros(myArray)
+        N.testing.assert_array_equal(myArray, N.array([0,0,0,0,0]))
 
-    # def testLongDoubleOnes(self):
-    #     "Test the longDoubleOnes function"
-    #     myArray = N.zeros(5,'g')
-    #     Series.longDoubleOnes(myArray)
-    #     N.testing.assert_array_equal(myArray, N.array([1.,1.,1.,1.,1.]))
+    def testDoubleMin(self):
+        "Test doubleMin function"
+        matrix = [[9,8],[7,6],[5,4]]
+        self.assertEquals(Series.doubleMin(matrix), 4)
 
-    # def testLongDoubleOnesNonArray(self):
-    #     "Test the longDoubleOnes function with a list"
-    #     self.assertRaises(TypeError, Series.longDoubleOnes, [True, 0, 2.718, "pi"])
+    def testDoubleCeil(self):
+        "Test doubleCeil function"
+        matrix = N.array([[10,-2],[-6,7]],'d')
+        Series.doubleCeil(matrix,5)
+        N.testing.assert_array_equal(matrix, N.array([[5,-2],[-6,5]]))
 
 ######################################################################
 



More information about the Numpy-svn mailing list