Ejemplo n.º 1
0
 def test_is_quantity_sequence(self):
     self.assertTrue(
         _is_quantity_sequence((self.Q_(0, "m"), self.Q_(32.0, "degF"))))
     self.assertTrue(_is_quantity_sequence(np.arange(4) * self.ureg.m))
     self.assertFalse(_is_quantity_sequence((self.Q_(0), True)))
     self.assertFalse(_is_quantity_sequence([1, 3, 5]))
     self.assertFalse(_is_quantity_sequence(9 * self.ureg.m))
     self.assertFalse(_is_quantity_sequence(np.arange(4)))
     self.assertFalse(_is_quantity_sequence("0123"))
Ejemplo n.º 2
0
 def test_rad2deg(self):
     self._test1(
         np.rad2deg,
         (np.arange(0, pi / 2, pi / 4) * self.ureg.dimensionless,
          np.arange(0, pi / 2, pi / 4) * self.ureg.radian,
          np.arange(0, pi / 2, pi / 4) * self.ureg.mm / self.ureg.m),
         (self.ureg.m, ),
         'degree',
         results=(None, None,
                  np.rad2deg(np.arange(0, pi / 2, pi / 4) * 0.001)))
Ejemplo n.º 3
0
 def test_arccosh(self):
     self._test1(
         np.arccosh,
         (
             np.arange(1.0, 1.9, 0.1) * self.ureg.dimensionless,
             np.arange(1.0, 1.9, 0.1) * self.ureg.m / self.ureg.m,
         ),
         (1 * self.ureg.m, ),
         "radian",
     )
Ejemplo n.º 4
0
 def test_arctanh(self):
     self._test1(
         np.arctanh,
         (
             np.arange(0, 0.9, 0.1) * self.ureg.dimensionless,
             np.arange(0, 0.9, 0.1) * self.ureg.m / self.ureg.m,
         ),
         (0.1 * self.ureg.m, ),
         "radian",
     )
Ejemplo n.º 5
0
 def test_einsum(self):
     a = np.arange(25).reshape(5, 5) * self.ureg.m
     b = np.arange(5) * self.ureg.m
     self.assertQuantityEqual(np.einsum("ii", a), 60 * self.ureg.m)
     self.assertQuantityEqual(np.einsum("ii->i", a),
                              np.array([0, 6, 12, 18, 24]) * self.ureg.m)
     self.assertQuantityEqual(np.einsum("i,i", b, b), 30 * self.ureg.m**2)
     self.assertQuantityEqual(
         np.einsum("ij,j", a, b),
         np.array([30, 80, 130, 180, 230]) * self.ureg.m**2,
     )
Ejemplo n.º 6
0
 def test_rad2deg(self):
     self._test1(np.rad2deg,
                 (np.arange(0, pi/2, pi/4) * self.ureg.dimensionless,
                  np.arange(0, pi/2, pi/4) * self.ureg.radian,
                  np.arange(0, pi/2, pi/4) * self.ureg.mm / self.ureg.m,
                  ),
                 (self.ureg.m, ), 'degree',
                 results=(None,
                          None,
                          np.rad2deg(np.arange(0, pi/2, pi/4)*0.001) * self.ureg.degree,
                 ))
Ejemplo n.º 7
0
 def test_is_sequence_with_quantity_elements(self):
     assert _is_sequence_with_quantity_elements(
         (self.Q_(0, "m"), self.Q_(32.0, "degF")))
     assert _is_sequence_with_quantity_elements(np.arange(4) * self.ureg.m)
     assert _is_sequence_with_quantity_elements((self.Q_(0), 0))
     assert _is_sequence_with_quantity_elements((0, self.Q_(0)))
     assert not _is_sequence_with_quantity_elements([1, 3, 5])
     assert not _is_sequence_with_quantity_elements(9 * self.ureg.m)
     assert not _is_sequence_with_quantity_elements(np.arange(4))
     assert not _is_sequence_with_quantity_elements("0123")
     assert not _is_sequence_with_quantity_elements([])
     assert not _is_sequence_with_quantity_elements(np.array([]))
Ejemplo n.º 8
0
 def test_is_sequence_with_quantity_elements(self):
     self.assertTrue(
         _is_sequence_with_quantity_elements(
             (self.Q_(0, "m"), self.Q_(32.0, "degF"))))
     self.assertTrue(
         _is_sequence_with_quantity_elements(np.arange(4) * self.ureg.m))
     self.assertFalse(
         _is_sequence_with_quantity_elements((self.Q_(0), True)))
     self.assertFalse(_is_sequence_with_quantity_elements([1, 3, 5]))
     self.assertFalse(_is_sequence_with_quantity_elements(9 * self.ureg.m))
     self.assertFalse(_is_sequence_with_quantity_elements(np.arange(4)))
     self.assertFalse(_is_sequence_with_quantity_elements("0123"))
     self.assertFalse(_is_sequence_with_quantity_elements([]))
     self.assertFalse(_is_sequence_with_quantity_elements(np.array([])))
Ejemplo n.º 9
0
 def test_deg2rad(self):
     self._test1(
         np.deg2rad,
         (np.arange(0, pi / 2, pi / 4) * self.ureg.degrees, ),
         (1 * self.ureg.m, ),
         "radians",
     )
Ejemplo n.º 10
0
 def test_convert_to_consistent_units_with_dimensionality_error(self):
     with pytest.raises(DimensionalityError):
         convert_to_consistent_units(
             self.Q_(32.0, "degF"),
             pre_calc_units=self.ureg.meter,
         )
     with pytest.raises(DimensionalityError):
         convert_to_consistent_units(
             np.arange(4),
             pre_calc_units=self.ureg.meter,
         )
Ejemplo n.º 11
0
    def test_unwrap_and_wrap_constistent_units(self):
        (a, ), output_wrap_a = unwrap_and_wrap_consistent_units([2, 4, 8] *
                                                                self.ureg.m)
        (b, c), output_wrap_c = unwrap_and_wrap_consistent_units(
            np.arange(4), self.Q_(1, "g/kg"))

        self.assertNDArrayEqual(a, np.array([2, 4, 8]))
        self.assertNDArrayEqual(b, np.array([0, 1000, 2000, 3000]))
        assert c == 1

        helpers.assert_quantity_equal(output_wrap_a(0), 0 * self.ureg.m)
        helpers.assert_quantity_equal(output_wrap_c(0), self.Q_(0, "g/kg"))
Ejemplo n.º 12
0
 def test_tanh(self):
     self._test1(np.tanh, (np.arange(0, pi/2, pi/4) * self.ureg.dimensionless,
                           np.arange(0, pi/2, pi/4) * self.ureg.radian,
                           np.arange(0, pi/2, pi/4) * self.ureg.mm / self.ureg.m
                          ), (1*self.ureg.m, ), '', results=(None, None, np.tanh(np.arange(0, pi/2, pi/4)*0.001)))
     self._test1(np.tanh, (np.rad2deg(np.arange(0, pi/2, pi/4)) * self.ureg.degrees,
                          ), results=(np.tanh(np.arange(0, pi/2, pi/4)), ))
Ejemplo n.º 13
0
 def test_tanh(self):
     self._test1(np.tanh, (np.arange(0, pi/2, pi/4) * self.ureg.dimensionless,
                           np.arange(0, pi/2, pi/4) * self.ureg.radian,
                           np.arange(0, pi/2, pi/4) * self.ureg.mm / self.ureg.m
                          ), (self.ureg.m, ), '', results=(None, None, np.tanh(np.arange(0, pi/2, pi/4)*0.001)))
     self._test1(np.tanh, (np.rad2deg(np.arange(0, pi/2, pi/4)) * self.ureg.degrees,
                          ), results=(np.tanh(np.arange(0, pi/2, pi/4)), ))
Ejemplo n.º 14
0
 def test_convert_to_consistent_units_with_dimensionality_error(self):
     self.assertRaises(
         DimensionalityError,
         convert_to_consistent_units,
         self.Q_(32.0, "degF"),
         pre_calc_units=self.ureg.meter,
     )
     self.assertRaises(
         DimensionalityError,
         convert_to_consistent_units,
         np.arange(4),
         pre_calc_units=self.ureg.meter,
     )
Ejemplo n.º 15
0
 def test_convert_to_consistent_units_with_pre_calc_units(self):
     args, kwargs = convert_to_consistent_units(
         self.Q_(50, "cm"),
         np.arange(4).reshape(2, 2) * self.ureg.m,
         [0.042] * self.ureg.km,
         (self.Q_(0, "m"), self.Q_(1, "dam")),
         a=6378 * self.ureg.km,
         pre_calc_units=self.ureg.meter,
     )
     assert args[0] == 0.5
     self.assertNDArrayEqual(args[1], np.array([[0, 1], [2, 3]]))
     self.assertNDArrayEqual(args[2], np.array([42]))
     assert args[3][0] == 0
     assert args[3][1] == 10
     assert kwargs["a"] == 6.378e6
Ejemplo n.º 16
0
 def test_arctan2(self):
     m = self.ureg.m
     j = self.ureg.J
     km = self.ureg.km
     self._test2(np.arctan2, np.arange(0, .9, .1) * m,
                 (np.arange(0, .9, .1) * m, np.arange(.9, 0., -.1) * m,
                  np.arange(0, .9, .1) * km, np.arange(.9, 0., -.1) * km,
                 ),
                 raise_with=np.arange(0, .9, .1) * j,
                 output_units='radian')
Ejemplo n.º 17
0
 def test_arctan2(self):
     m = self.ureg.m
     j = self.ureg.J
     km = self.ureg.km
     self._test2(np.arctan2, np.arange(0, .9, .1) * m,
                 (np.arange(0, .9, .1) * m, np.arange(.9, 0., -.1) * m,
                  np.arange(0, .9, .1) * km, np.arange(.9, 0., -.1) * km,
                 ),
                 raise_with=np.arange(0, .9, .1) * j,
                 output_units='radian')
Ejemplo n.º 18
0
 def test_arctan2(self):
     m = self.ureg.m
     j = self.ureg.J
     km = self.ureg.km
     self._test2(
         np.arctan2,
         np.arange(0, 0.9, 0.1) * m,
         (
             np.arange(0, 0.9, 0.1) * m,
             np.arange(0.9, 0.0, -0.1) * m,
             np.arange(0, 0.9, 0.1) * km,
             np.arange(0.9, 0.0, -0.1) * km,
         ),
         raise_with=np.arange(0, 0.9, 0.1) * j,
         output_units="radian",
     )
Ejemplo n.º 19
0
 def test_cos(self):
     self._test1(
         np.cos,
         (
             np.arange(0, pi / 2, pi / 4) * self.ureg.dimensionless,
             np.arange(0, pi / 2, pi / 4) * self.ureg.radian,
             np.arange(0, pi / 2, pi / 4) * self.ureg.mm / self.ureg.m,
         ),
         (1 * self.ureg.m, ),
         "",
         results=(None, None, np.cos(np.arange(0, pi / 2, pi / 4) * 0.001)),
     )
     self._test1(
         np.cos,
         (np.rad2deg(np.arange(0, pi / 2, pi / 4)) * self.ureg.degrees, ),
         results=(np.cos(np.arange(0, pi / 2, pi / 4)), ),
     )
Ejemplo n.º 20
0
 def test_arccos(self):
     x = np.arange(0, .9, .1) * self.ureg.m
     self._test1(np.arccos, (np.arange(0, .9, .1) * self.ureg.dimensionless,
                             np.arange(0, .9, .1) * self.ureg.m / self.ureg.m
                            ), (self.ureg.m, ), 'radian')
Ejemplo n.º 21
0
 def test_shape(self):
     u = self.Q_(np.arange(12))
     u.shape = 4, 3
     self.assertEqual(u.magnitude.shape, (4, 3))
Ejemplo n.º 22
0
    def test_pad(self):
        # Tests reproduced with modification from NumPy documentation
        a = [1, 2, 3, 4, 5] * self.ureg.m
        b = self.Q_([4.0, 6.0, 8.0, 9.0, -3.0], "degC")

        self.assertQuantityEqual(np.pad(a, (2, 3), "constant"),
                                 [0, 0, 1, 2, 3, 4, 5, 0, 0, 0] * self.ureg.m)
        self.assertQuantityEqual(
            np.pad(a, (2, 3),
                   "constant",
                   constant_values=(0, 600 * self.ureg.cm)),
            [0, 0, 1, 2, 3, 4, 5, 6, 6, 6] * self.ureg.m,
        )
        self.assertQuantityEqual(
            np.pad(b, (2, 1),
                   "constant",
                   constant_values=(np.nan, self.Q_(10, "degC"))),
            self.Q_([np.nan, np.nan, 4, 6, 8, 9, -3, 10], "degC"),
        )
        self.assertRaises(DimensionalityError,
                          np.pad,
                          a, (2, 3),
                          "constant",
                          constant_values=4)
        self.assertQuantityEqual(np.pad(a, (2, 3), "edge"),
                                 [1, 1, 1, 2, 3, 4, 5, 5, 5, 5] * self.ureg.m)
        self.assertQuantityEqual(
            np.pad(a, (2, 3), "linear_ramp"),
            [0, 0, 1, 2, 3, 4, 5, 3, 1, 0] * self.ureg.m,
        )
        self.assertQuantityEqual(
            np.pad(a, (2, 3), "linear_ramp", end_values=(5, -4) * self.ureg.m),
            [5, 3, 1, 2, 3, 4, 5, 2, -1, -4] * self.ureg.m,
        )
        self.assertQuantityEqual(np.pad(a, (2, ), "maximum"),
                                 [5, 5, 1, 2, 3, 4, 5, 5, 5] * self.ureg.m)
        self.assertQuantityEqual(np.pad(a, (2, ), "mean"),
                                 [3, 3, 1, 2, 3, 4, 5, 3, 3] * self.ureg.m)
        self.assertQuantityEqual(np.pad(a, (2, ), "median"),
                                 [3, 3, 1, 2, 3, 4, 5, 3, 3] * self.ureg.m)
        self.assertQuantityEqual(
            np.pad(self.q, ((3, 2), (2, 3)), "minimum"),
            [
                [1, 1, 1, 2, 1, 1, 1],
                [1, 1, 1, 2, 1, 1, 1],
                [1, 1, 1, 2, 1, 1, 1],
                [1, 1, 1, 2, 1, 1, 1],
                [3, 3, 3, 4, 3, 3, 3],
                [1, 1, 1, 2, 1, 1, 1],
                [1, 1, 1, 2, 1, 1, 1],
            ] * self.ureg.m,
        )
        self.assertQuantityEqual(np.pad(a, (2, 3), "reflect"),
                                 [3, 2, 1, 2, 3, 4, 5, 4, 3, 2] * self.ureg.m)
        self.assertQuantityEqual(
            np.pad(a, (2, 3), "reflect", reflect_type="odd"),
            [-1, 0, 1, 2, 3, 4, 5, 6, 7, 8] * self.ureg.m,
        )
        self.assertQuantityEqual(np.pad(a, (2, 3), "symmetric"),
                                 [2, 1, 1, 2, 3, 4, 5, 5, 4, 3] * self.ureg.m)
        self.assertQuantityEqual(
            np.pad(a, (2, 3), "symmetric", reflect_type="odd"),
            [0, 1, 1, 2, 3, 4, 5, 5, 6, 7] * self.ureg.m,
        )
        self.assertQuantityEqual(np.pad(a, (2, 3), "wrap"),
                                 [4, 5, 1, 2, 3, 4, 5, 1, 2, 3] * self.ureg.m)

        def pad_with(vector, pad_width, iaxis, kwargs):
            pad_value = kwargs.get("padder", 10)
            vector[:pad_width[0]] = pad_value
            vector[-pad_width[1]:] = pad_value

        b = self.Q_(np.arange(6).reshape((2, 3)), "degC")
        self.assertQuantityEqual(
            np.pad(b, 2, pad_with),
            self.Q_(
                [
                    [10, 10, 10, 10, 10, 10, 10],
                    [10, 10, 10, 10, 10, 10, 10],
                    [10, 10, 0, 1, 2, 10, 10],
                    [10, 10, 3, 4, 5, 10, 10],
                    [10, 10, 10, 10, 10, 10, 10],
                    [10, 10, 10, 10, 10, 10, 10],
                ],
                "degC",
            ),
        )
        self.assertQuantityEqual(
            np.pad(b, 2, pad_with, padder=100),
            self.Q_(
                [
                    [100, 100, 100, 100, 100, 100, 100],
                    [100, 100, 100, 100, 100, 100, 100],
                    [100, 100, 0, 1, 2, 100, 100],
                    [100, 100, 3, 4, 5, 100, 100],
                    [100, 100, 100, 100, 100, 100, 100],
                    [100, 100, 100, 100, 100, 100, 100],
                ],
                "degC",
            ),
        )  # Note: Does not support Quantity pad_with vectorized callable use
Ejemplo n.º 23
0
 def test_convert_to_consistent_units_with_dimensionless(self):
     args, kwargs = convert_to_consistent_units(np.arange(2),
                                                pre_calc_units=self.ureg.g /
                                                self.ureg.kg)
     self.assertNDArrayEqual(args[0], np.array([0, 1000]))
     assert kwargs == {}
Ejemplo n.º 24
0
 def test_arccosh(self):
     self._test1(np.arccosh, (np.arange(1., 1.9, .1) * self.ureg.dimensionless,
                              np.arange(1., 1.9, .1) * self.ureg.m / self.ureg.m
                             ), (self.ureg.m, ), 'radian')
Ejemplo n.º 25
0
 def test_arctanh(self):
     self._test1(np.arctanh, (np.arange(0, .9, .1) * self.ureg.dimensionless,
                              np.arange(0, .9, .1) * self.ureg.m / self.ureg.m
                             ), (.1 * self.ureg.m, ), 'radian')
Ejemplo n.º 26
0
 def test_arccosh(self):
     self._test1(np.arccosh,
                 (np.arange(1., 1.9, .1) * self.ureg.dimensionless,
                  np.arange(1., 1.9, .1) * self.ureg.m / self.ureg.m),
                 (self.ureg.m, ), 'radian')
Ejemplo n.º 27
0
 def test_is_quantity(self):
     assert _is_quantity(self.Q_(0))
     assert _is_quantity(np.arange(4) * self.ureg.m)
     assert not _is_quantity(1.0)
     assert not _is_quantity(np.array([1, 1, 2, 3, 5, 8]))
     assert not _is_quantity("not-a-quantity")
Ejemplo n.º 28
0
 def test_arctanh(self):
     self._test1(np.arctanh,
                 (np.arange(0, .9, .1) * self.ureg.dimensionless,
                  np.arange(0, .9, .1) * self.ureg.m / self.ureg.m),
                 (.1 * self.ureg.m, ), 'radian')
Ejemplo n.º 29
0
 def test_shape(self):
     u = self.Q_(np.arange(12))
     u.shape = 4, 3
     self.assertEqual(u.magnitude.shape, (4, 3))
Ejemplo n.º 30
0
 def test_shape(self):
     u = self.Q_(np.arange(12))
     u.shape = 4, 3
     assert u.magnitude.shape == (4, 3)
Ejemplo n.º 31
0
 def test_arccos(self):
     x = np.arange(0, .9, .1) * self.ureg.m
     self._test1(np.arccos,
                 (np.arange(0, .9, .1) * self.ureg.dimensionless,
                  np.arange(0, .9, .1) * self.ureg.m / self.ureg.m),
                 (self.ureg.m, ), 'radian')
Ejemplo n.º 32
0
 def test_deg2rad(self):
     self._test1(np.deg2rad, (np.arange(0, pi/2, pi/4) * self.ureg.degrees,
                              ), (self.ureg.m, ), 'radians')
Ejemplo n.º 33
0
 def test_is_quantity(self):
     self.assertTrue(_is_quantity(self.Q_(0)))
     self.assertTrue(_is_quantity(np.arange(4) * self.ureg.m))
     self.assertFalse(_is_quantity(1.0))
     self.assertFalse(_is_quantity(np.array([1, 1, 2, 3, 5, 8])))
     self.assertFalse(_is_quantity("not-a-quantity"))