def __test_repo_convert_base2_to_base16(self):
'''
Functie care verifica daca conversia unui numar din baza 2 in baza 16 a fost realizata cu succes
'''
repo = Repo()
numar = Numar('101111110101', 2)
rezultat = repo.convert_base2_to_base16(numar)
assert rezultat.get_valoare() == 'BF5'
assert rezultat.get_baza() == 16
numar = Numar('11100', 2)
rezultat = repo.convert_base2_to_base16(numar)
assert rezultat.get_valoare() == '1C'
numar = Numar('101101', 2)
rezultat = repo.convert_base2_to_base16(numar)
assert rezultat.get_valoare() == '2D'
numar = Numar('1001110', 2)
rezultat = repo.convert_base2_to_base16(numar)
assert rezultat.get_valoare() == '4E'
numar = Numar('110001', 5)
try:
rezultat = repo.convert_base2_to_base16(numar)
assert False
except RepoError as re:
assert str(re) == "Baza nevalida!\n"
def __test_repo_impartiri_succesive(self):
'''
Functie test care verifica daca un numar a fost convertit cu succes prin imparitiri succesive
'''
repo = Repo()
numar = Numar('34', 10)
rezultat = repo.convert_impartiri_succesive(numar, 2)
assert rezultat.get_valoare() == '100010'
assert rezultat.get_baza() == 2
numar = Numar('63', 10)
rezultat = repo.convert_impartiri_succesive(numar, 16)
assert rezultat.get_valoare() == '3F'
assert rezultat.get_baza() == 16
numar = Numar('43', 10)
rezultat = repo.convert_impartiri_succesive(numar, 3)
assert rezultat.get_valoare() == '1121'
assert rezultat.get_baza() == 3
numar = Numar('17', 9)
try:
rezultat = repo.convert_impartiri_succesive(numar, 3)
assert False
except RepoError as re:
assert str(re) == "Baza nevalida!\n"
def __test_repo_convert_base16_to_base2(self):
'''
Functie care verifica daca conversia unui numar din baza 16 in baza 2 a fost realizata cu succes
'''
repo = Repo()
numar = Numar('25AF', 16)
rezultat = repo.convert_base16_to_base2(numar)
assert rezultat.get_valoare() == '10010110101111'
assert rezultat.get_baza() == 2
numar = Numar('60BC', 16)
rezultat = repo.convert_base16_to_base2(numar)
assert rezultat.get_valoare() == '110000010111100'
numar = Numar('D179', 16)
rezultat = repo.convert_base16_to_base2(numar)
assert rezultat.get_valoare() == '1101000101111001'
numar = Numar('348E', 16)
rezultat = repo.convert_base16_to_base2(numar)
assert rezultat.get_valoare() == '11010010001110'
numar = Numar('63', 10)
try:
rezultat = repo.convert_base16_to_base2(numar)
assert False
except RepoError as re:
assert str(re) == "Baza nevalida!\n"
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 __test_creeaza_numar(self):
'''
Functie de tip test care verifica daca un obiect de tip Numar a fost creat cu succes
'''
numar = Numar('120', 3)
assert numar.get_valoare() == '120'
assert numar.get_baza() == 3
numar.set_valoare('122')
assert numar.get_valoare() == '122'
numar.set_baza(4)
assert numar.get_baza() == 4
def division_decimalBase(self, stNumber, ndNumber):
'''
Function that divides two numbers in base 10
Input: stNumber, ndNumber - entities of type Numar, with decimal base
Output: two objects of type Numar, one representing the quotient, while the other representing the remainder, both in base 10
'''
self.__stNumber = stNumber
self.__ndNumber = ndNumber
quotient = int(self.__stNumber.get_valoare()) // int(
self.__ndNumber.get_valoare())
remainder = int(self.__stNumber.get_valoare()) % int(
self.__ndNumber.get_valoare())
return Numar(str(quotient), 10), Numar(str(remainder), 10)
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 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 __test_repo_convert_base8_to_base2(self):
'''
Functie care verifica daca conversia unui numar din baza 8 in baza 2 a fost realizata cu succes
'''
repo = Repo()
numar = Numar('1430', 8)
rezultat = repo.convert_base8_to_base2(numar)
assert rezultat.get_valoare() == '1100011000'
assert rezultat.get_baza() == 2
numar = Numar('7256', 8)
rezultat = repo.convert_base8_to_base2(numar)
assert rezultat.get_valoare() == '111010101110'
numar = Numar('23', 7)
try:
rezultat = repo.convert_base8_to_base2(numar)
assert False
except RepoError as re:
assert str(re) == "Baza nevalida!\n"
def multiply(self, valoare_numarA, valoare_numarB, baza_numarA,
baza_numarB, baza_calcul):
'''
Functie care inmulteste doua numere intr-o anumita baza
Input: valoare_numarA, valoare_numarB - string-uri
baza_numarA, baza_NumarB, baza_calcul - numere intregi, pozitive
Output: un obiect de tip Numar, reprezentand rezultatul calculului de inmultire
'''
numarA = Numar(valoare_numarA, baza_numarA)
numarB = Numar(valoare_numarB, baza_numarB)
# Convertim numerele la baza in care se va efectua calculul
numarA_convertit = self.__repoNumar.convert_to_another_base(
numarA, baza_calcul)
numarB_convertit = self.__repoNumar.convert_to_another_base(
numarB, baza_calcul)
# Validate the correctness of the operation
self.__validatorNumar.valideaza_operatie(numarA_convertit,
numarB_convertit,
operatie='*')
# Efectuam inmultirea in baza de calcul
return self.__repoNumar.multiply(numarA_convertit, numarB_convertit,
baza_calcul)
def substract(self, valoare_numarA, valoare_numarB, baza_numarA,
baza_numarB, baza_calcul):
'''
Functie care scade doua numere intr-o anumita baza
Input: valoare_numarA, valoare_numarB - string-uri
baza_numarA, baza_NumarB, baza_calcul - numere intregi, pozitive
Output: un obiect de tip Numar, reprezentand rezultatul calculului de scadere
Raises: Exception
daca primul numar este mai mic decat al doilea numar -> "Scadere negativa!\n"
'''
numarA = Numar(valoare_numarA, baza_numarA)
numarB = Numar(valoare_numarB, baza_numarB)
# Convertim numerele la baza in care se va efectua calculul
numarA_convertit = self.__repoNumar.convert_to_another_base(
numarA, baza_calcul)
numarB_convertit = self.__repoNumar.convert_to_another_base(
numarB, baza_calcul)
# Validam cele doua numere: primul numar trebuie sa fie mai mare decat al doilea numar (in baza de calcul)
self.__validatorNumar.valideaza_operatie(numarA_convertit,
numarB_convertit,
operatie='-')
# Efectuam scaderea in baza de calcul
return self.__repoNumar.substract(numarA_convertit, numarB_convertit,
baza_calcul)
def __test_repo_subtitutie(self):
'''
Functie de tip test care verifica daca conversia prin metoda subtitutiei a unui numar a fost realizata cu succes
'''
repo = Repo()
numar = Numar('1010', 2)
rezultat = repo.convert_subtitutie(numar)
assert rezultat.get_valoare() == '10'
assert rezultat.get_baza() == 10
numar = Numar('153', 6)
rezultat = repo.convert_subtitutie(numar)
assert rezultat.get_valoare() == '69'
numar = Numar('A3', 16)
rezultat = repo.convert_subtitutie(numar)
assert rezultat.get_valoare() == '163'
numar = Numar('132', 10)
try:
rezultat = repo.convert_subtitutie(numar)
assert False
except RepoError as re:
assert str(re) == "Baza nevalida!\n"
def divide(self, valoare_numarA, valoare_numarB, baza_numarA, baza_numarB,
baza_calcul):
'''
Functie care imparte doua numere intr-o anumita baza
Input: valoare_numarA, valoare_numarB - string-uri
baza_numarA, baza_NumarB, baza_calcul - numere intregi, pozitive
Output: doua obiecte de tip Numar, reprezentand catul si restul calcului de impartire
Raises: Exception
if the second number is 0 -> "Divide by zero!\n"
'''
numarA = Numar(valoare_numarA, baza_numarA)
numarB = Numar(valoare_numarB, baza_numarB)
# Convertim numerele la baza in care se va efectua calculul
numarA_convertit = self.__repoNumar.convert_to_another_base(
numarA, baza_calcul)
numarB_convertit = self.__repoNumar.convert_to_another_base(
numarB, baza_calcul)
# Validate the correctness of the operation: the second number has to be non-zero
self.__validatorNumar.valideaza_operatie(numarA_convertit,
numarB_convertit,
operatie='/')
# Efectuam impartirea in baza de calcul
return self.__repoNumar.divide(numarA_convertit, numarB_convertit,
baza_calcul)
def add(self, stNumber, ndNumber, baza):
'''
Functie care aduna doua numere intr-o anumita baza
Input: stNumber - un obiect de tip Numar
ndNumber - un obiect de tip Numar
baza - un numar intreg, pozitiv
Output: un obiect de tip Numar
'''
self.__stNumber = stNumber
self.__ndNumber = ndNumber
self.__baza = baza
rezultatNumber_value = ''
carryDigit = 0
while len(self.__stNumber.get_valoare()) > 0 or len(
self.__ndNumber.get_valoare()) > 0:
# Convertim cele mai din dreapta cifre ale celor doua numere la integer.
# Totodata, elimanam cea mai dreapta cifra a fiecarui numar
if len(self.__stNumber.get_valoare()) == 0:
digit_stNumber = 0
else: # Numarul nu este inca zero
digit_stNumber = character_to_decimal[
self.__stNumber.get_valoare()[-1]]
self.__stNumber.set_valoare(self.__stNumber.get_valoare()[:-1])
if len(self.__ndNumber.get_valoare()) == 0:
digit_ndNumber = 0
else: # Numarul nu este inca zero
digit_ndNumber = character_to_decimal[
self.__ndNumber.get_valoare()[-1]]
self.__ndNumber.set_valoare(self.__ndNumber.get_valoare()[:-1])
rezultat_adunare = digit_stNumber + digit_ndNumber + carryDigit
digit_rezultat = rezultat_adunare % self.__baza
carryDigit = rezultat_adunare // self.__baza
character_rezultat = decimal_to_character[
digit_rezultat] # Transformam cifra in caracter
rezultatNumber_value = character_rezultat + rezultatNumber_value
# Verificam daca a mai ramas o cifra de transport
if carryDigit != 0:
character_rezultat = decimal_to_character[
carryDigit] # Transformam cifra in caracter
rezultatNumber_value = character_rezultat + rezultatNumber_value
return Numar(rezultatNumber_value, self.__baza)
def substract(self, stNumber, ndNumber, baza):
'''
Functie care scade doua numere intr-o anumita baza
Input: stNumber - un obiect de tip Numar
ndNumber - un obiect de tip Numar
baza - un numar intreg, pozitiv
Output: un obiect de tip Numar
'''
self.__stNumber = stNumber
self.__ndNumber = ndNumber
self.__baza = baza
rezultatNumber_value = ''
borrowDigit = 0
while len(self.__stNumber.get_valoare()) > 0 or len(
self.__ndNumber.get_valoare()) > 0:
# Convertim cele mai din dreapta cifre ale celor doua numere la integer.
# Totodata, elimanam cea mai dreapta cifra a fiecarui numar
if len(self.__stNumber.get_valoare()) == 0:
digit_stNumber = 0
else: # Numarul nu este inca zero
digit_stNumber = character_to_decimal[
self.__stNumber.get_valoare()[-1]]
self.__stNumber.set_valoare(self.__stNumber.get_valoare()[:-1])
if len(self.__ndNumber.get_valoare()) == 0:
digit_ndNumber = 0
else: # Numarul nu este inca zero
digit_ndNumber = character_to_decimal[
self.__ndNumber.get_valoare()[-1]]
self.__ndNumber.set_valoare(self.__ndNumber.get_valoare()[:-1])
rezultat_scadere = digit_stNumber - digit_ndNumber + borrowDigit
if rezultat_scadere < 0:
rezultat_scadere = self.__baza + rezultat_scadere
borrowDigit = -1
else:
borrowDigit = 0
character_rezultat = decimal_to_character[
rezultat_scadere] # Transformam cifra in caracter
rezultatNumber_value = character_rezultat + rezultatNumber_value
# Elimin zerourile din fata numarului
while len(rezultatNumber_value) > 1 and rezultatNumber_value[0] == '0':
rezultatNumber_value = rezultatNumber_value[1:]
return Numar(rezultatNumber_value, self.__baza)
def convert_to_another_base(self, number, noua_baza):
'''
Functie care converteste un numar dintr-o baza in alta baza
Input: number - un obiect de tip Numar
noua_baza - un numar intreg, pozitiv
Output: un obiect de tip Numar
'''
self.__number = number
conversie_rapida = False # Daca se foloseste conversia rapida, nu mai convertim prin subtitutie si impartiri succesive
# Daca baza numarului este egala cu 2, iar noua_baza este 4, 8 sau 16 convertim numarul prin Metoda Conversiei Rapide
if self.__number.get_baza() == 2:
if noua_baza == 4:
self.__number = self.convert_base2_to_base4(self.__number)
conversie_rapida = True
elif noua_baza == 8:
self.__number = self.convert_base2_to_base8(self.__number)
conversie_rapida = True
elif noua_baza == 16:
self.__number = self.convert_base2_to_base16(self.__number)
conversie_rapida = True
# Daca baza numarul este egala cu 4, 8 sau 16, iar noua_baza este 2 convertim numarul prin Metoda Conversiei Rapide
if noua_baza == 2:
if self.__number.get_baza() == 4:
self.__number = self.convert_base4_to_base2(self.__number)
conversie_rapida = True
if self.__number.get_baza() == 8:
self.__number = self.convert_base8_to_base2(self.__number)
conversie_rapida = True
if self.__number.get_baza() == 16:
self.__number = self.convert_base16_to_base2(self.__number)
conversie_rapida = True
if conversie_rapida == False: # Nu s-a folosit metoda Conversiilor Rapide
# Daca baza numarului este diferita de 10, atunci convertim numarul prin Metoda Subtitutiei la baza 10
# este egala cu 10, atunci nu mai este nevoie sa il convertim.
if self.__number.get_baza() != 10:
self.__number = self.convert_subtitutie(self.__number)
# Daca noua baza este diferita de 10, atunci convertim numarul prin Metoda Impartirilor Succesive la noua baza
# este egala cu 10, atunci nu mai este nevoie sa il convertim.
if noua_baza != 10:
self.__number = self.convert_impartiri_succesive(
self.__number, noua_baza)
return Numar(self.__number.get_valoare(), self.__number.get_baza())
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 __test_repo_convert_to_another_base(self):
'''
Functie test care verifica daca un numar este convertit dintr-o baza in alta cu succes
'''
repo = Repo()
numar = Numar('120', 3)
rezultat = repo.convert_to_another_base(numar, 7)
assert rezultat.get_valoare() == '21'
assert rezultat.get_baza() == 7
numar = Numar('A7', 16)
rezultat = repo.convert_to_another_base(numar, 5)
assert rezultat.get_valoare() == '1132'
assert rezultat.get_baza() == 5
numar = Numar('35', 10)
rezultat = repo.convert_to_another_base(numar, 2)
assert rezultat.get_valoare() == '100011'
assert rezultat.get_baza() == 2
numar = Numar('163', 9)
rezultat = repo.convert_to_another_base(numar, 10)
assert rezultat.get_valoare() == '138'
assert rezultat.get_baza() == 10
numar = Numar('150', 10)
rezultat = repo.convert_to_another_base(numar, 10)
assert rezultat.get_valoare() == '150'
assert rezultat.get_baza() == 10
numar = Numar('1EF', 16)
rezultat = repo.convert_to_another_base(numar, 2)
assert rezultat.get_valoare() == '111101111'
assert rezultat.get_baza() == 2
numar = Numar('10101011', 2)
rezultat = repo.convert_to_another_base(numar, 8)
assert rezultat.get_valoare() == '253'
assert rezultat.get_baza() == 8
def __test_repo_substract(self):
'''
Functie de tip test care verifica daca scaderea a doua numere intr-o anumita baza a fost realizata cu succes
'''
repo = Repo()
numarA = Numar('54', 6)
numarB = Numar('32', 6)
rezultat = repo.substract(numarA, numarB, 6)
assert rezultat.get_valoare() == '22'
assert rezultat.get_baza() == 6
numarA = Numar('54', 6)
numarB = Numar('35', 6)
rezultat = repo.substract(numarA, numarB, 6)
assert rezultat.get_valoare() == '15'
numarA = Numar('54', 6)
numarB = Numar('45', 6)
rezultat = repo.substract(numarA, numarB, 6)
assert rezultat.get_valoare() == '5'
numarA = Numar('154', 6)
numarB = Numar('55', 6)
rezultat = repo.substract(numarA, numarB, 6)
assert rezultat.get_valoare() == '55'
numarA = Numar('AB', 16)
numarB = Numar('3C', 16)
rezultat = repo.substract(numarA, numarB, 16)
assert rezultat.get_valoare() == '6F'
assert rezultat.get_baza() == 16
numarA = Numar('127', 10)
numarB = Numar('30', 10)
rezultat = repo.substract(numarA, numarB, 10)
assert rezultat.get_valoare() == '97'
assert rezultat.get_baza() == 10
numarA = Numar('13', 10)
numarB = Numar('13', 10)
rezultat = repo.substract(numarA, numarB, 10)
assert rezultat.get_valoare() == '0'
assert rezultat.get_baza() == 10
def __test_repo_add(self):
'''
Functie de tip test care verifica daca adunarea a doua numere intr-o anumita baza a fost realizata cu succes
'''
repo = Repo()
numarA = Numar('120', 3)
numarB = Numar('102', 3)
rezultat = repo.add(numarA, numarB, 3)
assert rezultat.get_valoare() == '222'
assert rezultat.get_baza() == 3
numarA = Numar('120', 3)
numarB = Numar('110', 3)
rezultat = repo.add(numarA, numarB, 3)
assert rezultat.get_valoare() == '1000'
numarA = Numar('2A', 16)
numarB = Numar('14', 16)
rezultat = repo.add(numarA, numarB, 16)
assert rezultat.get_valoare() == '3E'
assert rezultat.get_baza() == 16
numarA = Numar('2A', 16)
numarB = Numar('17', 16)
rezultat = repo.add(numarA, numarB, 16)
assert rezultat.get_valoare() == '41'
numarA = Numar('1235', 10)
numarB = Numar('0', 10)
rezultat = repo.add(numarA, numarB, 10)
assert rezultat.get_valoare() == '1235'
assert rezultat.get_baza() == 10
numarA = Numar('1235', 10)
numarB = Numar('65', 10)
rezultat = repo.add(numarA, numarB, 10)
assert rezultat.get_valoare() == '1300'
numarA = Numar('', 10)
numarB = Numar('6', 10)
rezultat = repo.add(numarA, numarB, 10)
assert rezultat.get_valoare() == '6'
def multiply(self, stNumber, ndNumber, baza):
'''
Functie care inmulteste doua numere intr-o anumita baza
Input: stNumber - un obiect de tip Numar
ndNumber - un obiect de tip Numar
baza - un numar intreg, pozitiv
Output: un obiect de tip Numar
'''
self.__baza = baza
if (stNumber.get_valoare() == '0' or ndNumber.get_valoare() == '0'):
return Numar('0', self.__baza)
intermediaryResult_value = ''
finalResult_value = ''
carryDigit = 0
numberOfDigits_stNumber = len(stNumber.get_valoare())
numberOfDigits_ndNumber = len(ndNumber.get_valoare())
firstNumber = stNumber.get_valoare()
secondNumber = ndNumber.get_valoare()
for index_SecondNumber in range(numberOfDigits_ndNumber - 1, -1, -1):
for index_FirstNumber in range(numberOfDigits_stNumber - 1, -1,
-1):
# Convert rightmost digits to decimal
digit_stNumber = character_to_decimal[
firstNumber[index_FirstNumber]]
digit_ndNumber = character_to_decimal[
secondNumber[index_SecondNumber]]
result_Multplication = digit_stNumber * digit_ndNumber + carryDigit
digit_result = result_Multplication % self.__baza
carryDigit = result_Multplication // self.__baza
character_result = decimal_to_character[
digit_result] # Digit to character
intermediaryResult_value = character_result + intermediaryResult_value
# Check for carry digit
if carryDigit != 0:
character_result = decimal_to_character[
carryDigit] # Digit to character
intermediaryResult_value = character_result + intermediaryResult_value
carryDigit = 0
if numberOfDigits_ndNumber >= 2: # Multidigit Multiplication, then add an extra zero to the end of the final result
intermediaryResult_value = intermediaryResult_value + (
numberOfDigits_ndNumber - index_SecondNumber - 1) * '0'
# Perform a simple addition between the final result and the intermediary result
dummy_FirstNumber = Numar(finalResult_value, self.__baza)
dummy_SecondNumber = Numar(intermediaryResult_value, self.__baza)
dummy_ResultNumber = self.add(dummy_FirstNumber,
dummy_SecondNumber, self.__baza)
finalResult_value = dummy_ResultNumber.get_valoare(
) # Update the final result
# Update the intermediary result
intermediaryResult_value = ''
return Numar(finalResult_value, self.__baza)
def __test_repo_multiply(self):
'''
Functie de tip test care verifica daca inmultirea a doua numere intr-o anumita baza a fost realizata cu succes
'''
repo = Repo()
numarA = Numar('120', 6)
numarB = Numar('2', 6)
rezultat = repo.multiply(numarA, numarB, 6)
assert rezultat.get_valoare() == '240'
assert rezultat.get_baza() == 6
numarA = Numar('120', 6)
numarB = Numar('3', 6)
rezultat = repo.multiply(numarA, numarB, 6)
assert rezultat.get_valoare() == '400'
numarA = Numar('52', 16)
numarB = Numar('3', 16)
rezultat = repo.multiply(numarA, numarB, 16)
assert rezultat.get_valoare() == 'F6'
numarA = Numar('57', 16)
numarB = Numar('7', 16)
rezultat = repo.multiply(numarA, numarB, 16)
assert rezultat.get_valoare() == '261'
numarA = Numar('130', 10)
numarB = Numar('0', 10)
rezultat = repo.multiply(numarA, numarB, 10)
assert rezultat.get_valoare() == '0'
numarA = Numar('10', 10)
numarB = Numar('10', 10)
rezultat = repo.multiply(numarA, numarB, 10)
assert rezultat.get_valoare() == '100'
numarA = Numar('34', 5)
numarB = Numar('12', 5)
rezultat = repo.multiply(numarA, numarB, 5)
assert rezultat.get_valoare() == '1013'
numarA = Numar('1010', 2)
numarB = Numar('11101', 2)
rezultat = repo.multiply(numarA, numarB, 2)
assert rezultat.get_valoare() == '100100010'
def __test_repo_divide(self):
'''
Functie de tip test care verifica daca impartirea a doua numere intr-o anumita baza a fost realizata cu succes
'''
repo = Repo()
numarA = Numar('243', 5)
numarB = Numar('3', 5)
cat, rest = repo.divide(numarA, numarB, 5)
assert cat.get_valoare() == '44'
assert cat.get_baza() == 5
assert rest.get_valoare() == '1'
assert rest.get_baza() == 5
numarA = Numar('8140', 10)
numarB = Numar('3', 10)
cat, rest = repo.divide(numarA, numarB, 10)
assert cat.get_valoare() == '2713'
assert cat.get_baza() == 10
assert rest.get_valoare() == '1'
assert rest.get_baza() == 10
numarA = Numar('A5', 16)
numarB = Numar('D', 16)
cat, rest = repo.divide(numarA, numarB, 16)
assert cat.get_valoare() == 'C'
assert cat.get_baza() == 16
assert rest.get_valoare() == '9'
assert rest.get_baza() == 16
numberA = Numar('100', 10)
numberB = Numar('10', 10)
quotient, remainder = repo.divide(numberA, numberB, 10)
assert quotient.get_valoare() == '10'
assert quotient.get_baza() == 10
assert remainder.get_valoare() == '0'
assert remainder.get_baza() == 10
numberA = Numar('325', 10)
numberB = Numar('17', 10)
quotient, remainder = repo.divide(numberA, numberB, 10)
assert quotient.get_valoare() == '19'
assert remainder.get_valoare() == '2'
numberA = Numar('1111', 2)
numberB = Numar('100', 2)
quotient, remainder = repo.divide(numberA, numberB, 2)
assert quotient.get_valoare() == '11'
assert quotient.get_baza() == 2
assert remainder.get_valoare() == '11'
assert remainder.get_baza() == 2