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_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_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_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_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_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_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_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_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_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_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_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_FindUsedOneDimensionalVerticalToExtend_emptyResult(self):
"""
'ka' is a one dimensional variable but not y dimension.
Only variables with 'y' dimension must be extended.
"""
expression = 'asd * ka'
biggest_variable = R._get_biggest_variable(self.dic, expression)
dims = biggest_variable.dims
one_d_vars = R._find_used_one_dimensional_variables_to_extend(self.dic, dims, expression)
self.assertEqual(list(), one_d_vars)
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_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_FindUsedOneDimensionalVerticalToExtend_oneResult(self):
"""
'ody' is a one dimensional variable with dimension 'y'
"""
expression = 'asd * ody + ka'
biggest_variable = R._get_biggest_variable(self.dic, expression)
dims = biggest_variable.dims
one_d_vars = R._find_used_one_dimensional_variables_to_extend(self.dic, dims, expression)
self.assertEqual(1, len(one_d_vars))
self.assertTrue('ody' in one_d_vars)
variable = self.dic['ody']
self.assertEqual(('y',), variable.dims)
self.assertEqual(17, variable.data[0])
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_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_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_FindUsedOneDimensionalVerticalToExtend_twoResults(self):
"""
'ody' and 'woody' are a one dimensional variables with dimension 'y'
"""
expression = 'asd * (ody - woody) + ka'
biggest_variable = R._get_biggest_variable(self.dic, expression)
dims = biggest_variable.dims
one_d_vars = R._find_used_one_dimensional_variables_to_extend(self.dic, dims, expression)
self.assertEqual(2, len(one_d_vars))
self.assertTrue('ody' in one_d_vars)
self.assertTrue('woody' in one_d_vars)
var_o = self.dic['ody']
self.assertEqual(('y',), var_o.dims)
self.assertEqual(17, var_o.data[0])
var_w = self.dic['woody']
self.assertEqual(('y',), var_w.dims)
self.assertEqual(18, var_w.data[0])
def test_GetKeysSorted_LongestFirst(self):
dictionary = {"a": 1, "a2": 2, "b": 3, "bb3": 4, "c2": 5}
sorted_keys = R._get_keys_sorted__longest_first(dictionary)
self.assertEqual(0, sorted_keys.index('bb3'))
self.assertTrue(sorted_keys.index('c2') == 1 or sorted_keys.index('c2') == 2)
self.assertTrue(sorted_keys.index('a2') == 1 or sorted_keys.index('a2') == 2)
self.assertTrue(sorted_keys.index('a') == 3 or sorted_keys.index('a') == 4)
self.assertTrue(sorted_keys.index('b') == 3 or sorted_keys.index('b') == 4)
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_GetBiggestDimension(self):
expression = '(asd)*[lsmf + bottle] - ka'
biggest_variable = R._get_biggest_variable(self.dic, expression)
self.assertEqual(("z", "y", "x"), biggest_variable.dims)
expression = '[lsmf + bottle] - ka'
biggest_variable = R._get_biggest_variable(self.dic, expression)
self.assertEqual(("y", "x"), biggest_variable.dims)
expression = 'lsmf + ka'
biggest_variable = R._get_biggest_variable(self.dic, expression)
self.assertEqual(("y", "x"), biggest_variable.dims)
expression = 'bottle - ka'
biggest_variable = R._get_biggest_variable(self.dic, expression)
self.assertEqual(("y", "x"), biggest_variable.dims)
expression = 'ka * 4'
biggest_variable = R._get_biggest_variable(self.dic, expression)
self.assertEqual(("x",), biggest_variable.dims)
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_)
