def test_convenience():

    arr = YTArray([1, 2, 3], 'cm')

    assert_equal(arr.unit_quantity, YTQuantity(1, 'cm'))
    assert_equal(arr.uq, YTQuantity(1, 'cm'))
    assert_isinstance(arr.unit_quantity, YTQuantity)
    assert_isinstance(arr.uq, YTQuantity)

    assert_array_equal(arr.unit_array, YTArray(np.ones_like(arr), 'cm'))
    assert_array_equal(arr.ua, YTArray(np.ones_like(arr), 'cm'))
    assert_isinstance(arr.unit_array, YTArray)
    assert_isinstance(arr.ua, YTArray)

    assert_array_equal(arr.ndview, arr.view(np.ndarray))
    assert_array_equal(arr.d, arr.view(np.ndarray))
    assert_true(arr.ndview.base is arr.base)
    assert_true(arr.d.base is arr.base)

    assert_array_equal(arr.value, np.array(arr))
    assert_array_equal(arr.v, np.array(arr))
def test_convenience():

    arr = YTArray([1, 2, 3], 'cm')

    yield assert_equal, arr.unit_quantity, YTQuantity(1, 'cm')
    yield assert_equal, arr.uq, YTQuantity(1, 'cm')
    yield assert_isinstance, arr.unit_quantity, YTQuantity
    yield assert_isinstance, arr.uq, YTQuantity

    yield assert_array_equal, arr.unit_array, YTArray(np.ones_like(arr), 'cm')
    yield assert_array_equal, arr.ua, YTArray(np.ones_like(arr), 'cm')
    yield assert_isinstance, arr.unit_array, YTArray
    yield assert_isinstance, arr.ua, YTArray

    yield assert_array_equal, arr.ndview, arr.view(np.ndarray)
    yield assert_array_equal, arr.d, arr.view(np.ndarray)
    yield assert_true, arr.ndview.base is arr.base
    yield assert_true, arr.d.base is arr.base

    yield assert_array_equal, arr.value, np.array(arr)
    yield assert_array_equal, arr.v, np.array(arr)
 def recv_array(self, source, tag = 0):
     metadata = self.comm.recv(source=source, tag=tag)
     dt, ne = metadata[:2]
     if ne is None and dt is None:
         return self.comm.recv(source=source, tag=tag)
     arr = np.empty(ne, dtype=dt)
     if len(metadata) == 4:
         registry = UnitRegistry(lut=metadata[3], add_default_symbols=False)
         arr = YTArray(arr, metadata[2], registry=registry)
     tmp = arr.view(self.__tocast)
     self.comm.Recv([tmp, MPI.CHAR], source=source, tag=tag)
     return arr
 def recv_array(self, source, tag=0):
     metadata = self.comm.recv(source=source, tag=tag)
     dt, ne = metadata[:2]
     if ne is None and dt is None:
         return self.comm.recv(source=source, tag=tag)
     arr = np.empty(ne, dtype=dt)
     if len(metadata) == 4:
         registry = UnitRegistry(lut=metadata[3], add_default_symbols=False)
         arr = YTArray(arr, metadata[2], registry=registry)
     tmp = arr.view(self.__tocast)
     self.comm.Recv([tmp, MPI.CHAR], source=source, tag=tag)
     return arr
 def alltoallv_array(self, send, total_size, offsets, sizes):
     if len(send.shape) > 1:
         recv = []
         for i in range(send.shape[0]):
             recv.append(self.alltoallv_array(send[i,:].copy(),
                                              total_size, offsets, sizes))
         recv = np.array(recv)
         return recv
     offset = offsets[self.comm.rank]
     tmp_send = send.view(self.__tocast)
     recv = np.empty(total_size, dtype=send.dtype)
     if isinstance(send, YTArray):
         # We assume send.units is consitent with the units
         # on the receiving end.
         recv = YTArray(recv, send.units)
     recv[offset:offset+send.size] = send[:]
     dtr = send.dtype.itemsize / tmp_send.dtype.itemsize # > 1
     roff = [off * dtr for off in offsets]
     rsize = [siz * dtr for siz in sizes]
     tmp_recv = recv.view(self.__tocast)
     self.comm.Allgatherv((tmp_send, tmp_send.size, MPI.CHAR),
                               (tmp_recv, (rsize, roff), MPI.CHAR))
     return recv
 def alltoallv_array(self, send, total_size, offsets, sizes):
     if len(send.shape) > 1:
         recv = []
         for i in range(send.shape[0]):
             recv.append(self.alltoallv_array(send[i,:].copy(),
                                              total_size, offsets, sizes))
         recv = np.array(recv)
         return recv
     offset = offsets[self.comm.rank]
     tmp_send = send.view(self.__tocast)
     recv = np.empty(total_size, dtype=send.dtype)
     if isinstance(send, YTArray):
         # We assume send.units is consitent with the units
         # on the receiving end.
         recv = YTArray(recv, send.units)
     recv[offset:offset+send.size] = send[:]
     dtr = send.dtype.itemsize / tmp_send.dtype.itemsize # > 1
     roff = [off * dtr for off in offsets]
     rsize = [siz * dtr for siz in sizes]
     tmp_recv = recv.view(self.__tocast)
     self.comm.Allgatherv((tmp_send, tmp_send.size, MPI.CHAR),
                               (tmp_recv, (rsize, roff), MPI.CHAR))
     return recv