Пример #1
0
    def test_simple_multiple_coords(self):
        expected_result = np.array(2.5)
        r = iintrp.linear(self.simple2d_cube, [
            ('dim1', 4),
            ('dim2', 3.5),
        ])
        np.testing.assert_array_equal(r.data, expected_result)
        self.assertCML(r, ('analysis', 'interpolation', 'linear',
                           'simple_multiple_coords.cml'),
                       checksum=False)

        # Check that it doesn't matter if you do the interpolation in separate steps...
        r = iintrp.linear(self.simple2d_cube, [('dim2', 3.5)])
        r = iintrp.linear(r, [('dim1', 4)])
        np.testing.assert_array_equal(r.data, expected_result)
        self.assertCML(r, ('analysis', 'interpolation', 'linear',
                           'simple_multiple_coords.cml'),
                       checksum=False)

        r = iintrp.linear(self.simple2d_cube, [('dim1', 4)])
        r = iintrp.linear(r, [('dim2', 3.5)])
        np.testing.assert_array_equal(r.data, expected_result)
        self.assertCML(r, ('analysis', 'interpolation', 'linear',
                           'simple_multiple_coords.cml'),
                       checksum=False)
Пример #2
0
    def _assert_expected_call(self, sample_points, sample_points_call,
                              cinterp_patch, linear_patch):
        linear_patch.return_value = self.scheme
        linear(self.cube, sample_points, self.extrapolation)

        linear_patch.assert_called_once_with(self.extrapolation)

        cinterp_patch.assert_called_once_with(sample_points_call, self.scheme)
Пример #3
0
 def test_simple_coord_linear_extrapolation(self):
     r = iintrp.linear( self.simple2d_cube, [('dim2', 2.5)], extrapolation_mode='linear')
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_coord_linear_extrapolation.cml'))
     
     np.testing.assert_array_equal(r.data, np.array([-1.,  2.,  5.,  8.], dtype=self.simple2d_cube.data.dtype))
     
     r = iintrp.linear(self.simple2d_cube, [('dim1', 1)])
     np.testing.assert_array_equal(r.data, np.array([-3., -2., -1.], dtype=self.simple2d_cube.data.dtype))
Пример #4
0
    def _assert_expected_call(self, sample_points, sample_points_call,
                              cinterp_patch, linear_patch):
        linear_patch.return_value = self.scheme
        linear(self.cube, sample_points, self.extrapolation)

        linear_patch.assert_called_once_with(self.extrapolation)

        cinterp_patch.assert_called_once_with(sample_points_call, self.scheme)
Пример #5
0
 def test_simple_coord_linear_extrapolation(self):
     r = iintrp.linear( self.simple2d_cube, [('dim2', 2.5)], extrapolation_mode='linear')
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_coord_linear_extrapolation.cml'))
     
     np.testing.assert_array_equal(r.data, np.array([-1.,  2.,  5.,  8.], dtype=self.simple2d_cube.data.dtype))
     
     r = iintrp.linear(self.simple2d_cube, [('dim1', 1)])
     np.testing.assert_array_equal(r.data, np.array([-3., -2., -1.], dtype=self.simple2d_cube.data.dtype))
Пример #6
0
 def test_simple_multiple_points_circular(self):
     r = iintrp.linear(self.simple2d_cube_circular, [('theta', [0., 60., 120., 180.])])
     normalise_order(r)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_multiple_points_circular.cml'))
     
     # check that the values returned by theta 0 & 360 are the same...
     r1 = iintrp.linear(self.simple2d_cube_circular, [('theta', 360)])
     r2 = iintrp.linear(self.simple2d_cube_circular, [('theta', 0)])
     np.testing.assert_array_almost_equal(r1.data, r2.data)
Пример #7
0
 def test_simple_multiple_points_circular(self):
     r = iintrp.linear(self.simple2d_cube_circular, [('theta', [0., 60., 120., 180.])])
     normalise_order(r)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_multiple_points_circular.cml'))
     
     # check that the values returned by theta 0 & 360 are the same...
     r1 = iintrp.linear(self.simple2d_cube_circular, [('theta', 360)])
     r2 = iintrp.linear(self.simple2d_cube_circular, [('theta', 0)])
     np.testing.assert_array_almost_equal(r1.data, r2.data)
Пример #8
0
 def test_simple_multiple_point(self):
     r = iintrp.linear(self.simple2d_cube, [('dim1', [4, 5])])
     np.testing.assert_array_equal(r.data, np.array([[ 1.5,  2.5,  3.5], [ 3.,  4.,  5. ]]))
     normalise_order(r)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_multiple_points.cml'))
     
     # Check that numpy arrays specifications work
     r = iintrp.linear(self.simple2d_cube, [('dim1', np.array([4, 5]))])
     normalise_order(r)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_multiple_points.cml'))
Пример #9
0
 def test_simple_multiple_point(self):
     r = iintrp.linear(self.simple2d_cube, [('dim1', [4, 5])])
     np.testing.assert_array_equal(r.data, np.array([[ 1.5,  2.5,  3.5], [ 3.,  4.,  5. ]]))
     normalise_order(r)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_multiple_points.cml'))
     
     # Check that numpy arrays specifications work
     r = iintrp.linear(self.simple2d_cube, [('dim1', np.array([4, 5]))])
     normalise_order(r)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_multiple_points.cml'))
Пример #10
0
    def test_single_point_to_scalar(self):
        # Slice to form (3, 1) shaped cube.
        cube = self.cube[:, 2:3]
        r = iintrp.linear(cube, [('longitude', 1.)])
        self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                     'single_pt_to_scalar_0'))

        # Slice to form (1, 4) shaped cube.
        cube = self.cube[1:2, :]
        r = iintrp.linear(cube, [('latitude', 1.)])
        self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                     'single_pt_to_scalar_1'))
Пример #11
0
    def test_multiple_points(self):
        # Slice to form (3, 1) shaped cube.
        cube = self.cube[:, 2:3]
        r = iintrp.linear(cube, [('longitude', [1., 2., 3., 4.])])
        self.assertCMLApproxData(
            r, ('analysis', 'interpolation', 'linear', 'single_pt_to_many_0'))

        # Slice to form (1, 4) shaped cube.
        cube = self.cube[1:2, :]
        r = iintrp.linear(cube, [('latitude', [1., 2., 3., 4.])])
        self.assertCMLApproxData(
            r, ('analysis', 'interpolation', 'linear', 'single_pt_to_many_1'))
Пример #12
0
    def test_single_point_to_scalar(self):
        # Slice to form (3, 1) shaped cube.
        cube = self.cube[:, 2:3]
        r = iintrp.linear(cube, [('longitude', 1.)])
        self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                     'single_pt_to_scalar_0'))

        # Slice to form (1, 4) shaped cube.
        cube = self.cube[1:2, :]
        r = iintrp.linear(cube, [('latitude', 1.)])
        self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                     'single_pt_to_scalar_1'))
Пример #13
0
    def test_multiple_points(self):
        # Slice to form (3, 1) shaped cube.
        cube = self.cube[:, 2:3]
        r = iintrp.linear(cube, [('longitude',
                                                     [1., 2., 3., 4.])])
        self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                     'single_pt_to_many_0'))

        # Slice to form (1, 4) shaped cube.
        cube = self.cube[1:2, :]
        r = iintrp.linear(cube, [('latitude',
                                                     [1., 2., 3., 4.])])
        self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                     'single_pt_to_many_1'))
Пример #14
0
 def test_multi(self):
     # Testing interpolation on specified points on cube with
     # multidimensional coordinates.
     interp_cube = linear(self.cube, {'latitude': 1.5, 'longitude': 1.5})
     self.assertCMLApproxData(interp_cube,
                              ('experimental', 'analysis', 'interpolate',
                               'linear_nd_2_coords.cml'))
Пример #15
0
 def test_simple_multiple_coords(self):
     expected_result = np.array(2.5)
     r = iintrp.linear(self.simple2d_cube, [('dim1', 4), ('dim2', 3.5), ])
     np.testing.assert_array_equal(r.data, expected_result)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_multiple_coords.cml'), checksum=False)
     
     # Check that it doesn't matter if you do the interpolation in separate steps...
     r = iintrp.linear(self.simple2d_cube, [('dim2', 3.5)])
     r = iintrp.linear(r, [('dim1', 4)])
     np.testing.assert_array_equal(r.data, expected_result)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_multiple_coords.cml'), checksum=False)
     
     r = iintrp.linear(self.simple2d_cube, [('dim1', 4)])
     r = iintrp.linear(r, [('dim2', 3.5)])
     np.testing.assert_array_equal(r.data, expected_result)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_multiple_coords.cml'), checksum=False)
Пример #16
0
 def test_extrapolation_mode_same_pt(self):
     # Slice to form (3, 1) shaped cube.
     cube = self.cube[:, 2:3]
     src_points = cube.coord('longitude').points
     r = iintrp.linear(cube, [('longitude', src_points)],
                                          extrapolation_mode='linear')
     self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                  'single_pt_to_same_pt'))
     r = iintrp.linear(cube, [('longitude', src_points)],
                                          extrapolation_mode='nan')
     self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                  'single_pt_to_same_pt'))
     r = iintrp.linear(cube, [('longitude', src_points)],
                                          extrapolation_mode='error')
     self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                  'single_pt_to_same_pt'))
Пример #17
0
 def test_dim_to_aux(self):
     cube = self.simple2d_cube
     other = iris.coords.DimCoord([1, 2, 3, 4], long_name='was_dim')
     cube.add_aux_coord(other, 0)
     r = iintrp.linear(cube, [('dim1', [7, 3, 5])])
     normalise_order(r)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'dim_to_aux.cml'))
Пример #18
0
 def test_extrapolation_mode_same_pt(self):
     # Slice to form (3, 1) shaped cube.
     cube = self.cube[:, 2:3]
     src_points = cube.coord('longitude').points
     r = iintrp.linear(cube, [('longitude', src_points)],
                                          extrapolation_mode='linear')
     self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                  'single_pt_to_same_pt'))
     r = iintrp.linear(cube, [('longitude', src_points)],
                                          extrapolation_mode='nan')
     self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                  'single_pt_to_same_pt'))
     r = iintrp.linear(cube, [('longitude', src_points)],
                                          extrapolation_mode='error')
     self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                  'single_pt_to_same_pt'))
Пример #19
0
 def test_multi(self):
     # Testing interpolation on specified points on cube with
     # multidimensional coordinates.
     interp_cube = linear(self.cube, {'latitude': 1.5, 'longitude': 1.5})
     self.assertCMLApproxData(interp_cube, ('experimental', 'analysis',
                                            'interpolate',
                                            'linear_nd_2_coords.cml'))
Пример #20
0
 def test_single(self):
     # Interpolation on the 1d coordinate.
     interp_cube = linear(self.cube, {'wibble': 20})
     self.assertArrayEqual(np.mean(self.cube.data, axis=0),
                           interp_cube.data)
     self.assertCMLApproxData(interp_cube, ('experimental', 'analysis',
                                            'interpolate', 'linear_nd.cml'))
Пример #21
0
def linear(cube, sample_points, extrapolation_mode='linear'):
    msg = (_INTERPOLATE_DEPRECATION_WARNING + '\n' +
           'Please replace usage of iris.analysis.interpolate.linear() with '
           'iris.cube.Cube.interpolate(..., scheme=iris.analysis.Linear()).')
    _warn_deprecated(msg)
    return oldinterp.linear(cube, sample_points,
                            extrapolation_mode=extrapolation_mode)
Пример #22
0
 def test_dim_to_aux(self):
     cube = self.simple2d_cube
     other = iris.coords.DimCoord([1, 2, 3, 4], long_name='was_dim')
     cube.add_aux_coord(other, 0)
     r = iintrp.linear(cube, [('dim1', [7, 3, 5])])
     normalise_order(r)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'dim_to_aux.cml'))
Пример #23
0
def linear(cube, sample_points, extrapolation_mode='linear'):
    msg = (_INTERPOLATE_DEPRECATION_WARNING + '\n' +
           'Please replace usage of iris.analysis.interpolate.linear() with '
           'iris.cube.Cube.interpolate(..., scheme=iris.analysis.Linear()).')
    _warn_deprecated(msg)
    return oldinterp.linear(cube,
                            sample_points,
                            extrapolation_mode=extrapolation_mode)
Пример #24
0
 def test_circular_vs_non_circular_coord(self):
     cube = self.simple2d_cube_circular
     other = iris.coords.AuxCoord([10, 6, 7, 4], long_name='other')
     cube.add_aux_coord(other, 1)
     samples = [0, 60, 300]
     r = iintrp.linear(cube, [('theta', samples)])
     normalise_order(r)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'circular_vs_non_circular.cml'))
Пример #25
0
 def test_shared_axis(self):
     c = self.simple2d_cube_extended
     r = iintrp.linear(c, [('dim2', [3.5, 3.25])])
     normalise_order(r)
     
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_shared_axis.cml'))
     
     self.assertRaises(ValueError, iintrp.linear, c, [('dim2', [3.5, 3.25]), ('shared_x_coord', [9, 7])])
Пример #26
0
 def test_circular_vs_non_circular_coord(self):
     cube = self.simple2d_cube_circular
     other = iris.coords.AuxCoord([10, 6, 7, 4], long_name='other')
     cube.add_aux_coord(other, 1)
     samples = [0, 60, 300]
     r = iintrp.linear(cube, [('theta', samples)])
     normalise_order(r)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'circular_vs_non_circular.cml'))
Пример #27
0
 def test_single(self):
     # Interpolation on the 1d coordinate.
     interp_cube = linear(self.cube, {'wibble': 20})
     self.assertArrayEqual(np.mean(self.cube.data, axis=0),
                           interp_cube.data)
     self.assertCMLApproxData(
         interp_cube,
         ('experimental', 'analysis', 'interpolate', 'linear_nd.cml'))
Пример #28
0
 def test_shared_axis(self):
     c = self.simple2d_cube_extended
     r = iintrp.linear(c, [('dim2', [3.5, 3.25])])
     normalise_order(r)
     
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_shared_axis.cml'))
     
     self.assertRaises(ValueError, iintrp.linear, c, [('dim2', [3.5, 3.25]), ('shared_x_coord', [9, 7])])
Пример #29
0
    def test_mask_retention(self):
        cube = stock.realistic_4d_w_missing_data()
        interp_cube = linear(cube, [('pressure', [850, 950])])
        self.assertIsInstance(interp_cube.data, np.ma.MaskedArray)

        # this value is masked in the input
        self.assertTrue(cube.data.mask[0, 2, 2, 0])
        # and is still masked in the output
        self.assertTrue(interp_cube.data.mask[0, 1, 2, 0])
Пример #30
0
 def test_simple_single_point(self):
     r = iintrp.linear(self.simple2d_cube, [('dim1', 4)])
     self.assertCML(
         r,
         ('analysis', 'interpolation', 'linear', 'simple_single_point.cml'),
         checksum=False)
     np.testing.assert_array_equal(
         r.data,
         np.array([1.5, 2.5, 3.5], dtype=self.simple2d_cube.data.dtype))
Пример #31
0
 def test_positive(self):
     # Check we can interpolate from a Cube defined over [0, 360).
     cube = self._create_cube([0, 90, 180, 270])
     samples = [('longitude', np.arange(-360, 720, 45))]
     result = interpolate.linear(cube, samples, extrapolation_mode='nan')
     normalise_order(result)
     self.assertCMLApproxData(result,
                              ('analysis', 'interpolation', 'linear',
                               'circular_wrapping', 'positive'))
Пример #32
0
    def test_circular(self):
        res = iintrp.linear(self.cube,
                                               [('longitude', 359.8)])
        normalise_order(res)
        lon_coord = self.cube.coord('longitude').points
        expected = self.cube.data[..., 0] + \
            ((self.cube.data[..., -1] - self.cube.data[..., 0]) *
             (((360 - 359.8) - lon_coord[0]) /
              ((360 - lon_coord[-1]) - lon_coord[0])))
        self.assertArrayAllClose(res.data, expected, rtol=1.0e-6)

        # check that the values returned by lon 0 & 360 are the same...
        r1 = iintrp.linear(self.cube, [('longitude', 360)])
        r2 = iintrp.linear(self.cube, [('longitude', 0)])
        np.testing.assert_array_equal(r1.data, r2.data)

        self.assertCML(res, ('analysis', 'interpolation', 'linear',
                             'real_circular_2dslice.cml'), checksum=False)
Пример #33
0
 def test_bounded_coordinate(self):
     # The results should be exactly the same as for the
     # non-bounded case.
     cube = self.simple2d_cube
     cube.coord('dim1').guess_bounds()
     r = iintrp.linear(cube, [('dim1', [4, 5])])
     np.testing.assert_array_equal(r.data, np.array([[ 1.5,  2.5,  3.5], [ 3.,  4.,  5. ]]))
     normalise_order(r)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_multiple_points.cml'))
Пример #34
0
 def test_positive(self):
     # Check we can interpolate from a Cube defined over [0, 360).
     cube = self._create_cube([0, 90, 180, 270])
     samples = [('longitude', np.arange(-360, 720, 45))]
     result = interpolate.linear(cube, samples, extrapolation_mode='nan')
     normalise_order(result)
     self.assertCMLApproxData(result, ('analysis', 'interpolation',
                                       'linear', 'circular_wrapping',
                                       'positive'))
Пример #35
0
 def test_bounded_coordinate(self):
     # The results should be exactly the same as for the
     # non-bounded case.
     cube = self.simple2d_cube
     cube.coord('dim1').guess_bounds()
     r = iintrp.linear(cube, [('dim1', [4, 5])])
     np.testing.assert_array_equal(r.data, np.array([[ 1.5,  2.5,  3.5], [ 3.,  4.,  5. ]]))
     normalise_order(r)
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_multiple_points.cml'))
Пример #36
0
    def test_circular(self):
        res = iintrp.linear(self.cube,
                                               [('longitude', 359.8)])
        normalise_order(res)
        lon_coord = self.cube.coord('longitude').points
        expected = self.cube.data[..., 0] + \
            ((self.cube.data[..., -1] - self.cube.data[..., 0]) *
             (((360 - 359.8) - lon_coord[0]) /
              ((360 - lon_coord[-1]) - lon_coord[0])))
        self.assertArrayAllClose(res.data, expected, rtol=1.0e-6)

        # check that the values returned by lon 0 & 360 are the same...
        r1 = iintrp.linear(self.cube, [('longitude', 360)])
        r2 = iintrp.linear(self.cube, [('longitude', 0)])
        np.testing.assert_array_equal(r1.data, r2.data)

        self.assertCML(res, ('analysis', 'interpolation', 'linear',
                             'real_circular_2dslice.cml'), checksum=False)
Пример #37
0
    def test_mask_retention(self):
        cube = stock.realistic_4d_w_missing_data()
        interp_cube = linear(cube, [('pressure', [850, 950])])
        self.assertIsInstance(interp_cube.data, np.ma.MaskedArray)

        # this value is masked in the input
        self.assertTrue(cube.data.mask[0, 2, 2, 0])
        # and is still masked in the output
        self.assertTrue(interp_cube.data.mask[0, 1, 2, 0])
Пример #38
0
    def test_extrapolation_mode_different_pts(self):
        # Slice to form (3, 1) shaped cube.
        cube = self.cube[:, 2:3]
        src_points = cube.coord('longitude').points
        new_points_single = src_points + 0.2
        new_points_multiple = [src_points[0],
                               src_points[0] + 0.2,
                               src_points[0] + 0.4]
        new_points_scalar = src_points[0] + 0.2

        # 'nan' mode
        r = iintrp.linear(cube, [('longitude',
                                                     new_points_single)],
                                             extrapolation_mode='nan')
        self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                     'single_pt_to_single_pt_nan'))
        r = iintrp.linear(cube, [('longitude',
                                                     new_points_multiple)],
                                             extrapolation_mode='nan')
        self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                     'single_pt_to_many_nan'))
        r = iintrp.linear(cube, [('longitude',
                                                     new_points_scalar)],
                                             extrapolation_mode='nan')
        self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                     'single_pt_to_scalar_nan'))

        # 'error' mode
        with self.assertRaises(ValueError):
            r = iintrp.linear(cube, [('longitude',
                                                         new_points_single)],
                                                 extrapolation_mode='error')
        with self.assertRaises(ValueError):
            r = iintrp.linear(cube, [('longitude',
                                                         new_points_multiple)],
                                                 extrapolation_mode='error')
        with self.assertRaises(ValueError):
            r = iintrp.linear(cube, [('longitude',
                                                         new_points_scalar)],
                                                 extrapolation_mode='error')
Пример #39
0
    def test_extrapolation_mode_different_pts(self):
        # Slice to form (3, 1) shaped cube.
        cube = self.cube[:, 2:3]
        src_points = cube.coord('longitude').points
        new_points_single = src_points + 0.2
        new_points_multiple = [src_points[0],
                               src_points[0] + 0.2,
                               src_points[0] + 0.4]
        new_points_scalar = src_points[0] + 0.2

        # 'nan' mode
        r = iintrp.linear(cube, [('longitude',
                                                     new_points_single)],
                                             extrapolation_mode='nan')
        self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                     'single_pt_to_single_pt_nan'))
        r = iintrp.linear(cube, [('longitude',
                                                     new_points_multiple)],
                                             extrapolation_mode='nan')
        self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                     'single_pt_to_many_nan'))
        r = iintrp.linear(cube, [('longitude',
                                                     new_points_scalar)],
                                             extrapolation_mode='nan')
        self.assertCMLApproxData(r, ('analysis', 'interpolation', 'linear',
                                     'single_pt_to_scalar_nan'))

        # 'error' mode
        with self.assertRaises(ValueError):
            r = iintrp.linear(cube, [('longitude',
                                                         new_points_single)],
                                                 extrapolation_mode='error')
        with self.assertRaises(ValueError):
            r = iintrp.linear(cube, [('longitude',
                                                         new_points_multiple)],
                                                 extrapolation_mode='error')
        with self.assertRaises(ValueError):
            r = iintrp.linear(cube, [('longitude',
                                                         new_points_scalar)],
                                                 extrapolation_mode='error')
Пример #40
0
 def test_2slices(self):
     r = iintrp.linear(self.cube, [('latitude', 0.0), ('longitude', 0.0)])
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'real_2slices.cml'))
Пример #41
0
 def test_slice(self):
     r = iintrp.linear(self.cube, [('latitude', 0)])
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'real_2dslice.cml'))
Пример #42
0
 def test_points_datatype_casting(self):
     # this test tries to extract a float from an array of type integer. the result should be of type float.
     r = iintrp.linear(self.simple2d_cube_extended, [('shared_x_coord', 7.5)])
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_casting_datatype.cml'))
Пример #43
0
 def test_simple_coord_nan_extrapolation(self):
     r = iintrp.linear( self.simple2d_cube, [('dim2', 2.5)], extrapolation_mode='nan')
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_coord_nan_extrapolation.cml'))
Пример #44
0
 def test_monotonic_decreasing_coord(self):
     c = self.simple2d_cube[::-1]
     r = iintrp.linear(c, [('dim1', 4)])
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_single_point.cml'), checksum=False)
     np.testing.assert_array_equal(r.data, np.array([1.5, 2.5, 3.5], dtype=self.simple2d_cube.data.dtype))
Пример #45
0
 def test_simple_coord_linear_extrapolation_multipoint2(self):
     r = iintrp.linear( self.simple2d_cube, [('dim1', [1, 10])], extrapolation_mode='linear')
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_coord_linear_extrapolation_multipoint2.cml'))
Пример #46
0
 def test_multiple_coord_linear_extrapolation(self):
     r = iintrp.linear(self.simple2d_cube, [('dim2', 9), ('dim1', 1.5)])
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_multiple_coords_extrapolation.cml'))
Пример #47
0
 def test_lots_of_points(self):
     r = iintrp.linear(self.simple2d_cube, [('dim1', np.linspace(3, 9, 20))])
Пример #48
0
 def test_points_datatype_casting(self):
     # this test tries to extract a float from an array of type integer. the result should be of type float.
     r = iintrp.linear(self.simple2d_cube_extended, [('shared_x_coord', 7.5)])
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_casting_datatype.cml'))
Пример #49
0
 def test_slice(self):
     r = iintrp.linear(self.cube, [('latitude', 0)])
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'real_2dslice.cml'))
Пример #50
0
 def test_2slices(self):
     r = iintrp.linear(self.cube, [('latitude', 0.0), ('longitude', 0.0)])
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'real_2slices.cml'))
Пример #51
0
 def test_simple_coord_linear_extrapolation_multipoint2(self):
     r = iintrp.linear( self.simple2d_cube, [('dim1', [1, 10])], extrapolation_mode='linear')
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_coord_linear_extrapolation_multipoint2.cml'))
Пример #52
0
 def test_simple_coord_nan_extrapolation(self):
     r = iintrp.linear( self.simple2d_cube, [('dim2', 2.5)], extrapolation_mode='nan')
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_coord_nan_extrapolation.cml'))
Пример #53
0
 def test_multiple_coord_linear_extrapolation(self):
     r = iintrp.linear(self.simple2d_cube, [('dim2', 9), ('dim1', 1.5)])
     self.assertCML(r, ('analysis', 'interpolation', 'linear', 'simple_multiple_coords_extrapolation.cml'))
Пример #54
0
 def test_lots_of_points(self):
     r = iintrp.linear(self.simple2d_cube, [('dim1', np.linspace(3, 9, 20))])
Пример #55
0
 def test_single_extrapolation(self):
     # Interpolation on the 1d coordinate with extrapolation.
     interp_cube = linear(self.cube, {'wibble': np.float32(1.5)})
     expected = ('experimental', 'analysis', 'interpolate',
                 'linear_nd_with_extrapolation.cml')
     self.assertCMLApproxData(interp_cube, expected)
Пример #56
0
 def test_single_extrapolation(self):
     # Interpolation on the 1d coordinate with extrapolation.
     interp_cube = linear(self.cube, {'wibble': np.float32(1.5)})
     expected = ('experimental', 'analysis', 'interpolate',
                 'linear_nd_with_extrapolation.cml')
     self.assertCMLApproxData(interp_cube, expected)