def convert_base2_to_base16(self, number):
'''
Functie care converteste un numar din baza 2 in baza 16 (Conversie rapida)
Input: number - obiect de tip Numar, pentru care baza este egala cu 2
Output: un obiect de tip Numar, pentru care baza este egala cu 16
Raises: Exception
daca baza numarului transmis ca parametru nu este 2 -> "Baza nevalida!\n"
'''
self.__number = number
if self.__number.get_baza() != 2:
raise RepoError("Baza nevalida!\n")
rezultatNumber_value = ''
while self.__number.get_valoare() != '':
# Luam cel mai din dreapta grup de 4 cifre binare (sau de cate au mai ramas)
grup_cifre_binare = self.__number.get_valoare()[-4:]
# Convertim grupul de 4 cifre binare (sau de cate au mai ramas)
digit = base2_to_base16[grup_cifre_binare]
# Adaugam grupul de cifre binare la numar
rezultatNumber_value = digit + rezultatNumber_value
# Scoatem cele mai din dreapta grup de 4 cifre binare
self.__number.set_valoare(self.__number.get_valoare()[:-4])
return Numar(rezultatNumber_value, 16)
def valideaza_operatie(self, numarA, numarB, operatie):
'''
Functie care valideaza operatiile ce pot fi efectuate intre cele 2 numere
Input: numarA, numarB - entitati de tip Numar
operatie - un caracter
Output: -
Raises: Exception
if operations is '/' and the second number is 0 -> "Divide by 0!\n"
if operation is '-' and the second number is bigger than the first number -> "Scadere negativa!\n"
'''
erori = ''
if operatie == '/':
if numarB.get_valoare() == '0':
erori += "Divide by 0!\n"
elif operatie == '-':
if len(numarA.get_valoare()) < len(numarB.get_valoare()):
erori += "Scadere negativa!\n"
elif len(numarA.get_valoare()) == len(numarB.get_valoare()):
# Verific daca de la stanga la dreapta numarulA are o cifra mai mica decat numarulB.
scadereNegativa = False
index = 0
while index < len(
numarA.get_valoare()) and scadereNegativa == False:
if numarA.get_valoare()[index] < numarB.get_valoare(
)[index]:
scadereNegativa = True
index = index + 1
if scadereNegativa == True:
erori += "Scadere negativa!\n"
if len(erori) > 0: # Exista erori
raise RepoError(erori)
def convert_impartiri_succesive(self, number, baza):
'''
Functie care converteste un numar din baza 10 intr-o alta baza. (Metoda impartirii succesive)
Input: number - un obiect de tip Numar, pentru care baza este egala cu 10
baza - un numar intreg, pozitiv, ce apartine multimii {2, 3, ..., 10, 16}
Output: un obiect de tip Numar, pentru care baza este diferita de 10
Raises: Exception
daca numarul transmis ca parametru are baza diferita de 10 -> "Baza nevalida!\n"
'''
self.__number = number
if self.__number.get_baza() != 10:
raise RepoError("Baza nevalida!\n")
rezultatNumber_value = ''
if self.__number.get_valoare() == '0':
return Numar('0', baza)
while self.__number.get_valoare() != '0':
number_value_integer = int(self.__number.get_valoare())
digit = number_value_integer % baza
digit = decimal_to_character[digit]
rezultatNumber_value = digit + rezultatNumber_value
# Actualizam numarul
number_value_integer = number_value_integer // baza
self.__number.set_valoare(str(number_value_integer))
return Numar(rezultatNumber_value, baza)
def convert_base16_to_base2(self, number):
'''
Functie care converteste un numar din baza 16 in baza 2 (Conversie rapida)
Input: number - obiect de tip Numar, pentru care baza este egala cu 16
Output: un obiect de tip Numar, pentru care baza este egala cu 2
Raises: Exception
daca baza numarului transmis ca parametru nu este 16 -> "Baza nevalida!\n"
'''
self.__number = number
if self.__number.get_baza() != 16:
raise RepoError("Baza nevalida!\n")
rezultatNumber_value = ''
for index in range(len(self.__number.get_valoare())):
digit = self.__number.get_valoare()[index]
# Convertim cifra in baza 16 a numarului la grupul de 4 cifre binare
grup_cifre_binare = base16_to_base2[digit]
# Adaugam grupul de cifre binare la numar
rezultatNumber_value = rezultatNumber_value + grup_cifre_binare
# Elimin zerourile din fata numarului
while rezultatNumber_value[0] == '0':
rezultatNumber_value = rezultatNumber_value[1:]
return Numar(rezultatNumber_value, 2)
def get_students(self):
"""
Returns all students from repo
"""
if len(self._repoStudents.get_all()) == 0:
raise RepoError("Repo Empty")
return self._repoStudents.get_all()
def add(self, element):
"""
Adds a new element in the repo
:params element = the new element
"""
if element in self._entities:
raise RepoError("id existent!\n")
self._entities.append(element)
def search(self, element):
"""
Searches for an element in the repo
:params element = element to be looking for
:return: the element looked for
"""
if element not in self._entities:
raise RepoError("id inexistent!\n")
for x in self._entities:
if x == element:
return x
def adauga_disc(self, disc):
"""
metoda care adauga disciplina | sau eroare daca exista deja
date de intrare:
disc-disciplina pe care vrem sa o aduagam
date de iesire:-
date de exceptie:
RepoError-"Disciplina existenta!"
"""
if disc in self._discipline:
raise RepoError("Disciplina existenta!")
self._discipline.append(disc)
def adauga_stud(self, stud):
"""
metoda care adauga student in lista de studenti | sau eroare daca exista deja
date de intrare:
stud-studentul pe care vrem sa il aduagam
date de iesire:-
date de exceptie:
RepoError-"Student existent!"
"""
if stud in self._studenti:
raise RepoError("Student existent!")
self._studenti.append(stud)
def adauga_nota(self, nota):
"""
metoda care adauga nota | sau eroare daca exista deja
date de intrare:
nota-nota pe care vrem sa o aduagam
date de iesire:-
date de exceptie:
RepoError-"Nota existenta!"
"""
if nota in self._note:
raise RepoError("Nota existenta!")
self._note.append(nota)
def cauta_stud(self, id_stud):
"""
metoda care returneaza un student dupa id in lista de studenti | sau eroare daca nu il gaseste
date de intrare:
id_stud-idul studentului pe care il cautam
date de iesire:
el-studentul pe care il cautam
date de exceptie:
RepoError-"Student inexistent!"
"""
for el in self._studenti:
if el.get_id_stud() == id_stud:
return el
raise RepoError("Student inexistent!")
def sterge_stud(self, id_stud):
"""
metoda care sterge student dupa id in lista de studenti | sau eroare daca nu il gaseste
date de intrare:
id_stud-idul studentului
date de iesire:-
exceptii:
RepoError-"Student inexistent!"
"""
for i in range(len(self._studenti)):
if self._studenti[i].get_id_stud() == id_stud:
del self._studenti[i]
return
raise RepoError("Student inexistent!")
def sterge_disc(self, id_disc):
"""
metoda care sterge disciplina dupa id | sau eroare daca nu o gaseste
date de intrare:
id_disc-idul disciplinei
date de iesire:-
date de exceptie:
RepoError-"Disciplina inexistenta!"
"""
for i in range(len(self._discipline)):
if self._discipline[i].get_id_disc() == id_disc:
del self._discipline[i]
return
raise RepoError("Disciplina inexistenta!")
def cauta_disc(self, id_disc):
"""
metoda care returneaza o disciplina dupa id | sau eroare daca nu o gaseste
date de intrare:
id_disc-idul disciplinei pe care o cautam
date de iesire:
self.__discipline[i]-disciplina pe care o cautam
date de exceptie:
RepoError-"Disciplina inexistenta!"
"""
for i in range(len(self._discipline)):
if self._discipline[i].get_id_disc() == id_disc:
return self._discipline[i]
raise RepoError("Disciplina inexistenta!")
def sterge_nota(self, id_nota):
"""
metoda care sterge nota dupa id | sau eroare daca nu o gaseste
date de intrare:
id_nota-idul notei
date de iesire:-
date de exceptie:
RepoError-"Nota inexistenta!"
"""
for i in range(len(self._note)):
if self._note[i].get_id_nota() == id_nota:
del self._note[i]
return
raise RepoError("Nota inexistenta!")
def cauta_nota(self, id_nota):
"""
metoda care returneaza o nota dupa id in lista de note | sau eroare daca nu o gaseste
date de intrare:
id_nota-idul notei pe care o cautam
date de iesire:
el-nota pe care o cautam
date de exceptie:
RepoError-"Nota inexistenta!"
"""
for el in self._note:
if el.get_id_nota() == id_nota:
return el
raise RepoError("Nota inexistenta!")
def modifica_stud(self, stud_modif):
"""
metoda care modifica student in lista de studenti dupa id, id-ul ramanand la fel | sau eroare daca nu il gaseste
date de intrare:
stud_modif-inlocuitorul studentului pe care vrem sa-l schimbam
date de iesire:-
date de exceptie:
RepoError-"Student inexistent!"
"""
for i in range(len(self._studenti)):
if self._studenti[i] == stud_modif:
stud_precedent = self._studenti[i]
self._studenti[i] = stud_modif
return stud_precedent
raise RepoError("Student inexistent!")
def modifica_disc(self, disc_modif):
"""
metoda care modifica disciplina dupa id, id-ul ramanand la fel | sau eroare daca nu o gaseste
date de intrare:
disc_modif-inlocuitorul disciplinei pe care vrem s-o schimbam
date de iesire:-
date de exceptie:
RepoError-"Disciplina inexistenta!"
"""
for i in range(len(self._discipline)):
if self._discipline[i] == disc_modif:
disc_precedent = self._discipline[i]
self._discipline[i] = disc_modif
return disc_precedent
raise RepoError("Disciplina inexistenta!")
def modifica_nota(self, nota_modif):
"""
metoda care modifica nota in lista de note dupa id, id-ul ramanand la fel | sau eroare daca nu o gaseste
date de intrare:
nota_modif-noua nota pe care vrem sa o schimbam
date de iesire:-
date de exceptie:
RepoError-"Nota inexistenta!"
"""
for i in range(len(self._note)):
if self._note[i] == nota_modif:
nota_precedenta = self._note[i]
self._note[i] = nota_modif
return nota_precedenta
raise RepoError("Nota inexistenta!")
def convert_subtitutie(self, number):
'''
Functie care converteste un numar dintr-o baza diferita de 10 in baza 10. (Metoda subtitutiei)
Input: number - un obiect de tip Numar, pentru care baza este diferita de 10
Output: un obiect de tip Numar, pentru care baza este egala cu 10
Raises: Exception
daca numarul transmis ca parametru are baza 10 -> "Baza nevalida!\n"
'''
self.__number = number
if self.__number.get_baza() == 10:
raise RepoError("Baza nevalida!\n")
rezultat_integer = 0
factor = 1
for index in range(len(self.__number.get_valoare()) - 1, -1, -1):
digit = character_to_decimal[self.__number.get_valoare()[index]]
rezultat_integer = rezultat_integer + factor * digit
factor = factor * self.__number.get_baza()
return Numar(str(rezultat_integer), 10)
def peek(self):
if len(self) == 0:
raise RepoError("Undo indisponibil!")
return self.__stiva[self.__index]
def pull(self):
if len(self) == len(self.__stiva):
raise RepoError("Redo indisponibil!")
self.__index += 1
