Confronto di oggetti con tolleranza

Penso che tu voglia qualcosa come un istogramma ma dove le categorie si basano sui dati che trovi e sull'ordine in cui li trovi. È fondamentale capire che le categorie non saranno garantite per essere distribuite uniformemente nel dominio come avviene normalmente in un istogramma.

categories = []

def categorize(shape):
  index=0

  for c in categories:
    if c.withinTolerance(shape):
      return c
    elif c.largerThan(shape):
      categories.insert(i, shape)
      return shape

    index += 1        

  categories.append(shape)
  return shape

def equalish(a, b):
  return categorize(a) == categorize(b)

Quindi, in base all'ancora della tua categoria basata su quanto sopra, puoi creare un uguale (anche se sono d'accordo con @Servy che dovrebbe essere usato un nome diverso).

Modifica

Questo è un esempio funzionante che mostra come è coerente (all'interno di una sessione).

TOL = 0.11

class C:
    categories = []

    def __init__(self, x):
        self.x = x

def _compare(self, other):
    return abs(self.x - other.x) < TOL

def __eq__(self, other):
    for c in self.categories:
        self_equal_c = c._compare(self)
        other_equal_c = c._compare(other)
        if self_equal_c or other_equal_c:
            return self_equal_c and other_equal_c
    self.categories.append(self)
    return self._compare(other)

a = C(1.1)
b = C(1.2)
c = C(1.3)

print('a == c', a == c)
print('a == b', a == b)
print('a == c', a == c)
print('b == c', b == c)

Questa soluzione è leggermente migliore di un istogramma quando vengono confrontati solo due elementi perché un istogramma renderebbe due elementi diversi quando si trovano in due diversi secchi anche se la loro distanza è inferiore alla tolleranza.

Questa soluzione è molto meglio di un istogramma quando vengono confrontate più di una proprietà. Se la classe C aveva più di un campo (come nell'esempio precedente), l'uso dell'istogramma causerebbe la quasi totalità degli elementi.

Evitare l'annullamento di un'uguaglianza implicita di oggetti quando si utilizza una tolleranza. Esporre un metodo specifico o un oggetto di confronto che confronta gli oggetti usando una tolleranza (ed è molto chiaro a riguardo nel suo nome / documentazione). L'eguaglianza implicita dell'oggetto dovrebbe rimanere transitiva, che questa implementazione non soddisfa.

In questo modo si garantisce che chiunque utilizzi questo metodo di confronto sia consapevole del fatto che non mantiene tutte le proprietà di un confronto di uguaglianza tradizionale e che dovrebbero utilizzarlo solo in un contesto in cui ciò è corretto e assicurati che le persone che usano l'uguaglianza implicita non abbiano le loro aspettative violate su come si comporta.

Stai chiedendo l'impossibile. O abbini esattamente o abbini con una tolleranza. Non puoi fare entrambe le cose contemporaneamente.

Dopo aver letto il tuo caso d'uso, posso pensare a un modo per affrontarlo. Capisco che inizi sempre con una forma che può essere tradotta e / o copiata un paio di volte. Perché non mantenere una proprietà di origine attaccata alla forma e confrontarla invece della forma stessa? Se due forme hanno la stessa origine, devono essere uguali indipendentemente dal numero di volte in cui sono state ridimensionate o ruotate. Quando una forma viene copiata, ottiene l'id origine del suo modello. Le nuove forme ottengono nuovi ID di origine.