Costruire l'astrazione dei dati per numeri razionali usando "oggetti"

Seguo questa definizione di "oggetto": An object is a value exporting a procedural interface to data or behavior. Objects use procedural abstraction for information hiding, not type abstraction. Object and and their types are often recursive. Objects provide a simple and powerful form of data abstraction. They can be understood as closures, first-class modules, records of functions, or processes. Objects can also be used for procedural abstraction. da questo articolo

Viene insegnato in classe che astrazione dei dati è la metodologia per creare una barriera tra "come vengono utilizzati i valori dei dati" e "come vengono rappresentati i valori dei dati". Si insegna che un tipo di dati astratti (ADT) è una raccolta di selettori e costruttori, insieme ad alcune condizioni di comportamento (invarianti).

Si tratta di dati composti che richiedono l'elaborazione dei dati che consente di pensare all'astrazione dei dati perché l'utente desidera utilizzare questi dati composti come unità singola.

Costruire "astrazione dati" e "ADT" per "numero razionale" usando oggetti python

#Use
def mulRational(x, y):
    """Violate abstraction by using other than constructor and selectors"""
    return Rational(getNumer(x)*getNumer(y), getDenom(x)*getDenom(y)) #x and y are abstract data

def addRational(x, y):
    """Violate abstraction by using other than constructor and selectors"""
    nx, dx = getNumer(x), getDenom(x)
    ny, dy = getNumer(y), getDenom(y)
    return Rational(nx * dy + ny * dx, dx * dy)

def eqRational(x, y):
    """Violate abstraction by using other than constructor and selectors"""
    return getNumer(x) * getDenom(y) == getNumer(y) * getDenom(x)

def toString(x):
    """Violate abstraction by using other than constructor and selectors"""
    return '{0}/{1}'.format(getNumer(x), getDenom(x))

#Representation
# Representation is provided by constructors and selectors using tuples

#Constructor
from fractions import gcd
def Rational(n, d):
    """Construct a rational number x that represents n/d."""
    g = gcd(n, d)
    return (n // g, d // g) #this is concrete representation of a rational number


#Selector
from operator import getitem
def getNumer(x):
    """Return the numerator of rational number x."""
    return getitem(x, 0)

#Selector
def getDenom(x):
    """Return the denominator of rational number x."""
    return getitem(x, 1)

Il numero razionale ha dati composti (n,d) che consente di creare astrazione dati, poiché l'utente desidera utilizzare questi dati composti come unità singola.

Di seguito l'implementazione viene eseguita con una diversa "rappresentazione".

#Use
def mulRational(x, y):
    """Violate abstraction by using other than constructor and selectors"""
    return pair(getitem_pair(x,0) * getitem_pair(y,0), getitem_pair(x,1) * getitem_pair(y,1))

def addRational(x, y):
    """Violate abstraction by using other than constructor and selectors"""
    nx, dx = getitem_pair(x,0), getitem_pair(x,1)
    ny, dy = getitem_pair(y,0), getitem_pair(y,1)
    return pair(nx * dy + ny * dx, dx * dy)

def eqRational(x, y):
    """Violate abstraction by using other than constructor and selectors"""
    return getitem_pair(x,0) * getitem_pair(y,1) == getitem_pair(y,0) * getitem_pair(x,1)

def toString(x):
    """Violate abstraction by using other than constructor and selectors"""
    return '{0}/{1}'.format(getitem_pair(x,0), getitem_pair(x,1))


#Representation
#Representation is provided by constructors and selectors using higher order functions

#Constructor 
def pair(x, y):
    from fractions import gcd
    g = gcd(x, y)
    """Return a functional pair"""
    def dispatch(m):  
        if m == 0:
            return x // g

        elif m == 1:
            return y // g
    return dispatch

#Selector
def getitem_pair(p, i):
    """Return the element at index of pair p"""
    return p(i)

Nel codice precedente, Constructors & selectors costituisce ADT.

Nelle due implementazioni di cui sopra:

Esiste un tipo di dati astratto che supporta un'invarianza:

a) Se costruiamo il numero razionale x dal numeratore n e il denominatore d , quindi getNumer(x)/getDenom(x) deve essere uguale a n/d .

b) Se costruiamo il numero razionale x dal numeratore n e il denominatore d allora getitem_pair(p, 0)/getitem_pair(p, 1) deve essere uguale a n/d

Nelle precedenti 2 implementazioni abbiamo 3 barriere di astrazione:

1. Parti del programma che funzionano con numeri razionali per eseguire calcoli usa mulRational(..) , addRational(..) , eqRational(..) & & Solo processi di calcolo toString(..) .

2. Parti del programma che implementano solo mulRational(..) utilizza costruttore e selettori.

3. Parti del programma che implementano costruttori e amp; i selettori userebbero tipi di dati incorporati o funzioni integrate.

La mia domanda:

La mia comprensione è corretta sulla progettazione di astrazione dati e ADT per numeri razionali? Non sono d'accordo con meno di tre punti.

1) Questo articolo dice: "Mentre gli oggetti e gli ADT sono fondamentalmente diversi, sono entrambi < strong> moduli di astrazione dati. "

2) Questo articolo : "Un tipo di dati astratti è un struttura che implementa un nuovo tipo nascondendo la rappresentazione del tipo e fornendo operazioni per manipolare i suoi valori. "

3) Questo articolo dice: "I tipi di dati astratti dipendono da un sistema di tipo statico per applicare l'astrazione del testo. "

Motivo,

Nel codice precedente,

In primo luogo, l'astrazione dei dati ha la sua identità imponendo una barriera tra "rappresentazione" e "uso". Ogni implementazione di cui sopra ha set di "oggetti" che costruiscono le operazioni di astrazione e fornitura di dati [ mulRational ]

In secondo luogo, ADT è solo la raccolta di "costruttore" e "selettori" che supportano alcuni invarianti per convalidare la "rappresentazione". ADT nel codice precedente non ha implementato un nuovo tipo. ADT non ha fornito operazioni. ADT non richiede un sistema di tipi.