class DimensionList(object): @pv.verify_method(pv.Iterable(a_name="dimension_iter", a_type=Dimension)) def __init__(self, dimension_iter): self._list = list(dimension_iter) def __len__(self): return len(self._list) def __iter__(self): return iter(self._list) def box_count(self): return reduce(mul, [len(dimension) for dimension in self]) def box_iter(self): # 1) from every i'th dimension receive the Range list. # As result, we have list of list of Range # 2) product Range lists (for get every combination of ranges) # 3) iterate over result from (2), receive arguments for Box, create Boxes return [Box(range_list) for range_list in product(*map(iter, self))] def __str__(self): return "DimensionList<%s>" % self.create() def __repr__(self): return str(self) def create(self): return ','.join(map(Dimension.create, list(self)))
class Value(object): @pv.verify_method(pv.Iterable(a_name="value", a_type=int, a_none=True)) def __init__(self, value): self._value = value def compatible(self, right): pv.Var(a_name="right", a_type=Value).verify(self.compatible, right) if bool(self) != bool(right): raise TypeError( "Value: compatible expects both is None or both is " "not None, but self is %s and right is %s" % (self, right)) if not self is None: if len(self) != len(right): raise TypeError("Value: compatible expects same dimension " "count of values, but self has %s " "and right has %s" % (len(self), len(right))) def __nonzero__(self): return not (self._value is None) def __len__(self): 'Count of attributes' if self._value is None: raise ValueError("Value: is empty, len undefined") else: return len(self._value) def __iter__(self): 'Iterate over attribute values (value should be not empty)' return iter(self._value) def __cmp__(self, right): 'Compare two values' pv.Var(a_name="right", a_type=Value).verify(self.__cmp__, right) self.compatible(right) for (left, right) in izip(self, right): result = cmp(left, right) if result != 0: return result return 0 def __hash__(self): return sum(map(hash, self)) def __str__(self): if self._value is None: return '()' else: def to_string(value): if value is None: return '' else: return str(value) return '(%s)' % ','.join(map(to_string, self._value)) def __repr__(self): return "Value%s" % str(self)
class AttributeList(object): @pv.verify_method(pv.Iterable(a_name="attribute_iter", a_type=Attribute)) def __init__(self, attribute_iter): self._list = list(attribute_iter) def __len__(self): return len(self._list) def __iter__(self): return iter(self._list) def create(self): return ','.join(map(Attribute.create, self._list))
class Array(object): @pv.verify_method(name=pv.Str("name"), attribute_list=pv.Iterable("attribute_list", a_type=Attribute), dimension_list=pv.Iterable("dimension_list", a_type=Dimension), filler=pv.Proxy()) def __init__(self, name=None, attribute_list=None, dimension_list=None): #, filler=None): #if filler is None: # raise TypeError("Array: expected filler, but received %s" % str(filler)) self._name = name self._attribute = attribute_list self._dimension = dimension_list #self._filler= filler(self) @property def name(self): return self._name @property def attribute_list(self): return self._attribute @property def dimension_list(self): return self._dimension @property def filler(self): return self._filler def __len__(self): 'Total count of chunks inside the array' return self._dimension.box_count() def __iter__(self): 'Iterate over chunks inside the array' def create_chunk(box): return Chunk(box, self.filler) return imap(create_chunk, self._dimension.box_iter()) #def dense(self): # return self.cell_print(dense=True) #def sparse(self): # return self.cell_print(dense=False) #@pv.verify_method(dense=pv.Bool("dense")) #def cell_print(self, dense=None): # sep= ';%s' % os.linesep # if dense: # f= Chunk.dense # else: # f= Chunk.sparse # return sep.join(map(f, list(self))) def create(self): return "create array %s <%s> [%s]" % (self.name, self.attribute_list.create(), self.dimension_list.create()) def remove(self): return "remove(%s)" % self._name
class Vector(object): 'The n-dimensional vector' @pv.verify_method(pv.Iterable(a_name="vector", a_type=int)) def __init__(self, vector): self._vector = vector def __hash__(self): return sum(map(hash, self)) def __len__(self): 'Total count of components' return len(self._vector) def __str__(self): 'String representation of vector components' return '{%s}' % ','.join(map(str, self._vector)) def __repr__(self): return "Vector%s" % str(self) #def dense(self): # return '' #def sparse(self): # return str(self) def __getitem__(self, index): "Get index's component" return self._vector[index] def __iter__(self): 'Iterate over components' return iter(self._vector) def __neg__(self): return Vector(-item for item in self) def __pos__(self): return Vector(self) def compatible(self, right): pv.Var(a_name="right", a_type=Vector).verify(self.compatible, right) if len(self) != len(right): raise TypeError("Vector: compatible expects same " "dimension count of vectors, " "but self has %s and right has %s" % (len(self), len(right))) @property def zero(self): return Vector(0 for value in self) def __cmp__(self, right): 'Compare two vectors' self.compatible(right) for (left, right) in izip(self, right): result = cmp(left, right) if result != 0: return result return 0 def __add__(self, right): self.compatible(right) return Vector((left + right) for (left, right) in zip(self, right)) def __sub__(self, right): self.compatible(right) return Vector((left - right) for (left, right) in zip(self, right))
class Box(object): @pv.verify_method(pv.Iterable(a_name="range_iter", a_type=Range)) def __init__(self, range_iter): "every i'th range from range_iter - range from i'th dimension" self._range = range_iter def compatible(self, right): pv.Var(a_name="right", a_type=Box).verify(self.compatible, right) if len(self) != len(right): raise TypeError("Box: compatible expects same dimension count " "of boxes, but self has %s and right has %s" % (len(self), len(right))) def __nonzero__(self): return all(self) def __str__(self): return "Box(%s)" % ','.join(map(str, self)) def __repr__(self): return str(self) def __contains__(self, right): 'Vector inside the box' pv.Var(a_name="right", a_type=Box).verify(self.__contains__, right) if len(self) != len(right): raise TypeError( "Box: contains expects same dimension count of " "box and vector, but self has %s and right has %s" % (len(self), len(right))) return all(_item in _range for _range, _item in izip(self, right)) def __eq__(self, right): pv.Var(a_name="right", a_type=Box).verify(self.__eq__, right) self.compatible(right) return all(left == right for left, right in izip(self, right)) def __ne__(self, right): pv.Var(a_name="right", a_type=Box).verify(self.__ne__, right) return not (self == right) def __hash__(self): return mul(map(hash, [self._min, self._max])) def __len__(self): return len(self._range) def __iter__(self): return iter(self._range) def cell_count(self): return def vector_count(self): return mul(map(Range.value_count, self)) def vector_iter(self): return imap(Vector, product(*imap(Range.value_iter, self))) @property def minimum(self): return Vector([current_range.minimum.value for current_range in self])