def test_absolute_value(self):
expression = 'abs(a)'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = xr.Variable(('x',), [-2.2, -3.4, 4.5 * -1])
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(('x',), [2.2, 3.4, 4.5])
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_square_root(self):
expression = 'sqrt(a)'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = xr.Variable(('x',), [4, 9, math.pow(12, 2)])
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(('x',), [2, 3, 12])
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_replace_pi(self):
expression = 'a*pi'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = xr.Variable(['x'], np.asarray([1, 2, 3, 4, 0.01]))
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['x'], [3.14159265359, 6.28318530718, 9.42477796077, 12.5663706144, 0.0314159265359])
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_number_constants_with_scientific_notation(self):
expression = 'a + 257e-3'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = xr.Variable(['x'], np.asarray([1, 2, 3, 4, 0.01]))
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['x'], [1.257, 2.257, 3.257, 4.257, 0.267])
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_not_with_vertical_1D(self):
expression = '~ a' # the meaning is "not a"
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = get_vertical_one_dim_bool_variable()
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['y'], np.asarray([t, f, t]))
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_inverse_tangent(self):
expression = 'arctan(tan(a))'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = xr.Variable(('x',), [1, 0.5, 0])
R._load_virtual_variable(ds, 'v')
expected = ds['a']
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_extend_vertical_1D_variable_to_2D(self):
vertical_variable = xr.Variable('y', [5, 6, 7])
reference_variable = xr.Variable(('z', 'y', 'x'), [[[1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6], ], [[4, 5, 6, 7], [5, 6, 7, 8], [6, 7, 8, 9], ], ])
extended = R._extend_1d_vertical_to_2d(vertical_variable, reference_variable)
self.assertEqual((3, 4), extended.shape)
self.assertEqual(('y', 'x'), extended.dims)
expected = np.asarray([[5, 5, 5, 5], [6, 6, 6, 6], [7, 7, 7, 7], ])
ftu.assert_array_equals_with_index_error_message(self, expected, extended.data)
def test_modulo(self):
expression = 'a % 7'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = get_two_dim_int_variable()
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['y', 'x'], np.asarray(
[[3, 6, 2, 5], [6, 2, 5, 1], [2, 5, 1, 4]]))
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_power(self):
expression = 'a ** 2'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = get_two_dim_int_variable()
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['y', 'x'], np.asarray(
[[100, 400, 900, 1600], [169, 529, 1089, 1849], [256, 676, 1296, 2116]]))
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_unary_negation(self):
expression = '- a'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = get_two_dim_int_variable()
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['y', 'x'], np.asarray(
[[-10, -20, -30, -40], [-13, -23, -33, -43], [-16, -26, -36, -46]]))
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_or_with_vertical_1D(self):
expression = 'a | b' # the meaning is "a or b"
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = get_vertical_one_dim_bool_variable()
ds['b'] = get_two_dim_bool_variable()
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['y', 'x'], np.asarray([[t, f, f, t], [t, t, t, t], [t, f, f, f]]))
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_addition(self):
expression = 'a + b'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = get_two_dim_int_variable()
ds['b'] = get_vertical_one_dim_int_variable()
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['y', 'x'], np.asarray(
[[210, 220, 230, 240], [313, 323, 333, 343], [416, 426, 436, 446]]))
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_natural_logarithm_1_plus_x(self):
expression = 'log1p(a)'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = xr.Variable(('x',), [2.2, 3.4, 4.5])
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(('x',), [math.log1p(2.2),
math.log1p(3.4),
math.log1p(4.5), ])
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_inverse_hyperbolic_tangent(self):
expression = 'arctanh(a)'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = xr.Variable(('x',), [0.2, 0.4, 0.5])
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(('x',), [math.atanh(0.2),
math.atanh(0.4),
math.atanh(0.5), ])
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_inverse_hyperbolic_cosine(self):
expression = 'arccosh(a)'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = xr.Variable(('x',), [2, 4, 5])
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(('x',), [math.acosh(2),
math.acosh(4),
math.acosh(5), ])
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_multiplication(self):
expression = 'a * b'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = get_two_dim_int_variable()
ds['b'] = get_vertical_one_dim_int_variable()
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['y', 'x'], np.asarray(
[[2000, 4000, 6000, 8000], [3900, 6900, 9900, 12900], [6400, 10400, 14400, 18400]]))
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_exponential_minus_one(self):
expression = 'expm1(a)'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = xr.Variable(('x',), [2.2, 3.4, 4.5])
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(('x',), [math.expm1(2.2),
math.expm1(3.4),
math.expm1(4.5), ])
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_subtraction(self):
expression = 'b - a'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = get_two_dim_int_variable()
ds['b'] = get_vertical_one_dim_int_variable()
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['y', 'x'], np.asarray(
[[190, 180, 170, 160], [287, 277, 267, 257], [384, 374, 364, 354]]))
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_equal(self):
expression = 'a == 5'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = get_three_dim_int_variable()
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['z', 'y', 'x'], np.asarray(
[[[f, f, f, f], [f, f, f, t], [f, f, t, f]],
[[f, t, f, f], [t, f, f, f], [f, f, f, f]]]))
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_dont_replace_pi_if_it_part_of_a_word(self):
expression = 'lpit + pit + lpi'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['lpit'] = xr.Variable(['x'], np.asarray([1, 2, 3, 4, 0.01]))
ds['pit'] = xr.Variable(['x'], np.asarray([1, 2, 3, 4, 0.01]))
ds['lpi'] = xr.Variable(['x'], np.asarray([1, 2, 3, 4, 0.01]))
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['x'], [3, 6, 9, 12, 0.03])
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_arctan2(self):
expression = 'arctan2(a, b)'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = xr.Variable(('x',), [0.2, 0.4, 0.5])
ds['b'] = xr.Variable(('x',), [0.8, 0.7, 0.6])
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(('x',), [math.atan2(0.2, 0.8),
math.atan2(0.4, 0.7),
math.atan2(0.5, 0.6), ])
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_tangent(self):
expression = 'tan(a)'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = get_one_dim_radians()
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['x'], np.asarray(
[0,
1,
6.95515277177,
-1,
1,
6.95515277177]))
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_cosine(self):
expression = 'cos(a)'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = get_one_dim_radians()
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['x'], np.asarray(
[1,
0.70710678,
0.142314838273,
-0.70710678,
-0.70710678,
-0.142314838273]))
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_sinus(self):
expression = 'sin(a)'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = get_one_dim_radians()
R._load_virtual_variable(ds, 'v')
expected = xr.Variable(['x'], np.asarray(
[0,
0.70710678,
0.989821441881,
0.70710678,
-0.70710678,
-0.989821441881]))
tu.assert_array_equals_with_index_error_message(self, expected, ds['v'])
def test_adding_1_three_dimensional_variable_and_1_vertical_one_dimensional_variable(self):
ds = xr.Dataset()
ds['a'] = create_three_dim_variable()
ds['b'] = create_vertical_one_dim_variable()
v_var = create_virtual_variable("a + b")
ds["v_var"] = v_var
self.fcdr_reader._load_virtual_variable(ds, 'v_var')
self.assertTrue('v_var' in ds)
virtual_loaded = ds['v_var']
self.assertEqual(('z', 'y', 'x'), virtual_loaded.dims)
self.assertEqual((4, 2, 3), virtual_loaded.shape)
self.assertEqual(v_var.attrs, virtual_loaded.attrs)
expected = np.asarray([[[6, 7, 8], [7.1, 8.1, 9.1]], [[16, 17, 18], [17.1, 18.1, 19.1]], [[26, 27, 28], [27.1, 28.1, 29.1]], [[36, 37, 38], [37.1, 38.1, 39.1]]])
actual = virtual_loaded.values
self.assertEqual(type(expected), type(actual))
tu.assert_array_equals_with_index_error_message(self, expected, actual)
def test_adding_1_three_dimensional_variable_and_1_one_dimensional_variable(self):
ds = xr.Dataset()
ds['a'] = create_three_dim_variable()
ds['b'] = create_one_dim_variable()
v_var = create_virtual_variable("a + b")
ds["v_var"] = v_var
self.fcdr_reader._load_virtual_variable(ds, 'v_var')
self.assertTrue('v_var' in ds)
virtual_loaded = ds['v_var']
self.assertEqual(('z', 'y', 'x'), virtual_loaded.dims)
self.assertEqual((4, 2, 3), virtual_loaded.shape)
self.assertEqual(v_var.attrs, virtual_loaded.attrs)
expected = np.asarray([[[2.3, 4.3, 6.3], [2.4, 4.4, 6.4]], [[12.3, 14.3, 16.3], [12.4, 14.4, 16.4]], [[22.3, 24.3, 26.3], [22.4, 24.4, 26.4]], [[32.3, 34.3, 36.3], [32.4, 34.4, 36.4]]])
actual = virtual_loaded.values
self.assertEqual(type(expected), type(actual))
tu.assert_array_equals_with_index_error_message(self, expected, actual)
def test_adding_1_three_dimensional_variable_and_1_two_dimensional_variable(self):
ds = xr.Dataset()
ds['a'] = create_three_dim_variable()
ds['b'] = create_two_dim_variable()
v_var = create_virtual_variable("a + b")
ds["v_var"] = v_var
self.fcdr_reader._load_virtual_variable(ds, 'v_var')
self.assertTrue('v_var' in ds)
virtual_loaded = ds['v_var']
self.assertEqual(('z', 'y', 'x'), virtual_loaded.dims)
self.assertEqual((4, 2, 3), virtual_loaded.shape)
self.assertEqual(v_var.attrs, virtual_loaded.attrs)
expected = np.asarray([[[2, 4, 6], [5.1, 7.1, 9.1]], [[12, 14, 16], [15.1, 17.1, 19.1]], [[22, 24, 26], [25.1, 27.1, 29.1]], [[32, 34, 36], [35.1, 37.1, 39.1]]])
actual = virtual_loaded.values
self.assertEqual(type(expected), type(actual))
tu.assert_array_equals_with_index_error_message(self, expected, actual)
def test_adding_2_three_dimensional_variables(self):
ds = xr.Dataset()
ds['a'] = create_three_dim_variable()
ds['b'] = create_three_dim_variable()
v_var = create_virtual_variable("a + b")
ds["v_var"] = v_var
self.fcdr_reader._load_virtual_variable(ds, 'v_var')
self.assertTrue('v_var' in ds)
virtual_loaded = ds['v_var']
self.assertEqual(('z', 'y', 'x'), virtual_loaded.dims)
self.assertEqual((4, 2, 3), virtual_loaded.shape)
self.assertEqual(v_var.attrs, virtual_loaded.attrs)
expected = np.asarray([[[2, 4, 6], [2.2, 4.2, 6.2]], [[22, 24, 26], [22.2, 24.2, 26.2]], [[42, 44, 46], [42.2, 44.2, 46.2]], [[62, 64, 66], [62.2, 64.2, 66.2]]])
actual = ds['v_var'].values
self.assertEqual(type(expected), type(actual))
tu.assert_array_equals_with_index_error_message(self, expected, actual)
def test_multiplying_1_three_dimensional_variable_and_1_scalar_variable(self):
ds = xr.Dataset()
ds['a'] = create_three_dim_variable()
ds['b'] = create_scalar_variable(2.7)
v_var = create_virtual_variable("a * b")
ds["v_var"] = v_var
self.fcdr_reader._load_virtual_variable(ds, 'v_var')
self.assertTrue('v_var' in ds)
virtual_loaded = ds['v_var']
self.assertEqual(('z', 'y', 'x'), virtual_loaded.dims)
self.assertEqual((4, 2, 3), virtual_loaded.shape)
self.assertEqual(v_var.attrs, virtual_loaded.attrs)
expected = np.asarray(
[[[2.7, 5.4, 8.1], [2.97, 5.67, 8.37]], [[29.7, 32.4, 35.1], [29.97, 32.67, 35.37]], [[56.7, 59.4, 62.1], [56.97, 59.67, 62.37]], [[83.7, 86.4, 89.1], [83.97, 86.67, 89.37]]])
actual = virtual_loaded.values
self.assertEqual(type(expected), type(actual))
tu.assert_array_equals_with_index_error_message(self, expected, actual)
def test_division(self):
expression = 'b / a'
ds = xr.Dataset()
ds['v'] = create_virtual_variable(expression)
ds['a'] = get_two_dim_int_variable()
ds['b'] = get_vertical_one_dim_int_variable()
R._load_virtual_variable(ds, 'v')
loaded_ = ds['v']
# if two arrays of type integer are divided, the result data type can be integer or float
# the expected preparation depends on returned datatype
if np.issubdtype(loaded_.dtype, np.integer):
expected = xr.Variable(['y', 'x'], np.asarray(
[[20, 10, 6, 5],
[23, 13, 9, 6],
[25, 15, 11, 8]]))
else:
expected = xr.Variable(['y', 'x'], np.asarray(
[[20, 10, 6.666666666666667, 5],
[23.076923076923077, 13.043478260869565, 9.090909090909092, 6.976744186046512],
[25, 15.384615384615385, 11.11111111111111, 8.695652173913043]]))
tu.assert_array_equals_with_index_error_message(self, expected, loaded_)
