示例#1
0
 def test_TimeDuration_iso(self):
     self.assertEqual(cf.Y(19).iso, "P19Y")
     self.assertEqual(cf.M(9).iso, "P9M")
     self.assertEqual(cf.D(34).iso, "P34D")
     self.assertEqual(cf.m(16).iso, "PT16M")
     self.assertEqual(cf.h(19897.546).iso, "PT19897.546H")
     self.assertEqual(cf.s(1989).iso, "PT1989S")
示例#2
0
 def test_TimeDuration_iso(self):
     self.assertTrue(cf.Y(19).iso == 'P19Y')
     self.assertTrue(cf.M(9).iso == 'P9M')
     self.assertTrue(cf.D(34).iso == 'P34D')
     self.assertTrue(cf.m(16).iso == 'PT16M')
     self.assertTrue(cf.h(19897.546).iso == 'PT19897.546H')
     self.assertTrue(cf.s(1989).iso == 'PT1989S')
示例#3
0
 def test_TimeDuration_interval(self):
     self.assertTrue(cf.M().interval(cf.dt(1999, 12)) == (
         cf.dt('1999-12-01 00:00:00', calendar=None),
         cf.dt('2000-01-01 00:00:00', calendar=None)))
     self.assertTrue(
         cf.Y(2).interval(cf.dt(2000, 2), end=True) == (
             cf.dt('1998-02-01 00:00:00', calendar=None),
             cf.dt('2000-02-01 00:00:00', calendar=None)))
     self.assertTrue(
         cf.D(30).interval(cf.dt(1983, 12, 1, 6)) == (
             cf.dt('1983-12-01 06:00:00', calendar=None),
             cf.dt('1983-12-31 06:00:00', calendar=None)))
     self.assertTrue(
         cf.D(30).interval(cf.dt(1983, 12, 1, 6), end=True) == (
             cf.dt('1983-11-01 06:00:00', calendar=None),
             cf.dt('1983-12-01 06:00:00', calendar=None)))
     self.assertTrue(
         cf.D(0).interval(cf.dt(1984, 2, 3)) == (
             cf.dt('1984-02-03 00:00:00', calendar=None),
             cf.dt('1984-02-03 00:00:00', calendar=None)))
     self.assertTrue(
         cf.D(5, hour=6).interval(cf.dt(2004, 3, 2), end=True) == (
             cf.dt('2004-02-26 00:00:00', calendar=None),
             cf.dt('2004-03-02 00:00:00', calendar=None)))
     self.assertTrue(
         cf.D(5, hour=6).interval(
             cf.dt(2004, 3, 2, calendar='noleap'), end=True) == (
                 cf.dt('2004-02-25 00:00:00', calendar='noleap'),
                 cf.dt('2004-03-02 00:00:00', calendar='noleap')))
     self.assertTrue(
         cf.D(5, hour=6).interval(
             cf.dt(2004, 3, 2, calendar='360_day'), end=True) == (
                 cf.dt('2004-02-27 00:00:00', calendar='360_day'),
                 cf.dt('2004-03-02 00:00:00', calendar='360_day')))
     self.assertTrue(
         cf.h(19897.5).interval(cf.dt(1984, 2, 3, 0)) == (
             cf.dt('1984-02-03 00:00:00', calendar=None),
             cf.dt('1986-05-12 01:30:00', calendar=None)))
     self.assertTrue(
         cf.h(19897.6).interval(cf.dt(1984, 2, 3, 0), end=True) == (
             cf.dt('1981-10-26 22:24:00', calendar=None),
             cf.dt('1984-02-03 00:00:00', calendar=None)))
示例#4
0
    def test_Field_collapse_GROUPS(self):
        if self.test_only and inspect.stack()[0][3] not in self.test_only:
            return

        verbose = False

        f = cf.example_field(2)

        g = f.collapse("T: mean", group=cf.M(12), group_span=cf.Y())
        expected_shape = list(f.shape)
        expected_shape[0] = 2

        if verbose:
            print(f)
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse("T: mean", group=cf.M(12, month=12), group_span=cf.Y())
        expected_shape = list(f.shape)
        expected_shape[0] = 3

        if verbose:
            print(f)
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse("T: mean", group=cf.M(12, day=16), group_span=cf.Y())
        expected_shape = list(f.shape)
        expected_shape[0] = 2

        if verbose:
            print(f)
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse(
            "T: mean", group=cf.M(12, month=11, day=27), group_span=cf.Y()
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 3

        if verbose:
            print(f)
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse(
            "T: mean", group=cf.M(12, month=6, day=27), group_span=cf.Y()
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 2

        if verbose:
            print(f)
            print(g)
            print(
                g.dimension_coordinates("T").value().bounds.data.datetime_array
            )
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse(
            "T: mean",
            group=cf.M(5, month=12),
            group_span=cf.M(5),
            group_contiguous=1,
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 7

        if verbose:
            print(f)
            print(g)
            print(
                g.dimension_coordinates("T").value().bounds.data.datetime_array
            )
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse(
            "T: mean",
            group=cf.M(5, month=12),
            group_span=cf.M(5),
            group_contiguous=1,
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 7

        if verbose:
            print(f)
            print(g)
            print(
                g.dimension_coordinates("T").value().bounds.data.datetime_array
            )
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse(
            "T: mean",
            group=cf.M(5, month=3),
            group_span=cf.M(5),
            group_contiguous=1,
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 7

        if verbose:
            print(f)
            print(g)
            print(
                g.dimension_coordinates("T").value().bounds.data.datetime_array
            )
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse(
            "T: mean",
            group=cf.M(5, month=2),
            group_span=cf.M(5),
            group_contiguous=1,
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 7

        if verbose:
            print(f)
            print(g)
            print(
                g.dimension_coordinates("T").value().bounds.data.datetime_array
            )
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse(
            "T: mean",
            group=cf.M(5, month=12),
            group_span=cf.M(5),
            group_contiguous=2,
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 7

        if verbose:
            print(f)
            print(g)
            print(
                g.dimension_coordinates("T").value().bounds.data.datetime_array
            )
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse("T: mean", group=cf.M(5, month=3))
        expected_shape = list(f.shape)
        expected_shape[0] = 7

        if verbose:
            print(f)
            print(g)
            print(
                g.dimension_coordinates("T").value().bounds.data.datetime_array
            )
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)
        # TODO - look into month offset when M< 12

        g = f.collapse(
            "T: mean",
            group=cf.M(5, month=3),
            group_span=cf.M(5),
            group_contiguous=2,
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 7

        if verbose:
            print(f)
            print(g)
            print(
                g.dimension_coordinates("T").value().bounds.data.datetime_array
            )
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse("T: mean", group=cf.M(5, month=12), group_contiguous=1)
        expected_shape = list(f.shape)
        expected_shape[0] = 7

        if verbose:
            print(f)
            print(g)
            print(
                g.dimension_coordinates("T").value().bounds.data.datetime_array
            )
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse("T: mean", group=cf.M(5, month=3), group_contiguous=1)
        expected_shape = list(f.shape)
        expected_shape[0] = 7

        if verbose:
            print(f)
            print(g)
            print(
                g.dimension_coordinates("T").value().bounds.data.datetime_array
            )
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse("T: mean", group=cf.M(5, month=12), group_contiguous=2)
        expected_shape = list(f.shape)
        expected_shape[0] = 7

        if verbose:
            print(f)
            print(g)
            print(
                g.dimension_coordinates("T").value().bounds.data.datetime_array
            )
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        # Test method=integral with groups
        g = f.collapse(
            "T: integral", group=cf.M(5, month=12), weights=True, measure=True
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 7
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse("T: mean", group=cf.M(5, month=3), group_contiguous=2)
        expected_shape = list(f.shape)
        expected_shape[0] = 7

        if verbose:
            print(f)
            print(g)
            print(
                g.dimension_coordinates("T").value().bounds.data.datetime_array
            )
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse(
            "T: mean within years time: minimum over years",
            within_years=cf.M(3),
            group_span=True,
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 4

        if verbose:
            print(f)
            print(g)
            print(
                g.dimension_coordinates("T").value().bounds.data.datetime_array
            )
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse(
            "T: mean within years time: minimum over years",
            within_years=cf.seasons(),
            group_span=cf.M(3),
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 4

        if verbose:
            print(f)
            print(g)
            print(
                g.dimension_coordinates("T").value().bounds.data.datetime_array
            )
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)
示例#5
0
    def test_Field_collapse_CLIMATOLOGICAL_TIME(self):
        if self.test_only and inspect.stack()[0][3] not in self.test_only:
            return

        verbose = False

        f = cf.example_field(2)

        g = f.collapse(
            "T: mean within years time: minimum over years",
            within_years=cf.seasons(),
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 4

        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape, g.shape)

        g = f.collapse(
            "T: max within years time: minimum over years",
            within_years=cf.seasons(),
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 4

        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape)

        g = f.collapse(
            "T: mean within years time: minimum over years",
            within_years=cf.M(),
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 12

        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape)

        g = f.collapse(
            "T: max within years time: minimum over years", within_years=cf.M()
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 12

        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape)

        g = f[:12].collapse(
            "T: mean within years time: minimum over years",
            within_years=cf.seasons(),
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 4

        if verbose:
            print("\n", f[:12])
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape)

        g = f[:12].collapse(
            "T: max within years time: minimum over years",
            within_years=cf.seasons(),
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 4

        if verbose:
            print("\n", f[:12])
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape)

        g = f[:12].collapse(
            "T: mean within years time: minimum over years",
            within_years=cf.M(),
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 12

        if verbose:
            print("\n", f[:12])
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape)

        g = f[:12].collapse(
            "T: max within years time: minimum over years", within_years=cf.M()
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 12

        if verbose:
            print("\n", f[:12])
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape)

        for key in f.cell_methods(todict=True):
            f.del_construct(key)

        g = f.collapse(
            "T: max within years time: minimum over years",
            within_years=cf.seasons(),
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 4

        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape)

        g = f.collapse(
            "T: max within years time: min over years", within_years=cf.M()
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 12

        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape)

        g = f[:12].collapse(
            "T: max within years time: minimum over years",
            within_years=cf.seasons(),
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 4

        if verbose:
            print("\n", f[:12])
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape)

        g = f[:12].collapse(
            "T: max within years time: minimum over years", within_years=cf.M()
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 12

        if verbose:
            print("\n", f[:12])
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape)

        g = f.collapse(
            "T: max within years time: minimum over years",
            within_years=cf.seasons(),
            over_years=cf.Y(2),
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 8

        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape)

        g = f[::-1, ...].collapse(
            "T: max within years time: minimum over years",
            within_years=cf.seasons(),
            over_years=cf.Y(2),
        )
        expected_shape = list(f.shape)
        expected_shape[0] = 8

        if verbose:
            print("\n", f[::-1, ...])
            print(g)
            print(g.constructs)
        self.assertEqual(list(g.shape), expected_shape)
示例#6
0
    def test_Field_collapse(self):
        if self.test_only and inspect.stack()[0][3] not in self.test_only:
            return

        verbose = False

        f = cf.read(self.filename2)[0]

        g = f.collapse("mean")
        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1, 1, 1), g.shape)

        g = f.collapse("mean", axes=["T", "X"])
        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1, 4, 1))

        g = f.collapse("mean", axes=[0, 2])

        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1, 4, 1))

        g = f.collapse("mean", axes=[0, 1])
        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1, 1, 5))

        g = f.collapse("mean", axes="domainaxis1")
        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1800, 1, 5))

        g = f.collapse("mean", axes=["domainaxis1"])
        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1800, 1, 5))

        g = f.collapse("mean", axes=[1])
        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1800, 1, 5))

        g = f.collapse("mean", axes=1)
        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1800, 1, 5))

        g = f.collapse("T: mean")
        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1, 4, 5))

        g = f.collapse("T: mean X: maximum")
        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1, 4, 1))

        g = f.collapse(
            "T: mean within years time: minimum over years",
            within_years=cf.M(),
        )
        if verbose:
            print("\n", f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (12, 4, 5))

        for m in range(1, 13):
            a = numpy.empty((5, 4, 5))
            for i, year in enumerate(
                f.subspace(T=cf.month(m)).coord("T").year.unique()
            ):
                cf.month(m) & cf.year(year)
                x = f.subspace(T=cf.month(m) & cf.year(year))
                x.data.mean(axes=0, inplace=True)
                a[i] = x.array

            a = a.min(axis=0)
            self.assertTrue(numpy.allclose(a, g.array[m % 12]))

        g = f.collapse("T: mean", group=360)

        for group in (
            cf.M(12),
            cf.M(12, month=12),
            cf.M(12, day=16),
            cf.M(12, month=11, day=27),
        ):
            g = f.collapse("T: mean", group=group)
            bound = g.coord("T").bounds.datetime_array[0, 1]
            self.assertEqual(
                bound.month,
                group.offset.month,
                f"{bound.month}!={group.offset.month}, group={group}",
            )
            self.assertEqual(
                bound.day,
                group.offset.day,
                f"{bound.day}!={group.offset.day}, group={group}",
            )
示例#7
0
    def test_Field_collapse(self):
        if self.test_only and inspect.stack()[0][3] not in self.test_only:
            return

        verbose = False

        f = cf.read(self.filename2)[0]

        g = f.collapse('mean')
        if verbose:
            print('\n', f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1, 1, 1), g.shape)

        g = f.collapse('mean', axes=['T', 'X'])
        if verbose:
            print('\n', f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1, 4, 1))

        g = f.collapse('mean', axes=[0, 2])

        if verbose:
            print('\n', f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1, 4, 1))

        g = f.collapse('mean', axes=[0, 1])
        if verbose:
            print('\n', f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1, 1, 5))

        g = f.collapse('mean', axes='domainaxis1')
        if verbose:
            print('\n', f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1800, 1, 5))

        g = f.collapse('mean', axes=['domainaxis1'])
        if verbose:
            print('\n', f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1800, 1, 5))

        g = f.collapse('mean', axes=[1])
        if verbose:
            print('\n', f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1800, 1, 5))

        g = f.collapse('mean', axes=1)
        if verbose:
            print('\n', f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1800, 1, 5))

        g = f.collapse('T: mean')
        if verbose:
            print('\n', f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1, 4, 5))

        g = f.collapse('T: mean X: maximum')
        if verbose:
            print('\n', f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (1, 4, 1))

        g = f.collapse('T: mean within years time: minimum over years',
                       within_years=cf.M())
        if verbose:
            print('\n', f)
            print(g)
            print(g.constructs)
        self.assertEqual(g.shape, (12, 4, 5))

        for m in range(1, 13):
            a = numpy.empty((5, 4, 5))
            for i, year in enumerate(
                    f.subspace(T=cf.month(m)).coord('T').year.unique()):
                q = cf.month(m) & cf.year(year)
                x = f.subspace(T=cf.month(m) & cf.year(year))
                x.data.mean(axes=0, inplace=True)
                a[i] = x.array

            a = a.min(axis=0)
            self.assertTrue(numpy.allclose(a, g.array[m % 12]))
        # --- End: for

        g = f.collapse('T: mean', group=360)

        for group in (cf.M(12), cf.M(12, month=12), cf.M(12, day=16),
                      cf.M(12, month=11, day=27)):
            g = f.collapse('T: mean', group=group)
            bound = g.coord('T').bounds.datetime_array[0, 1]
            self.assertEqual(
                bound.month, group.offset.month,
                "{}!={}, group={}".format(bound.month, group.offset.month,
                                          group))
            self.assertEqual(
                bound.day, group.offset.day,
                "{}!={}, group={}".format(bound.day, group.offset.day, group))
示例#8
0
    def test_TimeDuration_arithmetic(self):
        self.assertTrue(cf.M() + cf.dt(2000, 1, 1) == cf.dt(2000, 2, 1))
        self.assertTrue(cf.M() * 8 == cf.M(8))
        self.assertTrue(cf.M() * 8.5 == cf.M(8.5))
        self.assertTrue(cf.dt(2000, 1, 1) + cf.M() == cf.dt(2000, 2, 1))
        self.assertTrue(cf.dt(2000, 1, 1) - cf.M() == cf.dt(1999, 12, 1))
        self.assertTrue(cf.M() +
                        datetime.datetime(2000, 1, 1) == cf.dt(2000, 2, 1))
        self.assertTrue(
            datetime.datetime(2000, 1, 1) + cf.M() == cf.dt(2000, 2, 1))
        self.assertTrue(
            datetime.datetime(2000, 1, 1) - cf.M() == cf.dt(1999, 12, 1))

        d = cf.dt(2000, 1, 1)
        d += cf.M()
        self.assertTrue(d == cf.dt(2000, 2, 1))
        d -= cf.M()
        self.assertTrue(d == cf.dt(2000, 1, 1))

        d = datetime.datetime(2000, 1, 1)
        d += cf.M()
        self.assertTrue(d == cf.dt(2000, 2, 1))
        d -= cf.M()
        self.assertTrue(d == cf.dt(2000, 1, 1))

        self.assertTrue(cf.M() * 8 == cf.M(8))
        self.assertTrue(cf.M() * 8.5 == cf.M(8.5))
        self.assertTrue(cf.M() / 2.0 == cf.M(0.5))
        self.assertTrue(cf.M(8) / 3 == cf.M(8 / 3))
        self.assertTrue(cf.M(8) // 3 == cf.M(2))
示例#9
0
    def test_TimeDuration_bounds(self):
        for direction in (True, False):
            for x, y in zip([
                    cf.Y().bounds(cf.dt(1984, 1, 1), direction=direction),
                    cf.Y().bounds(cf.dt(1984, 12, 1), direction=direction),
                    cf.Y().bounds(cf.dt(1984, 12, 3), direction=direction),
                    cf.Y(month=9).bounds(cf.dt(1984, 1, 1),
                                         direction=direction),
                    cf.Y(month=9).bounds(cf.dt(1984, 3, 3),
                                         direction=direction),
                    cf.Y(month=9).bounds(cf.dt(1984, 9, 20),
                                         direction=direction),
                    cf.Y(month=9, day=13).bounds(cf.dt(1984, 12, 12),
                                                 direction=direction),
            ], [
                (cf.dt('1984-01-01', calendar='standard'),
                 cf.dt('1985-01-01', calendar='standard')),
                (cf.dt('1984-01-01', calendar='standard'),
                 cf.dt('1985-01-01', calendar='standard')),
                (cf.dt('1984-01-01', calendar='standard'),
                 cf.dt('1985-01-01', calendar='standard')),
                (cf.dt('1983-09-01', calendar='standard'),
                 cf.dt('1984-09-01', calendar='standard')),
                (cf.dt('1983-09-01', calendar='standard'),
                 cf.dt('1984-09-01', calendar='standard')),
                (cf.dt('1984-09-01', calendar='standard'),
                 cf.dt('1985-09-01', calendar='standard')),
                (cf.dt('1984-09-13', calendar='standard'),
                 cf.dt('1985-09-13', calendar='standard')),
            ]):
                if direction is False:
                    y = y[::-1]
                self.assertTrue(x == y,
                                "{}!={} direction={}".format(x, y, direction))

            for x, y in zip([
                    cf.M().bounds(cf.dt(1984, 1, 1), direction=direction),
                    cf.M().bounds(cf.dt(1984, 12, 1), direction=direction),
                    cf.M().bounds(cf.dt(1984, 12, 3), direction=direction),
                    cf.M(day=15).bounds(cf.dt(1984, 12, 1),
                                        direction=direction),
                    cf.M(day=15).bounds(cf.dt(1984, 12, 3),
                                        direction=direction),
                    cf.M(day=15).bounds(cf.dt(1984, 12, 15),
                                        direction=direction),
                    cf.M(day=15).bounds(cf.dt(1984, 12, 20),
                                        direction=direction),
            ], [
                (cf.dt('1984-01-01', calendar='standard'),
                 cf.dt('1984-02-01', calendar='standard')),
                (cf.dt('1984-12-01', calendar='standard'),
                 cf.dt('1985-01-01', calendar='standard')),
                (cf.dt('1984-12-01', calendar='standard'),
                 cf.dt('1985-01-01', calendar='standard')),
                (cf.dt('1984-11-15', calendar='standard'),
                 cf.dt('1984-12-15', calendar='standard')),
                (cf.dt('1984-11-15', calendar='standard'),
                 cf.dt('1984-12-15', calendar='standard')),
                (cf.dt('1984-12-15', calendar='standard'),
                 cf.dt('1985-01-15', calendar='standard')),
                (cf.dt('1984-12-15', calendar='standard'),
                 cf.dt('1985-01-15', calendar='standard')),
            ]):
                if direction is False:
                    y = y[::-1]
                self.assertTrue(x == y, "{}!={}".format(x, y))

            for x, y in zip([
                    cf.D().bounds(cf.dt(1984, 1, 1), direction=direction),
                    cf.D().bounds(cf.dt(1984, 12, 3), direction=direction),
                    cf.D(hour=15).bounds(cf.dt(1984, 12, 1),
                                         direction=direction),
                    cf.D(hour=15).bounds(cf.dt(1984, 12, 1, 12),
                                         direction=direction),
                    cf.D(hour=15).bounds(cf.dt(1984, 12, 1, 15),
                                         direction=direction),
                    cf.D(hour=15).bounds(cf.dt(1984, 12, 1, 20),
                                         direction=direction),
            ], [
                (cf.dt('1984-01-01', calendar='gregorian'),
                 cf.dt('1984-01-02', calendar='gregorian')),
                (cf.dt('1984-12-03', calendar='gregorian'),
                 cf.dt('1984-12-04', calendar='gregorian')),
                (cf.dt('1984-11-30 15:00', calendar='gregorian'),
                 cf.dt('1984-12-01 15:00', calendar='gregorian')),
                (cf.dt('1984-11-30 15:00', calendar='gregorian'),
                 cf.dt('1984-12-01 15:00', calendar='gregorian')),
                (cf.dt('1984-12-01 15:00', calendar='gregorian'),
                 cf.dt('1984-12-02 15:00', calendar='gregorian')),
                (cf.dt('1984-12-01 15:00', calendar='gregorian'),
                 cf.dt('1984-12-02 15:00', calendar='gregorian')),
            ]):
                if direction is False:
                    y = y[::-1]

                self.assertTrue(x == y, "{}!={}".format(x, y))
示例#10
0
    def test_TimeDuration(self):
        self.assertGreater(cf.TimeDuration(2, 'calendar_years'),
                           cf.TimeDuration(1, 'calendar_years'))
        self.assertLess(cf.TimeDuration(2, 'calendar_years'),
                        cf.TimeDuration(25, 'calendar_months'))
        self.assertLessEqual(cf.TimeDuration(2, 'hours'),
                             cf.TimeDuration(1, 'days'))
        self.assertEqual(cf.TimeDuration(2, 'hours'),
                         cf.TimeDuration(1 / 12.0, 'days'))
        self.assertEqual(cf.TimeDuration(2, 'days'),
                         cf.TimeDuration(48, 'hours'))
        self.assertEqual(cf.TimeDuration(2, 'days'), cf.Data(2))
        self.assertEqual(cf.TimeDuration(2, 'days'), cf.Data([2.], 'days'))
        self.assertGreater(cf.TimeDuration(2, 'days'),
                           cf.Data([[60]], 'seconds'))
        self.assertLessEqual(cf.TimeDuration(2, 'hours'), 2)
        self.assertEqual(cf.TimeDuration(0.1, units='seconds'), 0.1)
        self.assertNotEqual(cf.TimeDuration(2, 'days'), 30.5)
        self.assertGreater(cf.TimeDuration(2, 'calendar_years'),
                           numpy.array(1.5))
        self.assertLess(cf.TimeDuration(2, 'calendar_months'),
                        numpy.array([[12]]))

        self.assertGreater(cf.TimeDuration(2, 'calendar_years'),
                           cf.TimeDuration(1, 'calendar_years'))
        self.assertLessEqual(cf.TimeDuration(1, 'calendar_years'),
                             cf.TimeDuration(2, 'calendar_years'))

        self.assertGreaterEqual(cf.TimeDuration(25, 'calendar_months'),
                                cf.TimeDuration(2, 'calendar_years'))
        self.assertLess(cf.TimeDuration(2, 'calendar_years'),
                        cf.TimeDuration(25, 'calendar_months'))

        self.assertGreaterEqual(cf.TimeDuration(1, 'days'),
                                cf.TimeDuration(2, 'hours'))
        self.assertEqual(cf.TimeDuration(2, 'hours'),
                         cf.TimeDuration(1 / 12.0, 'days'))
        self.assertEqual(cf.TimeDuration(2, 'days'),
                         cf.TimeDuration(48, 'hours'))
        self.assertEqual(cf.TimeDuration(2, 'days'), cf.Data(2))
        self.assertEqual(cf.TimeDuration(2, 'days'), cf.Data([2.], 'days'))
        self.assertGreater(cf.TimeDuration(2, 'days'),
                           cf.Data([[60]], 'seconds'))
        self.assertEqual(cf.TimeDuration(2, 'hours'), 2)
        self.assertNotEqual(cf.TimeDuration(2, 'days'), 30.5)
        self.assertGreater(cf.TimeDuration(2, 'calendar_years'),
                           numpy.array(1.5))
        self.assertLess(cf.TimeDuration(2, 'calendar_months'),
                        numpy.array([[12]]))

        self.assertEqual(cf.TimeDuration(64, 'calendar_years') + 2, cf.Y(66))
        self.assertEqual(
            cf.TimeDuration(64, 'calendar_years') - 2.5, cf.Y(61.5))
        self.assertEqual(
            cf.M(23) + cf.TimeDuration(64, 'calendar_years'), cf.M(791))
        self.assertEqual(
            cf.TimeDuration(64, 'calendar_years') + cf.M(24), cf.Y(66))

        self.assertTrue(
            cf.TimeDuration(36, 'calendar_months') / 8 == cf.M(4.5))
        self.assertTrue(cf.TimeDuration(36, 'calendar_months') // 8 == cf.M(4))

        self.assertTrue(
            cf.TimeDuration(36, 'calendar_months') /
            numpy.array(8.0) == cf.M(36 / 8.0))
        self.assertTrue(
            cf.TimeDuration(12, 'calendar_months') *
            cf.Data([[1.5]]) == cf.Y(1.5))
        self.assertTrue(
            cf.TimeDuration(36, 'calendar_months') // 8.25 == cf.M(4.0))
        self.assertTrue(cf.TimeDuration(36, 'calendar_months') % 10 == cf.M(6))

        self.assertTrue(
            cf.TimeDuration(24, 'hours') +
            cf.TimeDuration(0.5, 'days') == cf.h(36.0))
        self.assertTrue(
            cf.TimeDuration(0.5, 'days') +
            cf.TimeDuration(24, 'hours') == cf.D(1.5))

        t = cf.TimeDuration(24, 'hours')
        t += 2
        self.assertTrue(t == cf.h(26))
        t -= cf.Data(3, 'hours')
        self.assertTrue(t == cf.h(23))
        t = cf.TimeDuration(24.0, 'hours')
        t += 2
        self.assertTrue(t == cf.h(26))
        self.assertTrue(t - cf.Data(2.5, 'hours') == cf.h(23.5))
        t *= 2
        self.assertTrue(t == cf.h(52.0))
        t -= 1.0
        self.assertTrue(t == cf.h(51))
        t /= 3
        self.assertTrue(t == cf.h(17))
        t += 5.5
        self.assertTrue(t == cf.h(22.5))
        t //= numpy.array(2)
        self.assertTrue(t == cf.h(11.0))
        t *= 10
        self.assertTrue(t == cf.h(110.0))
        t %= 3
        self.assertTrue(t == cf.h(2.0))

        t = cf.TimeDuration(24.5, 'hours')
        self.assertTrue(-t == -24.5)
        self.assertTrue(int(t) == 24)
        self.assertTrue(t / 0.5 == 49)
        self.assertTrue(t // 2 == 12)
        self.assertTrue(25 - t == 0.5)
        self.assertTrue(2 * t == 49)
        self.assertTrue(2.0 % t == 2, 2.0 % t)

        self.assertTrue(cf.TimeDuration(24, 'hours').isint)
        self.assertTrue(cf.TimeDuration(24.0, 'hours').isint)
        self.assertFalse(t.isint)

        t.Units = 'days'
        self.assertTrue(t.Units == cf.Units('days'))
        t.Units = 'hours'

        self.assertTrue(cf.TimeDuration(12, 'hours').is_day_factor())
        self.assertFalse(cf.TimeDuration(13, 'hours').is_day_factor())
        self.assertFalse(cf.TimeDuration(2, 'days').is_day_factor())

        self.assertTrue(cf.TimeDuration(cf.Data(2, 'days')) == 2)
        self.assertTrue(cf.TimeDuration(cf.Data(48, 'hours')) == 48)
        self.assertTrue(
            cf.TimeDuration(cf.Data(48, 'hours'), units='days') == 2)
        self.assertTrue(cf.TimeDuration(0.1, units='seconds') == 0.1)

        self.assertTrue(t.equals(t, verbose=2))
        self.assertTrue(t.equals(t.copy(), verbose=2))

        self.assertTrue(t.equivalent(t, verbose=2))
        self.assertTrue(t.equivalent(t.copy(), verbose=2))

        with self.assertRaises(Exception):
            t = cf.TimeDuration(48, 'm')
        with self.assertRaises(Exception):
            t = cf.TimeDuration(cf.Data(48, 'm'))
        with self.assertRaises(Exception):
            t = cf.TimeDuration(cf.Data(48, 'days'), units='m')

        t = t.copy()
        t = copy.deepcopy(t)

        _ = repr(t)
        _ = str(t)

        t //= 2
        t %= 2
示例#11
0
f = cf.read(sub_interdata_folder + '/' + year + '-???Sa_track.nc')
f.pop(21)
f.pop(19)
f.pop(17)
f.pop(15)
f.pop(13)
f.pop(11)

f_out = output_folder + '/' + region + '_source_forward_' + band + '_' + year + '_daily.nc'
print f_out
cf.write(f, f_out, single=True)

if region == 'cn1':
    E = f.select_field('E', exact=True).collapse('sum',
                                                 axes='time',
                                                 group=cf.M())
    P = f.select_field('P', exact=True).collapse('sum',
                                                 axes='time',
                                                 group=cf.M())
    W_down = f.select_field('W_down', exact=True).collapse('mean',
                                                           axes='time',
                                                           group=cf.M())
    W_top = f.select_field('W_top', exact=True).collapse('mean',
                                                         axes='time',
                                                         group=cf.M())

    Fa_E_down = f.select_field('Fa_E_down', exact=True).collapse('sum',
                                                                 axes='time',
                                                                 group=cf.M())
    Fa_E_top = f.select_field('Fa_E_top', exact=True).collapse('sum',
                                                               axes='time',
示例#12
0
    def test_TimeDuration_arithmetic(self):
        self.assertEqual(cf.M() + cf.dt(2000, 1, 1), cf.dt(2000, 2, 1))
        self.assertEqual(cf.M() * 8, cf.M(8))
        self.assertEqual(cf.M() * 8.5, cf.M(8.5))
        self.assertEqual(cf.dt(2000, 1, 1) + cf.M(), cf.dt(2000, 2, 1))
        self.assertEqual(cf.dt(2000, 1, 1) - cf.M(), cf.dt(1999, 12, 1))
        self.assertEqual(
            cf.M() + datetime.datetime(2000, 1, 1),
            cf.dt(2000, 2, 1, calendar="gregorian"),
        )
        self.assertEqual(
            datetime.datetime(2000, 1, 1) + cf.M(),
            cf.dt(2000, 2, 1, calendar="gregorian"),
        )
        self.assertEqual(
            datetime.datetime(2000, 1, 1) - cf.M(),
            cf.dt(1999, 12, 1, calendar="gregorian"),
        )

        d = cf.dt(2000, 1, 1)
        d += cf.M()
        self.assertEqual(d, cf.dt(2000, 2, 1))
        d -= cf.M()
        self.assertEqual(d, cf.dt(2000, 1, 1))

        d = datetime.datetime(2000, 1, 1)
        d += cf.M()
        self.assertEqual(d, cf.dt(2000, 2, 1, calendar="gregorian"))
        d -= cf.M()
        self.assertEqual(d, cf.dt(2000, 1, 1, calendar="gregorian"))

        self.assertEqual(cf.M() * 8, cf.M(8))
        self.assertEqual(cf.M() * 8.5, cf.M(8.5))
        self.assertEqual(cf.M() / 2.0, cf.M(0.5))
        self.assertEqual(cf.M(8) / 3, cf.M(8 / 3))
        self.assertEqual(cf.M(8) // 3, cf.M(2))

        # Test arithmetic involving Data as well as datetimes:
        da = cf.Data([2], units="days since 2000-01-01")
        dt = cf.TimeDuration(14, "day")
        t0 = da + dt
        t1 = dt + da
        self.assertEqual(
            t0,
            cf.dt(2000, 1, 17, calendar="gregorian"),
        )
        self.assertEqual(t0, t1)
        t2 = dt - da
        t3 = da - dt
        self.assertEqual(
            t2,
            cf.dt(1999, 12, 20, calendar="gregorian"),
        )
        self.assertEqual(t2, t3)
示例#13
0
    def test_TimeDuration_bounds(self):
        for direction in (True, False):
            for x, y in zip(
                [
                    cf.Y().bounds(cf.dt(1984, 1, 1), direction=direction),
                    cf.Y().bounds(cf.dt(1984, 12, 1), direction=direction),
                    cf.Y().bounds(cf.dt(1984, 12, 3), direction=direction),
                    cf.Y(month=9).bounds(
                        cf.dt(1984, 1, 1), direction=direction
                    ),
                    cf.Y(month=9).bounds(
                        cf.dt(1984, 3, 3), direction=direction
                    ),
                    cf.Y(month=9).bounds(
                        cf.dt(1984, 9, 20), direction=direction
                    ),
                    cf.Y(month=9, day=13).bounds(
                        cf.dt(1984, 12, 12), direction=direction
                    ),
                ],
                [
                    (
                        cf.dt("1984-01-01", calendar="standard"),
                        cf.dt("1985-01-01", calendar="standard"),
                    ),
                    (
                        cf.dt("1984-01-01", calendar="standard"),
                        cf.dt("1985-01-01", calendar="standard"),
                    ),
                    (
                        cf.dt("1984-01-01", calendar="standard"),
                        cf.dt("1985-01-01", calendar="standard"),
                    ),
                    (
                        cf.dt("1983-09-01", calendar="standard"),
                        cf.dt("1984-09-01", calendar="standard"),
                    ),
                    (
                        cf.dt("1983-09-01", calendar="standard"),
                        cf.dt("1984-09-01", calendar="standard"),
                    ),
                    (
                        cf.dt("1984-09-01", calendar="standard"),
                        cf.dt("1985-09-01", calendar="standard"),
                    ),
                    (
                        cf.dt("1984-09-13", calendar="standard"),
                        cf.dt("1985-09-13", calendar="standard"),
                    ),
                ],
            ):
                if direction is False:
                    y = y[::-1]

                self.assertEqual(x, y, f"{x}!={y} direction={direction}")

            for x, y in zip(
                [
                    cf.M().bounds(cf.dt(1984, 1, 1), direction=direction),
                    cf.M().bounds(cf.dt(1984, 12, 1), direction=direction),
                    cf.M().bounds(cf.dt(1984, 12, 3), direction=direction),
                    cf.M(day=15).bounds(
                        cf.dt(1984, 12, 1), direction=direction
                    ),
                    cf.M(day=15).bounds(
                        cf.dt(1984, 12, 3), direction=direction
                    ),
                    cf.M(day=15).bounds(
                        cf.dt(1984, 12, 15), direction=direction
                    ),
                    cf.M(day=15).bounds(
                        cf.dt(1984, 12, 20), direction=direction
                    ),
                ],
                [
                    (
                        cf.dt("1984-01-01", calendar="standard"),
                        cf.dt("1984-02-01", calendar="standard"),
                    ),
                    (
                        cf.dt("1984-12-01", calendar="standard"),
                        cf.dt("1985-01-01", calendar="standard"),
                    ),
                    (
                        cf.dt("1984-12-01", calendar="standard"),
                        cf.dt("1985-01-01", calendar="standard"),
                    ),
                    (
                        cf.dt("1984-11-15", calendar="standard"),
                        cf.dt("1984-12-15", calendar="standard"),
                    ),
                    (
                        cf.dt("1984-11-15", calendar="standard"),
                        cf.dt("1984-12-15", calendar="standard"),
                    ),
                    (
                        cf.dt("1984-12-15", calendar="standard"),
                        cf.dt("1985-01-15", calendar="standard"),
                    ),
                    (
                        cf.dt("1984-12-15", calendar="standard"),
                        cf.dt("1985-01-15", calendar="standard"),
                    ),
                ],
            ):
                if direction is False:
                    y = y[::-1]
                self.assertEqual(x, y, f"{x}!={y}")

            for x, y in zip(
                [
                    cf.D().bounds(cf.dt(1984, 1, 1), direction=direction),
                    cf.D().bounds(cf.dt(1984, 12, 3), direction=direction),
                    cf.D(hour=15).bounds(
                        cf.dt(1984, 12, 1), direction=direction
                    ),
                    cf.D(hour=15).bounds(
                        cf.dt(1984, 12, 1, 12), direction=direction
                    ),
                    cf.D(hour=15).bounds(
                        cf.dt(1984, 12, 1, 15), direction=direction
                    ),
                    cf.D(hour=15).bounds(
                        cf.dt(1984, 12, 1, 20), direction=direction
                    ),
                ],
                [
                    (
                        cf.dt("1984-01-01", calendar="gregorian"),
                        cf.dt("1984-01-02", calendar="gregorian"),
                    ),
                    (
                        cf.dt("1984-12-03", calendar="gregorian"),
                        cf.dt("1984-12-04", calendar="gregorian"),
                    ),
                    (
                        cf.dt("1984-11-30 15:00", calendar="gregorian"),
                        cf.dt("1984-12-01 15:00", calendar="gregorian"),
                    ),
                    (
                        cf.dt("1984-11-30 15:00", calendar="gregorian"),
                        cf.dt("1984-12-01 15:00", calendar="gregorian"),
                    ),
                    (
                        cf.dt("1984-12-01 15:00", calendar="gregorian"),
                        cf.dt("1984-12-02 15:00", calendar="gregorian"),
                    ),
                    (
                        cf.dt("1984-12-01 15:00", calendar="gregorian"),
                        cf.dt("1984-12-02 15:00", calendar="gregorian"),
                    ),
                ],
            ):
                if direction is False:
                    y = y[::-1]

                self.assertEqual(x, y, f"{x}!={y}")
示例#14
0
    def test_TimeDuration(self):
        self.assertGreater(
            cf.TimeDuration(2, "calendar_years"),
            cf.TimeDuration(1, "calendar_years"),
        )
        self.assertLess(
            cf.TimeDuration(2, "calendar_years"),
            cf.TimeDuration(25, "calendar_months"),
        )
        self.assertLessEqual(
            cf.TimeDuration(2, "hours"), cf.TimeDuration(1, "days")
        )
        self.assertEqual(
            cf.TimeDuration(2, "hours"), cf.TimeDuration(1 / 12.0, "days")
        )
        self.assertEqual(
            cf.TimeDuration(2, "days"), cf.TimeDuration(48, "hours")
        )
        self.assertEqual(cf.TimeDuration(2, "days"), cf.Data(2))
        self.assertEqual(cf.TimeDuration(2, "days"), cf.Data([2.0], "days"))
        self.assertGreater(
            cf.TimeDuration(2, "days"), cf.Data([[60]], "seconds")
        )
        self.assertLessEqual(cf.TimeDuration(2, "hours"), 2)
        self.assertEqual(cf.TimeDuration(0.1, units="seconds"), 0.1)
        self.assertNotEqual(cf.TimeDuration(2, "days"), 30.5)
        self.assertGreater(
            cf.TimeDuration(2, "calendar_years"), numpy.array(1.5)
        )
        self.assertLess(
            cf.TimeDuration(2, "calendar_months"), numpy.array([[12]])
        )

        self.assertGreater(
            cf.TimeDuration(2, "calendar_years"),
            cf.TimeDuration(1, "calendar_years"),
        )
        self.assertLessEqual(
            cf.TimeDuration(1, "calendar_years"),
            cf.TimeDuration(2, "calendar_years"),
        )

        self.assertGreaterEqual(
            cf.TimeDuration(25, "calendar_months"),
            cf.TimeDuration(2, "calendar_years"),
        )
        self.assertLess(
            cf.TimeDuration(2, "calendar_years"),
            cf.TimeDuration(25, "calendar_months"),
        )

        self.assertGreaterEqual(
            cf.TimeDuration(1, "days"), cf.TimeDuration(2, "hours")
        )
        self.assertEqual(
            cf.TimeDuration(2, "hours"), cf.TimeDuration(1 / 12.0, "days")
        )
        self.assertEqual(
            cf.TimeDuration(2, "days"), cf.TimeDuration(48, "hours")
        )
        self.assertEqual(cf.TimeDuration(2, "days"), cf.Data(2))
        self.assertEqual(cf.TimeDuration(2, "days"), cf.Data([2.0], "days"))
        self.assertGreater(
            cf.TimeDuration(2, "days"), cf.Data([[60]], "seconds")
        )
        self.assertEqual(cf.TimeDuration(2, "hours"), 2)
        self.assertNotEqual(cf.TimeDuration(2, "days"), 30.5)
        self.assertGreater(
            cf.TimeDuration(2, "calendar_years"), numpy.array(1.5)
        )
        self.assertLess(
            cf.TimeDuration(2, "calendar_months"), numpy.array([[12]])
        )

        self.assertEqual(cf.TimeDuration(64, "calendar_years") + 2, cf.Y(66))
        self.assertEqual(
            cf.TimeDuration(64, "calendar_years") - 2.5, cf.Y(61.5)
        )
        self.assertEqual(
            cf.M(23) + cf.TimeDuration(64, "calendar_years"), cf.M(791)
        )
        self.assertEqual(
            cf.TimeDuration(64, "calendar_years") + cf.M(24), cf.Y(66)
        )

        self.assertEqual(cf.TimeDuration(36, "calendar_months") / 8, cf.M(4.5))
        self.assertEqual(cf.TimeDuration(36, "calendar_months") // 8, cf.M(4))

        self.assertEqual(
            cf.TimeDuration(36, "calendar_months") / numpy.array(8.0),
            cf.M(36 / 8.0),
        )
        self.assertEqual(
            cf.TimeDuration(12, "calendar_months") * cf.Data([[1.5]]),
            cf.Y(1.5),
        )
        self.assertEqual(
            cf.TimeDuration(36, "calendar_months") // 8.25, cf.M(4.0)
        )
        self.assertEqual(cf.TimeDuration(36, "calendar_months") % 10, cf.M(6))

        self.assertEqual(
            cf.TimeDuration(24, "hours") + cf.TimeDuration(0.5, "days"),
            cf.h(36.0),
        )
        self.assertEqual(
            cf.TimeDuration(0.5, "days") + cf.TimeDuration(24, "hours"),
            cf.D(1.5),
        )

        t = cf.TimeDuration(24, "hours")
        t += 2
        self.assertEqual(t, cf.h(26))
        t -= cf.Data(3, "hours")
        self.assertEqual(t, cf.h(23))
        t = cf.TimeDuration(24.0, "hours")
        t += 2
        self.assertEqual(t, cf.h(26))
        self.assertEqual(t - cf.Data(2.5, "hours"), cf.h(23.5))
        t *= 2
        self.assertEqual(t, cf.h(52.0))
        t -= 1.0
        self.assertEqual(t, cf.h(51))
        t /= 3
        self.assertEqual(t, cf.h(17))
        t += 5.5
        self.assertEqual(t, cf.h(22.5))
        t //= numpy.array(2)
        self.assertEqual(t, cf.h(11.0))
        t *= 10
        self.assertEqual(t, cf.h(110.0))
        t %= 3
        self.assertEqual(t, cf.h(2.0))

        t = cf.TimeDuration(24.5, "hours")
        self.assertEqual(-t, -24.5)
        self.assertEqual(int(t), 24)
        self.assertEqual(t / 0.5, 49)
        self.assertEqual(t // 2, 12)
        self.assertEqual(25 - t, 0.5)
        self.assertEqual(2 * t, 49)
        self.assertEqual(2.0 % t, 2, 2.0 % t)

        self.assertTrue(cf.TimeDuration(24, "hours").isint)
        self.assertTrue(cf.TimeDuration(24.0, "hours").isint)
        self.assertFalse(t.isint)

        t.Units = "days"
        self.assertEqual(t.Units, cf.Units("days"))
        t.Units = "hours"

        self.assertTrue(cf.TimeDuration(12, "hours").is_day_factor())
        self.assertFalse(cf.TimeDuration(13, "hours").is_day_factor())
        self.assertFalse(cf.TimeDuration(2, "days").is_day_factor())

        self.assertEqual(cf.TimeDuration(cf.Data(2, "days")), 2)
        self.assertEqual(cf.TimeDuration(cf.Data(48, "hours")), 48)
        self.assertEqual(
            cf.TimeDuration(cf.Data(48, "hours"), units="days"), 2
        )
        self.assertEqual(cf.TimeDuration(0.1, units="seconds"), 0.1)

        self.assertTrue(t.equals(t, verbose=2))
        self.assertTrue(t.equals(t.copy(), verbose=2))

        self.assertTrue(t.equivalent(t, verbose=2))
        self.assertTrue(t.equivalent(t.copy(), verbose=2))

        with self.assertRaises(Exception):
            t = cf.TimeDuration(48, "m")
        with self.assertRaises(Exception):
            t = cf.TimeDuration(cf.Data(48, "m"))
        with self.assertRaises(Exception):
            t = cf.TimeDuration(cf.Data(48, "days"), units="m")

        t = t.copy()
        t = copy.deepcopy(t)

        repr(t)
        str(t)

        t //= 2
        t %= 2
    def test_TimeDuration_arithmetic(self):
        self.assertEqual(cf.M() + cf.dt(2000, 1, 1), cf.dt(2000, 2, 1))
        self.assertEqual(cf.M() * 8, cf.M(8))
        self.assertEqual(cf.M() * 8.5, cf.M(8.5))
        self.assertEqual(cf.dt(2000, 1, 1) + cf.M(), cf.dt(2000, 2, 1))
        self.assertEqual(cf.dt(2000, 1, 1) - cf.M(), cf.dt(1999, 12, 1))
        self.assertEqual(
            cf.M() + datetime.datetime(2000, 1, 1),
            cf.dt(2000, 2, 1, calendar="gregorian"),
        )
        self.assertEqual(
            datetime.datetime(2000, 1, 1) + cf.M(),
            cf.dt(2000, 2, 1, calendar="gregorian"),
        )
        self.assertEqual(
            datetime.datetime(2000, 1, 1) - cf.M(),
            cf.dt(1999, 12, 1, calendar="gregorian"),
        )

        d = cf.dt(2000, 1, 1)
        d += cf.M()
        self.assertEqual(d, cf.dt(2000, 2, 1))
        d -= cf.M()
        self.assertEqual(d, cf.dt(2000, 1, 1))

        d = datetime.datetime(2000, 1, 1)
        d += cf.M()
        self.assertEqual(d, cf.dt(2000, 2, 1, calendar="gregorian"))
        d -= cf.M()
        self.assertEqual(d, cf.dt(2000, 1, 1, calendar="gregorian"))

        self.assertEqual(cf.M() * 8, cf.M(8))
        self.assertEqual(cf.M() * 8.5, cf.M(8.5))
        self.assertEqual(cf.M() / 2.0, cf.M(0.5))
        self.assertEqual(cf.M(8) / 3, cf.M(8 / 3))
        self.assertEqual(cf.M(8) // 3, cf.M(2))