def _assert_compatible(cube, other): """ Checks to see if cube.data and another array can be broadcast to the same shape using ``numpy.broadcast_arrays``. """ # This code previously returned broadcasted versions of the cube # data and the other array. As numpy.broadcast_arrays does not work # with masked arrays (it returns them as ndarrays) operations # involving masked arrays would be broken. try: if not isinstance(other, biggus.Array): data_view, other_view = BA.broadcast_arrays(cube._my_data, np.asarray(other)) else: data_view, other_view = BA.broadcast_arrays(cube._my_data, other) except ValueError as err: # re-raise raise ValueError("The array was not broadcastable to the cube's data " "shape. The error message from numpy when " "broadcasting:\n{}\nThe cube's shape was {} and the " "array's shape was {}".format(err, cube.shape, other.shape)) if cube.shape != data_view.shape: raise ValueError("The array operation would increase the " "dimensionality of the cube. The new cube's data " "would have had to become: {}".format( data_view.shape))
def _assert_compatible(cube, other): """ Checks to see if cube.data and another array can be broadcast to the same shape using ``numpy.broadcast_arrays``. """ # This code previously returned broadcasted versions of the cube # data and the other array. As numpy.broadcast_arrays does not work # with masked arrays (it returns them as ndarrays) operations # involving masked arrays would be broken. try: if not isinstance(other, biggus.Array): data_view, other_view = BA.broadcast_arrays( cube._my_data, np.asarray(other)) else: data_view, other_view = BA.broadcast_arrays(cube._my_data, other) except ValueError as err: # re-raise raise ValueError("The array was not broadcastable to the cube's data " "shape. The error message from numpy when " "broadcasting:\n{}\nThe cube's shape was {} and the " "array's shape was {}".format(err, cube.shape, other.shape)) if cube.shape != data_view.shape: raise ValueError("The array operation would increase the " "dimensionality of the cube. The new cube's data " "would have had to become: {}".format( data_view.shape))
def _binary_op_common(operation_function, operation_name, cube, other, new_unit, dim=None, in_place=False): """ Function which shares common code between binary operations. operation_function - function which does the operation (e.g. numpy.divide) operation_name - the public name of the operation (e.g. 'divide') cube - the cube whose data is used as the first argument to `operation_function` other - the cube, coord, ndarray or number whose data is used as the second argument new_unit - unit for the resulting quantity dim - dimension along which to apply `other` if it's a coordinate that is not found in `cube` in_place - whether or not to apply the operation in place to `cube` and `cube.data` """ _assert_is_cube(cube) if isinstance(other, iris.coords.Coord): other = _broadcast_cube_coord_data(cube, other, operation_name, dim) elif isinstance(other, iris.cube.Cube): try: BA.broadcast_arrays(cube._my_data, other._my_data) except ValueError: other = iris.util.as_compatible_shape(other, cube)._my_data else: other = other._my_data # don't worry about checking for other data types (such as scalars or # np.ndarrays) because _assert_compatible validates that they are broadcast # compatible with cube.data _assert_compatible(cube, other) def unary_func(x): ret = operation_function(x, other) if ret is NotImplemented: # explicitly raise the TypeError, so it gets raised even if, for # example, `iris.analysis.maths.multiply(cube, other)` is called # directly instead of `cube * other` raise TypeError('cannot %s %r and %r objects' % (operation_function.__name__, type(x).__name__, type(other).__name__)) return ret return _math_op_common(cube, unary_func, new_unit, in_place)
def test_lh_broadcast(self): a = np.empty([2]) b = np.empty([1, 2]) a1, b1 = BroadcastArray.broadcast_arrays(a, b) self.assertIs(b1, b) self.assertIsInstance(a1, BroadcastArray) self.assertEqual(a1.shape, (1, 2))