diff options
Diffstat (limited to '.venv/lib/python3.12/site-packages/fixedint/base.py')
| -rw-r--r-- | .venv/lib/python3.12/site-packages/fixedint/base.py | 468 |
1 files changed, 468 insertions, 0 deletions
diff --git a/.venv/lib/python3.12/site-packages/fixedint/base.py b/.venv/lib/python3.12/site-packages/fixedint/base.py new file mode 100644 index 00000000..ff93d43b --- /dev/null +++ b/.venv/lib/python3.12/site-packages/fixedint/base.py @@ -0,0 +1,468 @@ +# -*- coding: utf-8 -*- + +import sys +from fixedint.compat import * +from weakref import WeakValueDictionary + +class FixedProperty(object): + def __init__(self, val, doc): + self.val = val + self.__doc__ = doc + def __get__(self, obj, type=None): + return self.val + def __set__(self, obj, value): + raise AttributeError("property is read-only") + +class FixedMetaProperty(object): + def __init__(self, name, doc): + self.name = name + self.__doc__ = doc + def __get__(self, obj, type=None): + if self.name not in obj.__dict__: + # this should only happen when trying to access FixedInt.prop, which help() does + raise AttributeError("Attribute %s not defined on base class" % self.name) + prop = obj.__dict__[self.name] + return prop.__get__(obj) + def __set__(self, obj, value): + raise AttributeError("property %s is read-only" % self.name) + +if not PY3K: + # While it'd be nice to put machine-sized integers into Python 2.x "int"s, + # it turns out that the int methods occasionally freak out when given longs. + # So, we use arbitrary-precision ints for all Pythons. + int = long + +_class_cache = WeakValueDictionary() + +_doc_width = "Bit width of this integer, including the sign bit." +_doc_signed = "True if this integer is a twos-complement signed type." +_doc_mutable = "True if this integer is mutable (modifiable in-place)." +_doc_minval = "Minimum representable value of this integer type" +_doc_maxval = "Maximum representable value of this integer type" + +_subclass_token = object() +class _FixedIntBaseMeta(type): + def __new__(cls, name, bases, dict): + if dict.get('_subclass_enable', None) == _subclass_token: + del dict['_subclass_enable'] + return type.__new__(cls, name, bases, dict) + + for base in bases: + if issubclass(base, FixedInt): + basename = base.__name__ + raise Exception("Cannot subclass %s; use the %s constructor to produce new subclasses." % (basename, basename)) + raise Exception("Cannot subclass this class.") + + def __call__(self, width, signed=True, mutable=None): + signed = bool(signed) + if mutable is None: + # Take mutable from constructor used (FixedInt or MutableFixedInt) + mutable = (self == MutableFixedInt) + + cachekey = (width, signed, mutable) + try: + return _class_cache[cachekey] + except KeyError: + pass + + if signed: + min = -1<<(width-1) + max = (1<<(width-1))-1 + else: + min = 0 + max = (1<<width)-1 + + if mutable: + bases = (MutableFixedInt,) + else: + bases = (FixedInt, int) + + dict = {} + dict['width'] = FixedProperty(width, doc=_doc_width) + dict['signed'] = FixedProperty(signed, doc=_doc_signed) + dict['mutable'] = FixedProperty(mutable, doc=_doc_mutable) + dict['minval'] = FixedProperty(min, doc=_doc_minval) + dict['maxval'] = FixedProperty(max, doc=_doc_maxval) + + if signed: + _mask1 = (1<<(width-1)) - 1 + _mask2 = 1<<(width-1) + def _rectify(val): + return (val & _mask1) - (val & _mask2) + else: + _mask = (1<<width) - 1 + def _rectify(val): + return val & _mask + dict['_rectify'] = staticmethod(_rectify) + + if not mutable: + intbase = bases[1] + def _newfunc(cls, val=0): + ''' Convert an integer into a fixed-width integer. ''' + return intbase.__new__(cls, _rectify(int(val))) + _newfunc.__name__ = '__new__' + dict['__new__'] = _newfunc + + name = ''.join(['Mutable'*mutable, 'U'*(not signed), 'Int', str(width)]) + + cls = _FixedIntMeta(name, bases, dict) + _class_cache[cachekey] = cls + return cls + + width = FixedMetaProperty('width', doc=_doc_width) + signed = FixedMetaProperty('signed', doc=_doc_signed) + mutable = FixedMetaProperty('mutable', doc=_doc_mutable) + minval = FixedMetaProperty('minval', doc=_doc_minval) + maxval = FixedMetaProperty('maxval', doc=_doc_maxval) + +class _FixedIntMeta(_FixedIntBaseMeta): + __new__ = type.__new__ + __call__ = type.__call__ + + +def int_method(f): + if isinstance(f, str): + def wrapper(f2): + f2.__name__ = f + return int_method(f2) + return wrapper + else: + f.__doc__ = getattr(int, f.__name__).__doc__ + return f + +class FixedInt: + __slots__ = () + _subclass_enable = _subclass_token + + # width, signed, mutable, minval, maxval defined in metaclass + # _rectify defined in metaclass + # __new__ defined in metaclass + + if not PY3K: + @int_method + def __hex__(self): + return '%#x' % int(self) + def __oct__(self): + return '%#o' % int(self) + + @int_method + def __pow__(self, other, modulo=None): + # Jython can't handle int.__pow__(x, y, None) + if modulo is None: + return type(self)(int.__pow__(int(self), int(other))) + return type(self)(int.__pow__(int(self), int(other), modulo)) + + @int_method + def __rpow__(self, other): + return type(other)(int.__rpow__(int(self), int(other))) + + @int_method + def __repr__(self): + return '%s(%s)' % (type(self).__name__, self) + + @int_method + def __str__(self): + return str(int(self)) + + @classmethod + def _canonicalize_index(cls, idx): + if idx < 0: + idx += cls.width + return idx + + @classmethod + def _canonicalize_slice(cls, slice): + start = slice.start + stop = slice.stop + + if slice.step is not None: + raise ValueError("slice step unsupported") + + if start is None: + start = 0 + else: + start = cls._canonicalize_index(start) + + if stop is None: + stop = cls.width + elif isinstance(stop, complex): + if stop.real: + raise ValueError("invalid slice stop: must be integer or pure-imaginary complex number") + stop = int(stop.imag) + start + else: + stop = cls._canonicalize_index(stop) + + if 0 <= start < stop <= cls.width: + return (start, stop) + else: + raise IndexError("invalid slice %d:%d" % (start, stop)) + + def __getitem__(self, item): + ''' Slice the bits of an integer. + + x[a] gets a single bit at position a, returning a bool. + x[a:b] gets a range of bits as a FixedInt. + + For slice notation, b may be of the form 'bj' (a complex number) to treat it + as a length rather than a stop index. + The result will be of the type UIntX, where X is the number of bits in the range. + + Examples: + x[0]: equal to (x & 1) + x[1:5] or x[1:4j]: equal to (x & 31) >> 1 + x[:5]: equal to (x & 31) + ''' + + if isinstance(item, slice): + start, stop = self._canonicalize_slice(item) + return FixedInt(stop - start, signed=False)(int(self) >> start) + else: + item = self._canonicalize_index(item) + if 0 <= item < self.width: + return bool(int(self) & (1 << item)) + else: + raise IndexError("index %d out of range" % item) + + def to_bytes(self, length=None, byteorder=sys.byteorder): + if length is None: + length = (self.width + 7) // 8 + try: + return int(self).to_bytes(length, byteorder=byteorder, signed=self.signed) + except (OverflowError, AttributeError): + pass + + val = int(self) & ((1 << (length * 8)) - 1) + out = [] + while length > 0: + out.append(val & 0xff) + val >>= 8 + length -= 1 + if byteorder == 'big': + out = reversed(out) + if PY3K: + return bytes(out) + else: + return ''.join(map(chr, out)) + + @classmethod + def from_bytes(cls, bytes, byteorder=sys.byteorder, signed=None): + if cls in (FixedInt, MutableFixedInt): + if signed is None: + signed = False + elif signed is None: + signed = cls.signed + else: + raise ValueError("can't set signed with a concrete FixedInt") + + blen = len(bytes) + try: + val = int.from_bytes(bytes, byteorder=byteorder, signed=signed) + except AttributeError: + val = 0 + if byteorder == 'big': + bytes = reversed(bytes) + if PY3K: + for i,c in enumerate(bytes): + val |= c << (8 * i) + else: + for i,c in enumerate(bytes): + val |= ord(c) << (8 * i) + + if cls in (FixedInt, MutableFixedInt): + return cls(blen*8, signed=signed)(val) + else: + return cls(val) + + if PY3K: + @int_method + def __round__(self, n=0): + return int(self) + + # Inherited methods which are fine as-is: + # complex, int, long, float, index + # truediv, rtruediv, divmod, rdivmod, rlshift, rrshift + # format + +FixedInt = add_metaclass(_FixedIntBaseMeta)(FixedInt) + + +class MutableFixedInt(FixedInt): + _subclass_enable = _subclass_token + + def __init__(self, val=0, base=None): + ''' Convert an integer into a fixed-width integer. ''' + if base is None: + val = int(val) + else: + val = int(val, base) + + self._val = self._rectify(val) + + if PY3K: + @int_method + def __format__(self, format_spec): + return format(self._val, format_spec) + + def __ipow__(self, other, modulo=None): + if modulo is None: + self._val = self._rectify(int.__pow__(int(self), int(other))) + else: + self._val = self._rectify(int.__pow__(int(self), int(other), modulo)) + return self + + def __setitem__(self, item, value): + ''' Modify a slice of an integer. + + x[a]=y sets a single bit at position a. + x[a:b]=y sets a range of bits from an integer. + + See __getitem__ for more details on the slice notation. + ''' + + value = int(value) + if isinstance(item, slice): + start, stop = self._canonicalize_slice(item) + mask = (1 << (stop - start)) - 1 + self._val = (self._val & ~(mask << start)) | ((value & mask) << start) + else: + item = self._canonicalize_index(item) + if 0 <= item < self.width: + if value: + self._val |= (1 << item) + else: + self._val &= ~(1 << item) + return bool(int(self) & (1 << item)) + else: + raise IndexError("index %d out of range" % item) + +## Arithmetic methods +def _arith_unary_factory(name, mutable): + ''' Factory function producing methods for unary operations. ''' + intfunc = getattr(int, name) + if mutable: + @int_method(name) + def _f(self): + return type(self)(intfunc(self._val)) + else: + @int_method(name) + def _f(self): + return type(self)(intfunc(self)) + return _f + +_arith_unary = 'neg pos abs invert'.split() +for f in _arith_unary: + s = '__%s__' % f + setattr(FixedInt, s, _arith_unary_factory(s, mutable=False)) + setattr(MutableFixedInt, s, _arith_unary_factory(s, mutable=True)) + + +def _arith_convert(t1, t2): + if not issubclass(t2, FixedInt): + return t1 + + # Follow C conversion rules (ISO/IEC 9899:TC3 ยง6.3.1.8) + if t1.signed == t2.signed: + # If both are signed or both are unsigned, return the larger type. + if t1.width >= t2.width: + return t1 + return t2 + + if not t1.signed: + ut, st = t1, t2 + else: + ut, st = t2, t1 + + if ut.width >= st.width: + # If the unsigned type has rank >= the signed type, convert the signed type to the unsigned type. + return ut + else: + return st + +def _arith_binfunc_factory(name): + ''' Factory function producing methods for arithmetic operators ''' + intfunc = getattr(int, name) + @int_method(name) + def _f(self, other): + nt = _arith_convert(type(self), type(other)) + return nt(intfunc(int(self), int(other))) + return _f + +# divmod, rdivmod, truediv, rtruediv are considered non-arithmetic since they don't return ints +# pow, rpow, rlshift, and rrshift are special since the LHS and RHS are very different +_arith_binfunc = 'add sub mul floordiv mod lshift rshift and xor or'.split() +_arith_binfunc += 'radd rsub rmul rfloordiv rmod rand rxor ror'.split() +if not PY3K: + _arith_binfunc += 'div rdiv'.split() + +for f in _arith_binfunc: + s = '__%s__' % f + setattr(FixedInt, s, _arith_binfunc_factory(s)) + + +## Non-arithmetic methods (Mutable only) +def _nonarith_unary_factory_mutable(name): + ''' Factory function producing methods for unary operations. ''' + intfunc = getattr(int, name) + @int_method(name) + def _f(self): + return intfunc(self._val) + return _f + +_mutable_unary = 'int float'.split() +if sys.version_info[:2] >= (2,5): + _mutable_unary += ['index'] +if sys.version_info[:2] >= (2,6): + _mutable_unary += ['trunc'] +if PY3K: + _mutable_unary += 'bool'.split() +else: + _mutable_unary += 'nonzero long'.split() + +for f in _mutable_unary: + s = '__%s__' % f + setattr(MutableFixedInt, s, _nonarith_unary_factory_mutable(s)) + + +def _nonarith_binfunc_factory_mutable(name): + ''' Factory function producing methods for non-arithmetic binary operators on Mutable instances. ''' + intfunc = getattr(int, name) + @int_method(name) + def _f(self, other): + return intfunc(self._val, int(other)) + return _f + +_mutable_binfunc = 'truediv rtruediv divmod rdivmod rlshift rrshift'.split() +if hasattr(int, '__cmp__'): + _mutable_binfunc += ['cmp'] +else: + _mutable_binfunc += 'lt le eq ne gt ge'.split() +for f in _mutable_binfunc: + s = '__%s__' % f + setattr(MutableFixedInt, s, _nonarith_binfunc_factory_mutable(s)) + + +## In-place operators +def _inplace_factory_mutable(iname, name, op): + ''' Factory function producing methods for augmented assignments on Mutable instances. ''' + # This uses compiled operators instead of an int.__X__ function call for speed. + # Measured improvement is about 15% speed increase. + exec(""" +def _f(self, other): + self._val = self._rectify(self._val %s int(other)) + return self +globals()['_f'] = _f""" % op) + _f.__name__ = iname + doc = list.__iadd__.__doc__ + if doc: + _f.__doc__ = doc.replace('__iadd__', name).replace('+=', op+'=') + return _f + +# pow is special because it takes three arguments. +_inplace_func = 'add,+ sub,- mul,* truediv,/ floordiv,// mod,% lshift,<< rshift,<< and,& or,| xor,^'.split() +if not PY3K: + _inplace_func += ['div,/'] +for f in _inplace_func: + fn, op = f.split(',') + si = '__i%s__' % fn + so = '__%s__' % fn + setattr(MutableFixedInt, si, _inplace_factory_mutable(si, so, op)) |