Merge commit '8cbed8ce5253a0aa4341e6edbf8be123a06bb123' (Nov 18) into refactor

Conflicts:
	setup.py

Author: Ilan Schnell

doc/CAPI.txt renamed to doc/CAPI.rst.txt

@@ -652,7 +652,13 @@ static PyObject *
 {
     PyObject *ret;
     @name@ arg1, arg2;
-    @otyp@ out;
+    /*
+     * NOTE: In gcc >= 4.1, the compiler will reorder floating point operations and
+     *       floating point error state checks.  In particular, the arithmetic operations
+     *       were being reordered so that the errors weren't caught.  Declaring this output
+     *       variable volatile was the minimal fix for the issue. (Ticket #1671)
+     */
+    volatile @otyp@ out;
 #if @twoout@
     @otyp@ out2;
     PyObject *obj;
@@ -693,9 +699,9 @@ static PyObject *
      * as a function call.
      */
 #if @twoout@
-    @name@_ctype_@oper@(arg1, arg2, &out, &out2);
+    @name@_ctype_@oper@(arg1, arg2, (@otyp@ *)&out, &out2);
 #else
-    @name@_ctype_@oper@(arg1, arg2, &out);
+    @name@_ctype_@oper@(arg1, arg2, (@otyp@ *)&out);
 #endif
 
 #if @fperr@

doc/DISTUTILS.txt renamed to doc/DISTUTILS.rst.txt

@@ -251,6 +251,86 @@ def test_divide_err(self):
             seterr(**err)
 
 
+class TestFloatExceptions(TestCase):
+    def assert_raises_fpe(self, fpeerr, flop, x, y):
+        ftype = type(x)
+        try:
+            flop(x, y)
+            assert_(False,
+                    "Type %s did not raise fpe error '%s'." % (ftype, fpeerr))
+        except FloatingPointError, exc:
+            assert_(str(exc).find(fpeerr) >= 0,
+                    "Type %s raised wrong fpe error '%s'." % (ftype, exc))
+
+    def assert_op_raises_fpe(self, fpeerr, flop, sc1, sc2):
+        """Check that fpe exception is raised.
+
+       Given a floating operation `flop` and two scalar values, check that
+       the operation raises the floating point exception specified by
+       `fpeerr`. Tests all variants with 0-d array scalars as well.
+
+        """
+        self.assert_raises_fpe(fpeerr, flop, sc1, sc2);
+        self.assert_raises_fpe(fpeerr, flop, sc1[()], sc2);
+        self.assert_raises_fpe(fpeerr, flop, sc1, sc2[()]);
+        self.assert_raises_fpe(fpeerr, flop, sc1[()], sc2[()]);
+
+    def test_floating_exceptions(self):
+        """Test basic arithmetic function errors"""
+        oldsettings = np.seterr(all='raise')
+        try:
+            # Test for all real and complex float types
+            for typecode in np.typecodes['AllFloat']:
+                ftype = np.obj2sctype(typecode)
+                if np.dtype(ftype).kind == 'f':
+                    # Get some extreme values for the type
+                    fi = np.finfo(ftype)
+                    ft_tiny = fi.tiny
+                    ft_max = fi.max
+                    ft_eps = fi.eps
+                    underflow = 'underflow'
+                    divbyzero = 'divide by zero'
+                else:
+                    # 'c', complex, corresponding real dtype
+                    rtype = type(ftype(0).real)
+                    fi = np.finfo(rtype)
+                    ft_tiny = ftype(fi.tiny)
+                    ft_max = ftype(fi.max)
+                    ft_eps = ftype(fi.eps)
+                    # The complex types raise different exceptions
+                    underflow = ''
+                    divbyzero = ''
+                overflow = 'overflow'
+                invalid = 'invalid'
+
+                self.assert_raises_fpe(underflow,
+                        lambda a,b:a/b, ft_tiny, ft_max)
+                self.assert_raises_fpe(underflow,
+                        lambda a,b:a*b, ft_tiny, ft_tiny)
+                self.assert_raises_fpe(overflow,
+                        lambda a,b:a*b, ft_max, ftype(2))
+                self.assert_raises_fpe(overflow,
+                        lambda a,b:a/b, ft_max, ftype(0.5))
+                self.assert_raises_fpe(overflow,
+                        lambda a,b:a+b, ft_max, ft_max*ft_eps)
+                self.assert_raises_fpe(overflow,
+                        lambda a,b:a-b, -ft_max, ft_max*ft_eps)
+                self.assert_raises_fpe(divbyzero,
+                        lambda a,b:a/b, ftype(1), ftype(0))
+                self.assert_raises_fpe(invalid,
+                        lambda a,b:a/b, ftype(0), ftype(0))
+                self.assert_raises_fpe(invalid,
+                        lambda a,b:a-b, ftype(np.inf), ftype(np.inf))
+                self.assert_raises_fpe(invalid,
+                        lambda a,b:a+b, ftype(np.inf), ftype(-np.inf))
+                self.assert_raises_fpe(invalid,
+                        lambda a,b:a*b, ftype(0), ftype(np.inf))
+                self.assert_raises_fpe(overflow,
+                        np.power, ftype(2), ftype(2**fi.nexp))
+        finally:
+            np.seterr(**oldsettings)
+
+
 class TestFromiter(TestCase):
     def makegen(self):
         for x in xrange(24):

doc/EXAMPLE_DOCSTRING.txt renamed to doc/EXAMPLE_DOCSTRING.rst.txt

@@ -209,7 +209,7 @@ def _delimited_splitter(self, line):
         return line.split(self.delimiter)
     #
     def _fixedwidth_splitter(self, line):
-        line = line.split(self.comments)[0]
+        line = line.split(self.comments)[0].strip(asbytes("\r\n"))
         if not line:
             return []
         fixed = self.delimiter
@@ -707,8 +707,8 @@ def iterupgrade(self, value):
             self._status = _status
             self.iterupgrade(value)
 
-    def update(self, func, default=None, missing_values=asbytes(''),
-               locked=False):
+    def update(self, func, default=None, testing_value=None,
+               missing_values=asbytes(''), locked=False):
         """
         Set StringConverter attributes directly.
 
@@ -720,6 +720,9 @@ def update(self, func, default=None, missing_values=asbytes(''),
             Value to return by default, that is, when the string to be converted
             is flagged as missing. If not given, `StringConverter` tries to supply
             a reasonable default value.
+        testing_value : str, optional
+            A string representing a standard input value of the converter.
+            This string is used to help defining a reasonable default value.
         missing_values : sequence of str, optional
             Sequence of strings indicating a missing value.
         locked : bool, optional
@@ -741,7 +744,7 @@ def update(self, func, default=None, missing_values=asbytes(''),
             self.type = self._getsubdtype(default)
         else:
             try:
-                tester = func(asbytes('1'))
+                tester = func(testing_value or asbytes('1'))
             except (TypeError, ValueError):
                 tester = None
             self.type = self._getsubdtype(tester)

doc/HOWTO_BUILD_DOCS.txt renamed to doc/HOWTO_BUILD_DOCS.rst.txt

@@ -42,36 +42,37 @@ def seek_gzip_factory(f):
     """
     import gzip
 
-    def seek(self, offset, whence=0):
-        # figure out new position (we can only seek forwards)
-        if whence == 1:
-            offset = self.offset + offset
+    class GzipFile(gzip.GzipFile):
 
-        if whence not in [0, 1]:
-            raise IOError, "Illegal argument"
+        def seek(self, offset, whence=0):
+            # figure out new position (we can only seek forwards)
+            if whence == 1:
+                offset = self.offset + offset
 
-        if offset < self.offset:
-            # for negative seek, rewind and do positive seek
-            self.rewind()
-            count = offset - self.offset
-            for i in range(count // 1024):
-                self.read(1024)
-            self.read(count % 1024)
+            if whence not in [0, 1]:
+                raise IOError, "Illegal argument"
+
+            if offset < self.offset:
+                # for negative seek, rewind and do positive seek
+                self.rewind()
+                count = offset - self.offset
+                for i in range(count // 1024):
+                    self.read(1024)
+                self.read(count % 1024)
+
+        def tell(self):
+            return self.offset
 
-    def tell(self):
-        return self.offset
 
     if isinstance(f, str):
-        f = gzip.GzipFile(f)
+        f = GzipFile(f)
+    elif isinstance(f, gzip.GzipFile):
+        # cast to our GzipFile if its already a gzip.GzipFile
+        g = GzipFile(fileobj=f.fileobj)
+        g.name = f.name
+        g.mode = f.mode
 
-    if sys.version_info[0] >= 3:
-        import types
-        f.seek = types.MethodType(seek, f)
-        f.tell = types.MethodType(tell, f)
-    else:
-        import new
-        f.seek = new.instancemethod(seek, f)
-        f.tell = new.instancemethod(tell, f)
+        f = g
 
     return f
 
@@ -670,7 +671,6 @@ def loadtxt(fname, dtype=float, comments='#', delimiter=None,
     if _is_string_like(fname):
         own_fh = True
         if fname.endswith('.gz'):
-            import gzip
             fh = seek_gzip_factory(fname)
         elif fname.endswith('.bz2'):
             import bz2
@@ -1226,7 +1226,7 @@ def genfromtxt(fname, dtype=float, comments='#', delimiter=None,
         if fval in comments:
             del first_values[0]
 
-    # Check the columns to use
+    # Check the columns to use: make sure `usecols` is a list
     if usecols is not None:
         try:
             usecols = [_.strip() for _ in usecols.split(",")]
@@ -1249,7 +1249,6 @@ def genfromtxt(fname, dtype=float, comments='#', delimiter=None,
     # Get the dtype
     if dtype is not None:
         dtype = easy_dtype(dtype, defaultfmt=defaultfmt, names=names)
-        names = dtype.names
     # Make sure the names is a list (for 2.5)
     if names is not None:
         names = list(names)
@@ -1270,6 +1269,8 @@ def genfromtxt(fname, dtype=float, comments='#', delimiter=None,
         # If `names` is not None, update the names
         elif (names is not None) and (len(names) > nbcols):
             names = [names[_] for _ in usecols]
+    elif (names is not None) and (dtype is not None):
+        names = dtype.names
 
 
     # Process the missing values ...............................
@@ -1404,7 +1405,13 @@ def genfromtxt(fname, dtype=float, comments='#', delimiter=None,
             except ValueError:
                 # Unused converter specified
                 continue
+        # Find the value to test:
+        if len(first_line):
+            testing_value = first_values[i]
+        else:
+            testing_value = None
         converters[i].update(conv, locked=True,
+                             testing_value=testing_value,
                              default=filling_values[i],
                              missing_values=missing_values[i],)
         uc_update.append((i, conv))

doc/HOWTO_DOCUMENT.txt renamed to doc/HOWTO_DOCUMENT.rst.txt

@@ -714,6 +714,15 @@ def test_invalid_converter(self):
                       dtype=None)
         assert_raises(ConverterError, np.genfromtxt, s, **kwargs)
 
+    def test_tricky_converter_bug1666(self):
+        "Test some corner case"
+        s = StringIO('q1,2\nq3,4')
+        cnv = lambda s:float(s[1:])
+        test = np.genfromtxt(s, delimiter=',', converters={0:cnv})
+        control = np.array([[1., 2.], [3., 4.]])
+        assert_equal(test, control)
+
+
 
     def test_dtype_with_converters(self):
         dstr = "2009; 23; 46"
@@ -774,6 +783,13 @@ def test_spacedelimiter(self):
                             [ 6., 7., 8., 9., 10.]])
         assert_equal(test, control)
 
+    def test_integer_delimiter(self):
+        "Test using an integer for delimiter"
+        data = "  1  2  3\n  4  5 67\n890123  4"
+        test = np.genfromtxt(StringIO(data), delimiter=3)
+        control = np.array([[1, 2, 3], [4, 5, 67], [890, 123, 4]])
+        assert_equal(test, control)
+
 
     def test_missing(self):
         data = StringIO('1,2,3,,5\n')
@@ -1138,6 +1154,27 @@ def test_names_auto_completion(self):
                         dtype=[('a', int), ('f0', float), ('f1', int)])
         assert_equal(test, ctrl)
 
+    def test_names_with_usecols_bug1636(self):
+        "Make sure we pick up the right names w/ usecols"
+        data = "A,B,C,D,E\n0,1,2,3,4\n0,1,2,3,4\n0,1,2,3,4"
+        ctrl_names = ("A", "C", "E")
+        test = np.genfromtxt(StringIO(data),
+                             dtype=(int, int, int), delimiter=",",
+                             usecols=(0, 2, 4), names=True)
+        assert_equal(test.dtype.names, ctrl_names)
+        #
+        test = np.genfromtxt(StringIO(data),
+                             dtype=(int, int, int), delimiter=",",
+                             usecols=("A", "C", "E"), names=True)
+        assert_equal(test.dtype.names, ctrl_names)
+        #
+        test = np.genfromtxt(StringIO(data),
+                             dtype=int, delimiter=",",
+                             usecols=("A", "C", "E"), names=True)
+        assert_equal(test.dtype.names, ctrl_names)
+
+
+
     def test_fixed_width_names(self):
         "Test fix-width w/ names"
         data = "    A    B   C\n    0    1 2.3\n   45   67   9."

doc/HOWTO_MERGE_WIKI_DOCS.txt renamed to doc/HOWTO_MERGE_WIKI_DOCS.rst.txt

@@ -73,7 +73,6 @@
 sys.path.insert(0, os.path.dirname(__file__))
 try:
     setup_py = __import__("setup")
-    FULLVERSION = setup_py.FULLVERSION
     write_version_py = setup_py.write_version_py
 finally:
     sys.path.pop(0)