### Navigation

- index
- modules |
- next |
- previous |
- Miscellaneous »

# Fast methods via Cython

Fast methods via Cython

This module provides extension classes with useful methods of cython speed, that python classes can inherit.

Note

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.

AUTHOR:

- Simon King (2013-02)

class `sage.misc.fast_methods.``FastHashable_class`

  Bases: `object`

  A class that has a fast hash method, returning a pre-assigned value.

  NOTE:

  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`.

  TESTS:

      sage: from sage.misc.fast_methods import FastHashable_class
      sage: H = FastHashable_class(123)
      sage: hash(H)
      123

class `sage.misc.fast_methods.``WithEqualityById`

  Bases: `object`

  Provide hash and equality test based on identity.

  Note

  This class provides the unique representation behaviour of `UniqueRepresentation`, together with `CachedRepresentation`.

  EXAMPLES:

  Any instance of `UniqueRepresentation` inherits from `WithEqualityById`.

      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

  Warning

  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

### Navigation

- index
- modules |
- next |
- previous |
- Miscellaneous »