def _inject_dives_ui(dives, title, info, temp, avg_depth,
legend, labels):
"""
Inject ``kz.dives.ui`` data frame into R global space.
The data frame has the following columns
info
Dive information string with dive duration, maximum depth and
dive temperature.
title
Dive title.
avg_depth
Dive average depth label.
label
Dive label put on legend.
See ``plot`` for parameters description.
"""
labels = [] if labels is None else labels
# dive title formatter
tfmt = lambda d, l: '{}'.format(d.datetime)
# dive info formatter
_ifmt = '{:.1f}m \u00b7 {}min \u00b7 {:.1f}\u00b0C'.format
ifmt = lambda d, l: _ifmt(d.depth, min2str(d.duration / 60.0), K2C(d.temp))
# average depth formatter
dfmt = lambda d, l: None if d.avg_depth is None \
else '{:.1f}m'.format(d.avg_depth)
# label formatter
lfmt = lambda d, l: l if l else tfmt(d)
cols = []
fmts = []
if title:
cols.append('title')
fmts.append(tfmt)
if info:
cols.append('info')
fmts.append(ifmt)
if avg_depth:
cols.append('avg_depth')
fmts.append(dfmt)
if legend:
cols.append('label')
fmts.append(lfmt)
vt = (ro.StrVector, ) * len(cols)
data = (tuple(f(d, l) for f in fmts) for d, l in lzip(dives, labels))
ui_df = kr.df(cols, vt, data)
ro.globalenv['kz.dives.ui'] = ui_df
def missing_number (array, upper_bound):
from itertools import izip_longest as lzip
possible_numbers = range (0, upper_bound+1)
missing_num = 0
for elem, poss_elem in lzip (array, possible_numbers, fillvalue = 0):
missing_num += poss_elem
missing_num -= elem
return missing_num
def test_dsl(formula, seed, expected):
from dice.parser import parse
# logging.basicConfig(level=logging.DEBUG)
values = parse(formula, seed=seed)
if isinstance(expected, (list, tuple)):
for value, expect in lzip(values, expected):
assert value == expect
else:
found = next(values)
assert found == expected
def test_iters_numpy(shape, chunkshape1, blockshape1, chunkshape2, blockshape2, dtype):
dtype = np.dtype(dtype)
size = int(np.prod(shape))
nparray = np.ones(size, dtype=dtype).reshape(shape)
a = cat.asarray(nparray, chunkshape=chunkshape1, blockshape=blockshape1) # creates a NPArray
b = cat.empty(shape, dtype.itemsize, str(dtype), chunkshape=chunkshape2, blockshape=blockshape2)
itershape = chunkshape2 if chunkshape2 is not None else b.shape
for (block_r, info_r), (block_w, info_w) in lzip(a.iter_read(itershape), b.iter_write()):
block_w[:] = bytearray(np.asarray(block_r))
nparray2 = np.asarray(b.copy())
np.testing.assert_equal(nparray, nparray2)
def get_position(node):
ret = [(-HALF_NODE_WIDTH, HALF_NODE_WIDTH)]
if node.char:
return ret
left = get_position(node.left)
right = get_position(node.right)
width = reduce(lambda w, lr:
max(w, lr[0][1] -lr[1][0] + NODE_SPACE),
zip(left, right), 0)
half = width / 2.0
node.left.offset = -half
node.right.offset = half
for l, r in lzip(left, right):
if l is None:
ret.append((r[0] + half, r[1] + half))
elif r is None:
ret.append((l[0] - half, l[1] - half))
else:
ret.append((l[0] - half, r[1] + half))
return ret
def find_dive_gas_nodes(files, nodes=None):
"""
Find gas nodes referenced by dives in UDDF files using optional node
ranges as search parameter.
The collection of gas nodes is returned.
:Parameters:
files
Collection of UDDF files.
nodes
Numeric ranges of nodes, `None` if all nodes.
.. seealso:: :py:func:`parse_range`
"""
nodes = [] if nodes is None else nodes
data = (ku.find(f, ku.XP_FIND_DIVE_GASES, nodes=q) \
for q, f in lzip(nodes, files))
nodes_by_id = ((n.get('id'), n) for n in ichain(data))
return dict(nodes_by_id).values()
def find_dive_nodes(files, nodes=None, dives=None):
"""
Find dive nodes in UDDF files using optional numeric ranges or total
dive number as search parameters.
The collection of dive nodes is returned.
:Parameters:
files
Collection of UDDF files.
nodes
Numeric ranges of nodes, `None` if all nodes.
dives
Numeric range of total dive number, `None` if any dive.
.. seealso:: :py:func:`parse_range`
.. seealso:: :py:func:`find_dives`
"""
nodes = [] if nodes is None else nodes
data = (ku.find(f, ku.XP_FIND_DIVES, nodes=q, dives=dives) \
for q, f in lzip(nodes, files))
return ichain(data)
def test_iters(shape, chunkshape1, blockshape1, chunkshape2, blockshape2,
dtype):
size = int(np.prod(shape))
nparray = np.ones(size, dtype=dtype).reshape(shape)
a = cat.from_buffer(bytes(nparray),
nparray.shape,
itemsize=nparray.itemsize,
chunkshape=chunkshape1,
blockshape=blockshape1)
itemsize = np.dtype(dtype).itemsize
b = cat.empty(shape,
chunkshape=chunkshape2,
blockshape=blockshape2,
itemsize=itemsize)
itershape = chunkshape2 if chunkshape2 is not None else b.shape
for (block_r, info_r), (block_w, info_w) in lzip(a.iter_read(itershape),
b.iter_write()):
block_w[:] = block_r
nparray2 = b.to_numpy(dtype)
np.testing.assert_equal(nparray, nparray2)
def __add__(self, other): # f + g
other = self.convert(other)
return IntPolynomial(x + y for x, y in lzip(self, other, fillvalue=0))
def __sub__(self, g): # f - g
g = self.valid(g)
return IntPolynomial(x - y for x, y in lzip(self, g, fillvalue=0))
def __add__(self, g): # f + g
"""
Addition with another polynomial or an integer.
"""
g = self.valid(g)
return IntPolynomial(x + y for x, y in lzip(self, g, fillvalue=0))
def __sub__(self, other): # f - g
other = self.convert(other)
return self.__class__(x - y for x, y in lzip(self, other, fillvalue=0))
# Create a numpy array
nparray = np.arange(int(np.prod(shape)), dtype=dtype).reshape(shape)
# Create a caterva array from a numpy array
a = cat.asarray(nparray)
# Create an empty caterva array (on disk)
b = cat.empty(shape,
itemsize,
dtype=str(dtype),
chunkshape=chunkshape,
blockshape=blockshape,
filename=filename)
# Fill an empty caterva array using a block iterator
for block, info in b.iter_write():
block[:] = bytes(nparray[info.slice])
# Load file
c = cat.from_file(filename)
# Assert both caterva arrays
itershape = (5, 5)
for (block1, info1), (block2, info2) in lzip(a.iter_read(itershape),
c.iter_read(itershape)):
np.testing.assert_equal(np.asarray(block1), np.asarray(block2))
# Remove file on disk
os.remove(filename)
def __add__(self, g):
"""Add a polynomial or an integer.
"""
g = self.valid(g)
return IntPolynomial(x + y for x, y in lzip(self, g, fillvalue=0))
def __sub__(self, other): # f - g
other = self.convert(other)
return IntPolynomial(x - y for x, y in lzip(self, other, fillvalue=0))
assert (b.has_metalayer("numpy") is True)
assert (b.get_metalayer("numpy") == {
b"dtype": bytes(str(np.dtype(dtype)), "utf-8")
})
assert (b.has_metalayer("test") is True)
assert (b.get_metalayer("test") == {b"lorem": 1234})
assert (b.update_metalayer("test", {b"lorem": 4321}) >= 0)
assert (b.get_metalayer("test") == {b"lorem": 4321})
# Fill an empty caterva array using a block iterator
for block, info in b.iter_write():
block[:] = bytes(nparray[info.slice])
# Assert that both caterva arrays are equal
itershape = (5, 5)
for (block1, info1), (block2, info2) in lzip(a.iter_read(blockshape),
b.iter_read(blockshape)):
np.testing.assert_equal(np.asarray(block1), np.asarray(block2))
assert (b.update_usermeta({
b"author": b"cat4py example",
b"description": b"lorem ipsum"
}) >= 0)
assert (b.get_usermeta() == {
b"author": b"cat4py example",
b"description": b"lorem ipsum"
})
assert (b.update_usermeta({b"author": b"cat4py example"}) >= 0)
assert (b.get_usermeta() == {b"author": b"cat4py example"})
# Remove file on disk
def __add__(self, other): # f + g
other = self.convert(other)
return self.__class__(x + y for x, y in lzip(self, other, fillvalue=0))
