Fast methods via Cython
This module provides extension classes with useful methods of cython speed, that python classes can inherit.
In its original version, this module provides a cython base class WithEqualityById implementing unique instance behaviour, and a cython base class FastHashable_class, which has a quite fast hash whose value can be freely chosen at initialisation time.
A class that has a fast hash method, returning a pre-assigned value.
This is for internal use only. The class has a cdef attribute _hash, that needs to be assigned (for example, by calling the init method, or by a direct assignement using cython). This is slower than using provide_hash_by_id(), but has the advantage that the hash can be prescribed, by assigning a cdef attribute _hash.
sage: from sage.misc.fast_methods import FastHashable_class sage: H = FastHashable_class(123) sage: hash(H) 123
Provide hash and equality test based on identity.
sage: class MyParent(Parent): ... def __init__(self, x): ... self.x = x ... def __cmp__(self,other): ... return cmp(self.x^2,other.x^2) ... def __hash__(self): ... return hash(self.x) sage: class MyUniqueParent(UniqueRepresentation, MyParent): pass sage: issubclass(MyUniqueParent, sage.misc.fast_methods.WithEqualityById) True
Inheriting from WithEqualityById provides unique representation behaviour. In particular, the comparison inherited from MyParent is overloaded:
sage: a = MyUniqueParent(1) sage: b = MyUniqueParent(2) sage: c = MyUniqueParent(1) sage: a is c True sage: d = MyUniqueParent(-1) sage: a == d False
Note, however, that Python distinguishes between “comparison by cmp” and “comparison by binary relations”:
sage: cmp(a,d) 0
The comparison inherited from MyParent will be used in those cases in which identity does not give sufficient information to find the relation:
sage: a < b True sage: b > d True
The hash inherited from MyParent is replaced by a hash that coincides with object‘s hash:
sage: hash(a) == hash(a.x) False sage: hash(a) == object.__hash__(a) True
It is possible to inherit from UniqueRepresentation and then overload equality test in a way that destroys the unique representation property. We strongly recommend against it! You should use CachedRepresentation instead.
sage: class MyNonUniqueParent(MyUniqueParent): ... def __eq__(self, other): ... return self.x^2 == other.x^2 sage: a = MyNonUniqueParent(1) sage: d = MyNonUniqueParent(-1) sage: a is MyNonUniqueParent(1) True sage: a == d True sage: a is d False