* roll back rounding changes, they were too strict.

ddale · ddale · commit 98fad810643a · 2010-03-14T15:11:29.000-04:00
* allow magnitude of a quantity to be changed by passing a scalar to
  fill or __setitem__
* clean up tests
diff --git a/CHANGES.txt b/CHANGES.txt
@@ -6,31 +6,12 @@ CHANGES
 0.8.0
 -----
 
-In the interest of reproducing the same physical result regardless of
-the units used, several numpy ufuncs now require dimensionless
-operands:
+The fill method, and __setitem__ methods will now accept scalar
+values in addition to quantities. If a scalar is passed, an
+assumption is made that the change should only be applied to the
+quantity's magnitude. The fill method will also accept a quantity
+with incompatible units, and will overwrite the previous units.
 
-* np.ceil
-* np.floor
-* np.fix
-* np.rint
-
-This change is commensurate with the behavior of np.mod, np.fmod,
-and np.floor_division, which require the dimensionalities of the
-operands to be equal (both quantities can be expressed with the same
-units). The motivation for this behavior and the changes listed above
-is that the operations on quantities should yield the same physical
-result regardless of the units used at any point in the process. For
-example, before quantities-0.8.0::
-
-    foo = floor(3.3*pq.m)
-    # foo = 3.0*pq.m
-    bar = floor(3300.0*pq.mm)
-    # bar = 3300.0*pq.mm
-    fubar = foo != bar
-
-This example indicates that floor (and friends) should only be defined
-for pure numbers and dimensionless quantities. 
 
 Bugs fixed
 **********
diff --git a/quantities/dimensionality.py b/quantities/dimensionality.py
@@ -303,6 +303,10 @@ def _d_copy(q1, out=None):
 p_dict[np.conjugate] = _d_copy
 p_dict[np.negative] = _d_copy
 p_dict[np.ones_like] = _d_copy
+p_dict[np.rint] = _d_copy
+p_dict[np.floor] = _d_copy
+p_dict[np.fix] = _d_copy
+p_dict[np.ceil] = _d_copy
 
 def _d_sqrt(q1, out=None):
     return q1._dimensionality**0.5
@@ -334,7 +338,3 @@ def _d_dimensionless(q1, out=None):
     return Dimensionality()
 p_dict[np.log] = _d_dimensionless
 p_dict[np.exp] = _d_dimensionless
-p_dict[np.rint] = _d_dimensionless
-p_dict[np.floor] = _d_dimensionless
-p_dict[np.fix] = _d_dimensionless
-p_dict[np.ceil] = _d_dimensionless
diff --git a/quantities/quantity.py b/quantities/quantity.py
@@ -325,11 +325,10 @@ def __getitem__(self, key):
 
     @with_doc(np.ndarray.__setitem__)
     def __setitem__(self, key, value):
-        if not isinstance(value, Quantity):
-            value = Quantity(value)
-
-        # TODO: do we want this kind of magic?
-        self.magnitude[key] = value.rescale(self._dimensionality).magnitude
+        if isinstance(value, Quantity):
+            if self._dimensionality != value._dimensionality:
+                value = value.rescale(self._dimensionality)
+        self.magnitude[key] = value
 
     @with_doc(np.ndarray.__lt__)
     @wrap_comparison
@@ -401,14 +400,12 @@ def sum(self, axis=None, dtype=None, out=None):
         )
 
     @with_doc(np.ndarray.fill)
-    def fill(self, scalar):
-        if not isinstance (scalar, Quantity):
-            scalar = Quantity(scalar, copy=False)
-
-        if scalar._dimensionality == self._dimensionality:
-            self.magnitude.fill(scalar.magnitude)
-        else:
-            raise ValueError("scalar must have the same units as self")
+    def fill(self, value):
+        self.magnitude.fill(value)
+        try:
+            self._dimensionality = value.dimensionality
+        except AttributeError:
+            pass
 
     @with_doc(np.ndarray.put)
     def put(self, indicies, values, mode='raise'):
diff --git a/quantities/tests/test_25_quantity_arithmetic.py b/quantities/tests/test_25_quantity_arithmetic.py
@@ -158,30 +158,10 @@ def test_imod():
 def test_fmod():
     assert_quantity_almost_equal(np.fmod(10*pq.m, (3*pq.m)), 1*pq.m)
     assert_raises(ValueError, np.fmod, 10*pq.J, 3*pq.m)
-@skip_if(
-    True,
-    'known failure, needs __input_prepare__ in numpy'
-)
-def test_fmod_future():
-    # requires __input_prepare__ in numpy:
-    assert_quantity_almost_equal(
-        np.fmod(10*pq.m, (3*pq.m).rescale('ft')),
-        10*pq.m % (3*pq.m)
-    )
 
 def test_remainder():
     assert_quantity_almost_equal(np.remainder(10*pq.m, (3*pq.m)), 1*pq.m)
     assert_raises(ValueError, np.remainder, 10*pq.J, 3*pq.m)
-@skip_if(
-    True,
-    'known failure, needs __input_prepare__ in numpy'
-)
-def test_remainder_future():
-    # requires __input_prepare__ in numpy:
-    assert_quantity_almost_equal(
-        np.remainder(10*pq.m, (3*pq.m).rescale('ft')),
-        10*pq.m % (3*pq.m)
-    )
 
 def test_negative():
     assert_quantity_equal(
diff --git a/quantities/tests/test_30_quantity_conversion.py b/quantities/tests/test_30_quantity_conversion.py
@@ -208,9 +208,6 @@ def test(value):
         test(2 *pq.lb)
 
         self.assertRaises(ValueError, test, 60 * pq.inch * pq.J)
-        # even in the case when the quantity has no units
-        # (maybe this could go away)
-        self.assertRaises(ValueError, test, 60)
 
         #test set item using slicing
         tempArray2 = [100, .2, -1, -5, -6] * pq.mA
diff --git a/quantities/tests/test_40_quantity_methods.py b/quantities/tests/test_40_quantity_methods.py
@@ -62,10 +62,8 @@ def test_numpy_functions(self):
 
         # fill
         u = [[-100, 5, 6], [1, 2, 3]] * pq.m
-        u.fill(6 * pq.m)
-        self.numAssertEqual(u,[[6, 6, 6], [6, 6, 6]] * pq.m)
-        # incompatible units:
-        self.assertRaises(ValueError, u.fill, [[-100, 5, 6], [1, 2, 3]])
+        u.fill(6 * pq.ft)
+        self.numAssertEqual(u,[[6, 6, 6], [6, 6, 6]] * pq.ft)
 
         # reshape
         y = [[1, 3, 4, 5], [1, 2, 3, 6]] * pq.inch
diff --git a/quantities/tests/test_50_umath.py b/quantities/tests/test_50_umath.py
@@ -5,6 +5,7 @@
 from nose.tools import *
 from numpy.testing import *
 from numpy.testing.utils import *
+from numpy.testing.decorators import skipif as skip_if
 
 import numpy as np
 import quantities as pq
@@ -157,37 +158,34 @@ def test_rounding():
     )
 
     #test rint
-    a = [-4.1, -3.6, -2.5, 0.1, 2.5, 3.1, 3.9] * pq.dimensionless
+    a = [-4.1, -3.6, -2.5, 0.1, 2.5, 3.1, 3.9] * pq.m
     assert_array_almost_equal(
         np.rint(a),
-        [-4., -4., -2., 0., 2., 3., 4.]
+        [-4., -4., -2., 0., 2., 3., 4.]*pq.m
     )
-    assert_raises(ValueError, np.rint, 3.3*pq.m)
-
-    # test fix
-# TODO: uncomment once np.fix behaves itself
-#    assert_array_equal(np.fix(3.14 * pq.degF), 3.0 * pq.degF)
-#    assert_array_equal(np.fix(3.0 * pq.degF), 3.0 * pq.degF)
-#    assert_array_equal(
-#        np.fix([2.1, 2.9, -2.1, -2.9] * pq.degF),
-#        [2., 2., -2., -2.] * pq.degF
-#    )
 
     # test floor
-    a = [-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0] * pq.dimensionless
+    a = [-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0] * pq.m
     assert_array_almost_equal(
         np.floor(a),
-        [-2., -2., -1., 0., 1., 1., 2.] * pq.dimensionless
+        [-2., -2., -1., 0., 1., 1., 2.] * pq.m
     )
-    assert_raises(ValueError, np.floor, 3.3*pq.m)
 
     # test ceil
-    a = [-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0] * pq.dimensionless
+    a = [-1.7, -1.5, -0.2, 0.2, 1.5, 1.7, 2.0] * pq.m
     assert_array_almost_equal(
         np.ceil(a),
-        [-1., -1., -0., 1., 2., 2., 2.] * pq.dimensionless
+        [-1., -1., -0., 1., 2., 2., 2.] * pq.m
+    )
+
+@skip_if(np.__version__[:3] < '1.4')
+def test_fix():
+    assert_array_equal(np.fix(3.14 * pq.degF), 3.0 * pq.degF)
+    assert_array_equal(np.fix(3.0 * pq.degF), 3.0 * pq.degF)
+    assert_array_equal(
+        np.fix([2.1, 2.9, -2.1, -2.9] * pq.degF),
+        [2., 2., -2., -2.] * pq.degF
     )
-    assert_raises(ValueError, np.ceil, 3.3*pq.m)
 
 
 def test_exponents_and_logarithms():
