Binarna relacija

Binarna relacija R je skup uređenih parova (d1,d2) pri čemu je d1€domain1 i d2€domain2.

Ako relacija sadrži uređeni par (d1,d2), kažemo da je d1 u relaciji s d2 i pišemo:

d1 R d2.
 
Primjer
domain1 = studenti
domain2 = izborni predmeti
 
domain1 = {Mirko, Marko, Žarko, Slavko}
domain2 = {strukture, euklidski, algebra, neeuklidski}
 
R = {(Mirko, strukture), (Marko, euklidski), (Mirko, algebra), (Žarko, algebra), (Žarko, euklidski)}
 
 ATP relation
domain1 … bilo koji tip podataka
domain 2 … bilo koji tip podataka
relation … binarna relacija čiju prvu domenu čine podaci tipa domain1, a drugu domenu
podaci tipa domain2

R.Make_null() … funkcija koja kreira prazan skup R

R.relate(d1,d2) … funkcija koja skupu R pridružuje uređeni par (d1,d2), tj. d1 je u relaciji s d2
R.unrelate(d1,d2) … funkcija koja u skupu R briše uređeni par (d1,d2)

S = compute1(d2) … funkcija koja za zadani d2 (npr. euklidski) kreira novi skup S u koji
stavlja sve elemente iz domain1 koji su u relaciji s d2
S = compute2(d1) …
 Implementacija relacije pomoću bit-matrice
Primjer
domain1 = {2, 3, 5, 7}
domain2 = {3, 6, 8, 9}
 
R = {(2,6), (2,9), (3,3), (5,3), (5,6), (5,9)}
…
R.relate(3,9)
R[3,9]=1

S = R.compute1(9)
S = {2,5}

S = R.compute2(5)
S2 = {3, 6, 9}
class relation():
def __init__(self,n):
self.n = n
self.r =[[False for j in range(n)]for i in range(n)]

def __repr__(self):
for i in range(self.n):
for j in range(self.n):
if self.r[i][j]:
print(‘({},{})‘.format(i,j),end=‘ ')
return ''
def relate(self,i,j):
self.r[i][j] = True

def unrelate(self,i,j):
self.r[i][j] = False

def Make_null(self):
for i in range(self.n):
for j in range(self.n):
self.r[i][j] = False

def compute1(self, d2):

def compute2(self, d1):

 Implementacija relacije pomoću skupa u Pythonu
class relation:
def __init__(self, D1, D2):
self.D1 = D1
self.D2 = D2
self.R = set()

def __repr__(self):
for par in self.R:
print('({},{})'.format(par[0],par[1]),end=' ')
return ''
 Implementacija relacije pomoću skupa u Pythonu
def Make_null(self):
self.R=set()

def relate(self,d1,d2):
if d1 in self.D1 and d2 in self.D2:
self.R.add((d1,d2))

def unrelate(self,d1,d2):
self.R.discard((d1,d2))

def compute1(self,d2):
S = set()
for par in self.R:
if par[1] == d2:
S.add(par[0])
return S
def compute2(self,d1):
…