def test_search_by_index(builder):
error = np.arange(9, dtype=float).reshape(3, 3)
error[-1] = 7
iarr = RawBinary.map(FloatArray.from_numpy(error))
seq = Linear.flatten(0, iarr)
space = builder.build_informationspace(seq)
assert isinstance(space, IS)
def transpose(obj, *order):
if isinstance(order[0], tuple):
order = order[0]
if isinstance(obj, np.ndarray):
newobj = transposeND(obj, order)
elif isinstance(obj, xr.DataArray):
newobj = transposeDA(obj, order)
elif isinstance(obj, FloatArray):
tmp = transposeND(obj.array, order)
newobj = FloatArray(tmp)
else:
raise TypeError("Can't understand datatype of obj.")
return newobj
def subset(obj, size, error=.005):
if isinstance(obj, np.ndarray):
subs = SubsetSlices(obj.shape, size, error)
result = obj[subs]
elif isinstance(obj, xr.DataArray):
subs = SubsetSlices(obj.values.shape, size, error)
slices = {x: y for x, y in zip(obj.dims, subs)}
result = obj.isel(**slices)
elif isinstance(obj, FloatArray):
subs = SubsetSlices(obj.array.shape, size, error)
result = FloatArray(obj.array[subs])
else:
raise TypeError("Can't understand type.")
return result
def test_floatarray_with_other_object(value):
"""Comparison with arbitary types."""
with pytest.raises(TypeError) as err:
_ = FloatArray(ARR) == value
assert "Comparison failed" in str(err)
def test_floatarray_with_npndarray():
"""Comparison with related values."""
assert FloatArray(ARR) == ARR
def test_equal_floatarray():
"""Comparison with itself."""
assert FloatArray(ARR) == FloatArray(ARR)
def test_value_error(value):
"""Wrong input types."""
with pytest.raises(TypeError) as err:
FloatArray(value)
assert "Expected np.nd" in str(err)
def test_raise_error(form):
"""Wrong np.dtypes of array."""
with pytest.raises(TypeError) as err:
FloatArray(ARR.astype(form))
assert "Expected np.nd" in str(err)
def test_importtype():
""""Correct initialisation."""
assert isinstance(FloatArray(ARR), FloatArray)
# coding: utf-8
"""Testing mapper functions."""
from pasc.modifier import mapper
from pasc.objects.floatarray import FloatArray
from pasc.objects.integerarray import IntegerArray
import numpy as np
import pytest
MAPPER = [
mapper.Lindstrom,
mapper.RawBinary,
]
INPUTGROUP_VALID = [
FloatArray(np.arange(24, dtype=np.float32)),
]
INPUTGROUP_INVALID = [
IntegerArray(np.arange(24, dtype=np.int32)),
]
@pytest.mark.parametrize('mapmod', MAPPER)
@pytest.mark.parametrize('inputgroup', INPUTGROUP_VALID)
def test_map_function_output(inputgroup, mapmod):
"""Result of Mapper is an IntegerArray using map method."""
mapfunc = mapmod.map(inputgroup)
assert isinstance(mapfunc, IntegerArray)
name = "Block"
@staticmethod
def flatten(startnode, integerarray, weights=None):
default_weights = ()
if not weights:
weights = default_weights
startnode, integerarray = _check_input(startnode, integerarray)
shape = integerarray.array.shape
_, seq = bfs.BFSBlos(shape=shape, startidx=int(startnode)-1, weights=weights)
data = np.array([integerarray.array.flat[x] for x in seq])
return IndexSequence(list(seq), shape, data)
if __name__ == '__main__':
from pasc.objects.floatarray import FloatArray
from pasc.modifier.mapper import RawBinary
farr = FloatArray.from_data('pre', 'tas')
# farr = FloatArray.from_numpy(np.arange(43, dtype=float))
farr = FloatArray.from_numpy(farr.array[::, ::, ::])
iarr = RawBinary.map(farr)
startidx = 0
print(ChequerboardC.name, ChequerboardC.flatten(startidx, iarr).sequence)
print(BlossomC.name, BlossomC.flatten(startidx, iarr).sequence)
print(BlockC.name, BlockC.flatten(startidx, iarr).sequence)
print(Linear.name, Linear.flatten(startidx, iarr).sequence)
print(Blossom.name, Blossom.flatten(startidx, iarr).sequence)
print(Block.name, Block.flatten(startidx, iarr).sequence)
print(Chequerboard.name, Chequerboard.flatten(startidx, iarr).sequence)
def reset(self):
self.builder = self.build(*self.args, **self.kwargs)
def feed(self, seqobj):
seqobj = _check_input(seqobj, BaseSequence)
self.reset()
for i in range(1, seqobj.sequence.size):
t = seqobj.__class__(seqobj.sequence[:i], seqobj.shape,
seqobj.data[:i])
yield self.builder.build_informationspace(t)
self.reset()
if __name__ == '__main__':
from itertools import islice
from pasc.objects.floatarray import FloatArray
from pasc.modifier import mapper as mp, sequencer as sq, builder as bd
farr = FloatArray.from_data('pre', 'tas', decode_times=False)
farr = FloatArray.from_numpy(farr.array[0, ::, ::])
iarr = mp.RawBinary.map(farr)
seq = sq.Linear.flatten(0, iarr)
builder = bd.RestrictedBuilder
kwargs = dict(restriction=5)
feeder = SpaceFeeder1DMA(builder, **kwargs)
result = islice(feeder.feed(seq, restriction=4), 902)
for IS in result:
print(IS, end='\n\n\n\n')
def to_floatarray(self, var):
dataarray = getattr(self.data, var)
return FloatArray(dataarray.values)