#UNCalculator (c) 2020 is made by Brian Gonzalez. 
# UN Quantum Math. Under license of The Work, by William John Cox (c) 2020
#08/05/2020 Last update

# UN Working with a 16 base number system where the order is 0, 1, 2, 3, U, 4, 5, 6, N, 7,  8,  9,  S,  C,  X, and  W
#                                                   hexa 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,  A,  B,  C,  D,  E, and  F
#                                                   deca 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, and 15
import tkinter
import sys

class HexaCalculator():
	def __init__(self):
		#Hexa is Master
		#self.MASTER = [ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z"]
		self.deca   = [ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"]

		# Hexa will be modified depending on base
		#self.Hexa   = [ "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F"]     #HEXA
		#self.sigFig = 8																						#HEXA

		self.sigFig = 4																					#UN
		self.Hexa   = [ "0", "1", "2", "3", "U", "4", "5", "6", "N", "7", "8", "9", "S", "C", "X", "W"]    #UN
		
		#Create the main window
		self.main_window = tkinter.Tk()
		#self.main_window.title('Hexa Calculator (c) 2020')														  #HEXA
		self.main_window.title('UNBaseCalculator&Converter (c) 2020')                                                           #UN
		
		#frames for the window lay out
		#self.baseOption_frames = tkinter.Frame(self.main_window)													#HEXA
		self.radio_frames  = tkinter.Frame(self.main_window)#done
		self.entry_frames  = tkinter.Frame(self.main_window,   height=500,width=2000, )
		self.answer_frames = tkinter.Frame(self.main_window)
		self.base10_frames = tkinter.Frame(self.main_window)
		self.quit_frames   = tkinter.Frame(self.main_window)#done

		#Base Option #HEXA BASEOPTIONS
		#self.baseOption_Label =tkinter.Label(self.baseOption_frames,text= "Bases 2 to 36: ")
		#self.baseOption_Entry = tkinter.Entry(self.baseOption_frames,width= 4)
		#self.baseOption_Entry.insert(0, '16')
		#self.baseOption_Label.pack(side="left")
		#self.baseOption_Entry.pack(side="left")

		#radio buttons
		self.radio_var = tkinter.IntVar()
		self.radio_var.set(1)

		self.radio_add  = tkinter.Radiobutton(self.radio_frames, text = "Add", variable = self.radio_var, value =1)
		self.radio_sub  = tkinter.Radiobutton(self.radio_frames, text = "Subtract", variable = self.radio_var, value =2)
		self.radio_mul  = tkinter.Radiobutton(self.radio_frames, text = "Multiply", variable = self.radio_var, value =3)
		self.radio_div  = tkinter.Radiobutton(self.radio_frames, text = "Divide", variable = self.radio_var, value =4)
		self.radio_pow  = tkinter.Radiobutton(self.radio_frames, text = "Power", variable = self.radio_var, value=5)		
		self.radio_root = tkinter.Radiobutton(self.radio_frames, text = "Root", variable = self.radio_var, value=6)			

		self.radio_add.pack()
		self.radio_sub.pack()
		self.radio_mul.pack()
		self.radio_div.pack()
		self.radio_pow.pack()																							
		self.radio_root.pack()																							
		#radio buttons end

		#Entry Widget
			#Left
		self.leftEntry_frames  = tkinter.Frame(self.entry_frames)

		self.entry1_Base10 = tkinter.StringVar()
		self.entry1_Base10_label =tkinter.Label(self.leftEntry_frames,textvariable=self.entry1_Base10)
		self.entry1_Base10_label.pack(side='top')

		self.entry1 = tkinter.Entry(self.leftEntry_frames, width= 20)
		self.entry1.pack(side='bottom')
		self.leftEntry_frames.pack(side='left')

			#Right
		self.rightEntry_frames  = tkinter.Frame(self.entry_frames)

		self.entry2_Base10 = tkinter.StringVar()
		self.entry2_Base10_label =tkinter.Label(self.rightEntry_frames,textvariable=self.entry2_Base10)
		self.entry2_Base10_label.pack(side='top')

		self.entry2 = tkinter.Entry(self.rightEntry_frames, width= 20)
		self.entry2.pack(side='bottom')


		self.rightEntry_frames.pack(side = "left")
			
			#clear
		self.clear_button = tkinter.Button(self.entry_frames, text = "Clear",command = self.clear)
		self.clear_button.pack( side = 'right')
		
		
		
		#Entry Widget end

		#quitButton
		self.quit_button = tkinter.Button(self.quit_frames, text = 'Quit', command =self.main_window.destroy)
		self.wjc_label = tkinter.Label(self.quit_frames, text=" By license of The Work (c) William John Cox")#UN
		#self.BNG_label = tkinter.Label(self.quit_frames, text="Hexa Calculator (c) 2020 created by Brian N. Gonzalez")				#HEXA
		self.quit_button.pack()
		#self.BNG_label.pack(side = 'bottom')																				#HEXA
		self.wjc_label.pack(side = 'bottom')																				#UN
		#quitButton end

		#Calculate Button
		self.calc_button = tkinter.Button(self.answer_frames, text = "Calculate",command = self.calculate)
		self.convert_button = tkinter.Button(self.answer_frames, text = "Calculate From Base 10",command = self.convertFromBase10ToBase)
		
		self.calc_button.pack()
		self.convert_button.pack()
		#Calculate Button end

		#Answer and Answer Label
		self.answer = tkinter.StringVar()
		self.answer_label =tkinter.Label(self.answer_frames,textvariable=self.answer)
		self.answer_label.pack()
		#Answer and AnswerLabel end
		
		#Base 10 framework
		#label for base 10
		self.base10_label = tkinter.Label(self.base10_frames, text = "Base 10:  ")
		#radio buttons for on and off
		self.radio_base10 = tkinter.IntVar()
		self.radio_base10.set(1)
		self.radio_on = tkinter.Radiobutton(self.base10_frames, text = "On", variable = self.radio_base10 , value =1)
		self.radio_off = tkinter.Radiobutton(self.base10_frames, text = "Off", variable = self.radio_base10 , value =2)
		#label for base10 answer
		self.base10answer = tkinter.StringVar()
		self.base10answer_label =tkinter.Label(self.base10_frames,textvariable=self.base10answer)


		#Pack 'em
		self.base10_label.pack(side = "left")
		self.radio_on.pack(side = "left")
		self.radio_off.pack(side = "left")
		self.base10answer_label.pack(side="left")


		#base10 framework end
		#self.baseOption_frames.pack()															#HEXA
		self.radio_frames.pack()
		self.entry_frames.pack()
		self.answer_frames.pack()
		self.base10_frames.pack()
		self.quit_frames.pack()
		#Runs an infinite loop until the window is closed
		tkinter.mainloop()

	#does the calculation of the entities when the button is pressed

	def convertFromBase10ToBase(self):


		num1 = self.entry1.get().strip()
		validChar1 = self.isValidChar(num1,self.deca)

		

		num2 = self.entry2.get().strip()
		validChar2 = self.isValidChar(num2,self.deca)

		if not validChar1 or not validChar2:
			self.answer.set("INVALID CHARACTER")
		#Charaters passed the test, Yay
		else:
			#self.convertDeciToBase

			sameList = self.sameLengthAfterDot(num1, num2)
			holdNum1 =  sameList[0]
			holdNum2 =  sameList[1]


			dotIndex1 = holdNum1.find('.')
			dotIndex2 = holdNum2.find('.')

			preDot1 = holdNum1[:dotIndex1]
			if preDot1 =='':
				preDot1 ='0'
			preDot1 = int(preDot1)
			preDot1 = self.convertDeciToBase(preDot1)

			postDot1=holdNum1[dotIndex1:]
			postDot1 = float(postDot1)
			postDot1 = self.convertDeciToBase2(postDot1)

			preDot2 = holdNum2[:dotIndex2] 
			if preDot2 =='':
				preDot2 ='0'
			preDot2 = int(preDot2)
			preDot2 = self.convertDeciToBase(preDot2)

			postDot2= holdNum2[dotIndex2:]
			postDot2 = float(postDot2)
			postDot2 = self.convertDeciToBase2(postDot2)

			combine1 = preDot1 +'.'+postDot1
			combine2 = preDot2 +'.'+ postDot2

			self.clear()
			self.entry1. insert(0, combine1)
			self.entry2. insert(0, combine2)

			self.calculate()


	def calculate(self):
		self.answer.set(" ")

		#self.BaseOptions()																	#HEXA
		

		num1 = self.entry1.get().strip()
		validChar1 = self.isValidChar(num1,self.Hexa)

		num2 = self.entry2.get().strip()
		validChar2 = self.isValidChar(num2,self.Hexa)

		if not validChar1 or not validChar2:
			self.answer.set("INVALID CHARACTER")
		#Charaters passed the test, Yay
		else:
			#self.answer.set("VALID CHARACTER!!!!!!!!!!") #keep incase u need to check
			
			#prepare num1 and num2 for addition by making sure they have the same number of characters after 0
			add1 =num1
			add2 =num2


			#What operation should we do?
			#Addition
			self.answer.set('')
			if   self.radio_var.get() ==1:
				self.answer.set(self.add( add1, add2))

			#Subtraction
			elif self.radio_var.get() ==2:
				self.answer.set(self.sub( add1, add2))

			#Multiply
			elif self.radio_var.get() ==3:
				self.answer.set(self.mul( add1, add2))

			#Divide
			elif self.radio_var.get() ==4:
				self.answer.set(self.div(add1,add2))
			#Power 
			elif self.radio_var.get() ==5:									

				self.answer.set(self.pow(add1,add2))
			#Root
			elif self.radio_var.get() ==6:
				self.answer.set(self.root(add1,add2))

			#Impossible to get to... but just in case
			else:
				self.answer.set("Contact Brian Gonzalez")

			#Show base 10:
			#On
			if self.radio_base10.get() == 1:
				checkkkkkk = self.answer.get()
				if self.isValidChar(self.answer.get(),self.Hexa):
					convert = self.convertBaseToDeci3(self.answer.get())
					convert = str(convert)
					convert = self.truncateAfterDot(convert)
					self.base10answer.set(convert)
				else:
					self.base10answer.set("")

				if self.isValidChar(num1,self.Hexa):
					convert = self.convertBaseToDeci3(num1)
					convert = str(convert)
					convert = self.truncateAfterDot(convert)
					self.entry1_Base10.set(convert)
				else:
					self.entry1_Base10.set("")

				if self.isValidChar(num2,self.Hexa):
					convert = self.convertBaseToDeci3(num2)
					convert = str(convert)
					convert = self.truncateAfterDot(convert)
					self.entry2_Base10.set(convert)
				else:
					self.entry2_Base10.set("")
			#off
			else:
				self.base10answer.set("")
				self.entry1_Base10.set("")
				self.entry2_Base10.set("")








#All Math Operations Take In Strings

	def add(self,num1, num2):
		sameList = self.sameLengthAfterDot(num1, num2)
		holdNum1 =  sameList[0]
		holdNum2 =  sameList[1]






		dotIndex1 = holdNum1.find('.')
		dotIndex2 = holdNum2.find('.')

		noDot1= holdNum1[:dotIndex1] + holdNum1[dotIndex1 + 1:]
		noDot2= holdNum2[:dotIndex2] + holdNum2[dotIndex2 + 1:]

		#Send String, return int base 10
		noDot1 = self.convertBaseToDeci(noDot1)
		noDot2 = self.convertBaseToDeci(noDot2)

		#From the end how many char's till you reach the point
		reverseDot = len(holdNum1)-1 - dotIndex1

		total = noDot1 + noDot2
		if total == 0:
			return '0'


		#now convert your total "whole" number back to hexa
		total = self.convertDeciToBase(total)
		negative = False
		if total[0] is '-':
			total = total[1:]
			negative = True
		while len(total)-reverseDot <0:
			total = '0' + total
		total = total[:len(total)-reverseDot] + '.' + total[len(total)-reverseDot:]
		if total == '.':
			return '0'
		if negative:
			total = '-' +total
		return total

	def sub(self, num1, num2):
		if num2[0]=='-':
			num2=num2[1:]
		else:
			num2 = '-' + num2
		return self.add(num1,num2)

	def mul(self, num1, num2):
		sameList = self.sameLengthAfterDot(num1, num2)
		holdNum1 =  sameList[0]
		holdNum2 =  sameList[1]

		num1Neg =False
		if holdNum1[0] == '-':
			num1Neg = True
			holdNum1 = holdNum1[1:]
		
		num2Neg = False
		if holdNum2[0] == '-':
			num2Neg = True
			holdNum2 = holdNum2[1:]

		#Temporarily remove dots
		dotIndex1 = holdNum1.find('.')
		dotIndex2 = holdNum2.find('.')

		noDot1= holdNum1[:dotIndex1] + holdNum1[dotIndex1 + 1:]
		noDot2= holdNum2[:dotIndex2] + holdNum2[dotIndex2 + 1:]

		#Send String, return int base 10
		noDot1 = self.convertBaseToDeci(noDot1)
		noDot2 = self.convertBaseToDeci(noDot2)

		#From the end how many char's till you reach the point
		reverseDot = (len(holdNum1)-1 - dotIndex1 )*2

		total = noDot1 * noDot2
		total = self.convertDeciToBase(total)

		#small numbers, needs more 0's
		while len(total) < reverseDot + 1:
			total = '0' + total
		total = total[:len(total)-reverseDot] + '.' + total[len(total)-reverseDot:]
		if total == '.':
			return '0'
		if num1Neg ^ num2Neg:
			total = '-' + total

		#Remove extra 0's
		dotIndex = total.find(".")+2
		while(total[len(total)-1] == '0')and len(total)>dotIndex:
			total = total[:len(total)-1]
		
		return total

	def div(self, num1, num2):
		base = len(self.Hexa)
		sameList = self.sameLengthAfterDot(num1, num2)
		holdNum1 =  sameList[0]
		holdNum2 =  sameList[1]

		num1Neg =False
		if holdNum1[0] == '-':
			num1Neg = True
			holdNum1 = holdNum1[1:]
		
		num2Neg = False
		if holdNum2[0] == '-':
			num2Neg = True
			holdNum2 = holdNum2[1:]

		#Temporarily remove dots
		dotIndex1 = holdNum1.find('.')
		dotIndex2 = holdNum2.find('.')

		noDot1= holdNum1[:dotIndex1] + holdNum1[dotIndex1 + 1:]
		noDot2= holdNum2[:dotIndex2] + holdNum2[dotIndex2 + 1:]

		#Send String, return int base 10
		noDot1 = self.convertBaseToDeci(noDot1)
		noDot2 = self.convertBaseToDeci(noDot2)
		if noDot2 ==0:
			return "Calculator made by Brian Gonzalez"
		total =''
		
		#Big number(num1) / little number (num2)
		if noDot1 > noDot2:
			temp = noDot1//noDot2
			temp = self.convertDeciToBase(temp)
			total = temp
			remainder = noDot1%noDot2
			#If remainder is 0 then you're done, if not you have to do remainder division
			#almost the same as small/big
			if remainder != 0:
				biggerRemainder = remainder #
				_addZeroes =-1
				while biggerRemainder < noDot2:
					biggerRemainder = biggerRemainder *base
					_addZeroes=_addZeroes+1
				biggerRemainder = biggerRemainder *base**self.sigFig
				
				_temp = biggerRemainder// noDot2
				_temp = self.convertDeciToBase(_temp)
				total = total + '.'
				for i in range(_addZeroes):
					total = total+'0'
				total = total +_temp
			return (total)

		#Small number(num1) / Big number(num2) LESS THAN 1
		elif noDot2 > noDot1:
			total = "0."
			#Make noDot1 bigger to help deal with division (base's version of adding trailing 0's)
			biggerNoDot1 = noDot1 * base**self.sigFig
			temp = biggerNoDot1 // noDot2
			temp = self.convertDeciToBase(temp)
			while len(temp) < self.sigFig:
				temp = '0' + temp
			total = total + temp
			return (total)

		else: 
			return '1.0'
	
	def pow(self, num1, num2): ##############################################################################################################################
		sameList = self.sameLengthAfterDot("1", num2)
		holdNumOne =  sameList[0]
		holdNum2 =  sameList[1]
		if self.convertBaseToDeci3(holdNum2) == 0 :
			if self.convertBaseToDeci3(num1) == 0 :
				return "Calculator made by Brian Gonzalez"
			return "1.0"

		#Temporarily remove dots
		dotIndexOne = holdNumOne.find('.')
		dotIndex2 = holdNum2.find('.')

		noDotOne= holdNumOne[:dotIndexOne] + holdNumOne[dotIndexOne + 1:]
		noDot2= holdNum2[:dotIndex2] + holdNum2[dotIndex2 + 1:]

		#We need to know if num2 is negative
		num2Neg = False
		if noDot2[0] == '-':
			num2Neg = True
			noDot2 = noDot2[1:]

		numGCD = self.GCD(noDotOne, noDot2)
		
		if  numGCD !="1":
			holdNumOne = self.div(noDotOne, numGCD)
			holdNum2 = self.div(noDot2, numGCD)

		if num2Neg:
			holdNum2 = '-' + holdNum2

		return self.exponent(num1, holdNum2, holdNumOne)#(exponentBase,numerator,denominator)

		



	def root (self, num1, num2):###########################################################################################################################
		sameList = self.sameLengthAfterDot("1", num2)
		holdNumOne =  sameList[0]
		holdNum2 =  sameList[1]
		if self.convertBaseToDeci3(holdNum2) == 0 :
			return "Calculator made by Brian Gonzalez"

		#Temporarily remove dots
		dotIndexOne = holdNumOne.find('.')
		dotIndex2 = holdNum2.find('.')

		noDotOne= holdNumOne[:dotIndexOne] + holdNumOne[dotIndexOne + 1:]
		noDot2= holdNum2[:dotIndex2] + holdNum2[dotIndex2 + 1:]

		#We need to know if num2 is negative
		num2Neg = False
		if noDot2[0] == '-':
			num2Neg = True
			noDot2 = noDot2[1:]

		numGCD = self.GCD(noDotOne, noDot2)
		
		if  numGCD !="1":
			holdNumOne = self.div(holdNumOne, numGCD)
			holdNum2 = self.div(holdNum2, numGCD)

		#Add the negative to holdnumOne so that exponent only checks if numerator is negative.
		if num2Neg:
			holdNum2 = '-' + holdNumOne

		return self.exponent(num1, holdNumOne, holdNum2)#(exponentBase,numerator,denominator)




	def exponent(self, num1, numerator, denominator):##############################################################################################################################
		#Even roots cannot have negative base for exponent
		intDenominator = self.convertBaseToDeci3(denominator)
		if intDenominator %2 == 0 and num1[0] is '-':
			return "Calculator made by Brian Gonzalez"


		holdNum1 = num1
		
		# if numerator is negative then num1 becomes 1/num1
		if numerator[0] is '-':
			holdNum1 = self.div('1.0', holdNum1)
			num1 = holdNum1
			numerator=numerator[1:]
		intNumerator = self.convertBaseToDeci(numerator)

		#final answer will be negative if num1 is negative and numerator is odd
		returny =''
		if num1[0] is '-':
			if intNumerator %2 == 1:
				returny='-'
			num1 =num1[1:]


		#calculation time 
		#if num1 <1  root first then power
		if holdNum1[0] is '0':
			#root root first
			if intDenominator != 1:
				holdNum1 = self.rootWhole(holdNum1, denominator)
			
			#pow next
			for i in range(intNumerator-1):
				holdNum1 =self.mul(holdNum1,num1)


		#if num1 >= 0 power first then root 
		else:
			#pow first
			for i in range(intNumerator-1):
				holdNum1 =self.mul(holdNum1,num1)
			
			#root next
			if intDenominator != 1:
				holdNum1 = self.rootWhole(holdNum1, denominator)

		
		return returny+ holdNum1





	#takes in  a string for num1 and a int for num2 AND returns a string
	def rootWhole(self, num1, num2): #num1 is exponent base and num2 is the root
		holdNum1 = num1
		holdNum2 = num2
		intHoldNum1 = self.convertBaseToDeci3(holdNum1)
		intHoldNum2 = self.convertBaseToDeci3(holdNum2)

		current = holdNum1
		#if num1 is smaller than 1 start with one so that when you divide by two you get closer to the answer. 
		if num1[0] is '0':
			current = '1'
		remainder = current
		
		#Remainder insert is to help deal with the last digit when it is only left for approxs.
		remainderInsert ="0."
		for i in range(self.sigFig-1):
			remainderInsert = remainderInsert + '0'
		remainder100 = str(int(len(self.Hexa)/2))
		remainderInsert = remainderInsert + remainder100

		powCheck =  current #self.truncateLenBig(  self.pow(  current, holdNum2)   ) 
		
		# instead of self. pow use loop, stop when its too big
		for i in range (intHoldNum2-1):
			powCheck = self.mul(powCheck,current)
			#if you are bigger then what you want to be no point in getting bigger
			#if self.convertBaseToDeci3(powCheck) > intHoldNum1:
			subCheck = self.sub(holdNum1,powCheck)
			if subCheck[0] is '-': 
				break
		
		tPowCheck = self.truncateAfterDot(powCheck)
		tHoldNum1 = self.truncateAfterDot(holdNum1)
		nth =1
		zeroCheckEntry = False
		while tHoldNum1  != tPowCheck:
			lastRemainder = remainder
			remainder = self.div(remainder, "2.0")
			zeroCheck = self.sameLengthAfterDot(remainder, '0')
			
			if zeroCheck[0] == zeroCheck[1]:
				remainder = remainderInsert
				compareNum = '-'
				if zeroCheckEntry:
					break
				zeroCheckEntry = True
			
			compareNum = self.sub(holdNum1,powCheck)
			
			#(Power of num2) is bigger than HoldNum1  to  so we need to go Smaller
			if compareNum[0] is '-':
				current = self.sub(current ,remainder)

			#(Power of num2) is smaller than HoldNum1 so we need to go Bigger
			else:
				current = self.add(current, remainder)

			nth = nth +1
			powCheck = current #self.truncateLenBig(  self.pow(  current, holdNum2)   )

			for i in range (intHoldNum2-1):
				powCheck = self.mul(powCheck,current)
				#if you are bigger then what you want to be no point in getting bigger
				subCheck = self.sub(holdNum1,powCheck)
				if subCheck[0] is '-': 
					break

			tPowCheck = self.truncateAfterDot(powCheck)
			
			sameLenAfterDot = self.sameLengthAfterDot(tHoldNum1, tPowCheck)
			tHoldNum1 = sameLenAfterDot[0]
			tPowCheck = sameLenAfterDot[1]

		return current




	def GCD(self, num1, num2): ###########################################################################################################################
		holdNum1 = self.convertBaseToDeci3( num1)
		holdNum2 = self.convertBaseToDeci3( num2)
		print("GCD",holdNum1, holdNum2)
		bigNum=""
		smallNum=""
		prevModNum=""
		if holdNum1 == holdNum2:
			return num1
		if holdNum1 > holdNum2:
			bigNum=holdNum1
			smallNum = holdNum2
			prevModNum = holdNum2
		else:
			bigNum=holdNum2
			smallNum = holdNum1
			prevModNum = holdNum1

		quotient = bigNum//smallNum
		modulus = bigNum%smallNum

		while modulus != 0:
			prevModNum = modulus
			bigNum=smallNum
			smallNum = modulus

			quotient = bigNum//smallNum
			modulus = bigNum%smallNum
		
		prevModNum = self.convertDeciToBase( prevModNum )
		
		return prevModNum
			
	#Strings to Whole numbers only	
	def convertBaseToDeci(self, num):
		#Takes in num as a String and returns an int
		base = len(self.Hexa)
		power = 0
		neg = 1
		valuesList = list()
		#Converts Hexa into decimal and stores the digits value in valuesList
		for i in range (len(num)-1, -1, -1):
			value =-1
			upper = num[i].upper()
			if upper == '-':
				neg=-1
			else:
				for i in self.Hexa:
					value = value +1
					if i == upper:
						valuesList.append(value)
						break
	
		total = 0
		for i in range(0, len(valuesList)):
			total = total + (valuesList[i] * (base ** i) )

		return total*neg
	
	
	#strings to fractions smaller than one only
	def convertBaseToDeci2(self, num):
		base = len(self.Hexa)
		power = -1
		neg = 1
		valuesList = list()
		for i in range (0, len(num)):
			value =-1
			upper = num[i].upper()
			if upper == '-':
				neg=-1
			else:
				for i in self.Hexa:
					value = value +1
					if i == upper:
						valuesList.append(value)
						break
	
		total = 0
		power = -1
		for i in range(0, len(valuesList)):
			total = total + (valuesList[i] * (base ** power) )
			power = power -1
		return total*neg

	#takes a string for any number
	def convertBaseToDeci3(self, num):

		dotIndex1 = num.find('.')
		#wholeNunber
		if dotIndex1 < 0 :
			return self.convertBaseToDeci(num)
		#Fractional
		elif dotIndex1 ==0:
			return self.convertBaseToDeci2(num)
		#Whole and Fractional
		else:
			part1 = self.convertBaseToDeci(num[:dotIndex1])
			part2 = self.convertBaseToDeci2(num[dotIndex1 +1:])
			combine = part1+part2
			return combine


	#takes an int returns a string, for whole numbers only
	def convertDeciToBase(self, num):
		#Takes an Int and returns a String
		remainders =list()
		base = len(self.Hexa)
		quotient = num
		neg =1
		if quotient==0:
			return '0'
		if quotient <0:
			neg =-1
			quotient = quotient *-1

		while quotient !=0:
			remainders.append(quotient%base)
			quotient = quotient//base
		hexaString =''
		
		#going backwards because last digit added is least significant
		for i in range(len(remainders)-1, -1, -1):
			hexaString = hexaString + self.Hexa[remainders[i]]
					
		if neg <0:
			hexaString ='-' +hexaString
		return hexaString


	#takes float and returns string, For fraction numbers only
	def convertDeciToBase2(self, num):
		integerString = ""
		currentFraction = num
		loopCount =0
		if currentFraction == 0.0:
			return"0"
		while currentFraction != 0.0:
			if loopCount >=self.sigFig:
				break
			else:
				loopCount = loopCount +1
				currentAnswer = currentFraction *len(self.Hexa)
				currentAnswer = str(currentAnswer)

				dotIndex1 = currentAnswer.find('.')
				preDot1 =   int( currentAnswer[:dotIndex1] )
				postDot1= float( currentAnswer[dotIndex1:] )
				integerString = integerString + (self.Hexa[preDot1])
				currentFraction = postDot1
		return integerString


		






	def clear(self):
		self.entry1.delete(0, 'end')
		self.entry2.delete(0, 'end')


	def isValidChar(self, num, _list):
		holdNum = num
		negative = False
		whole = '0'
		fract = '0'

		if len(num) == 0:
			return False

		#Check if number is a negative and temporarily remove negative sign
		if holdNum.find('-') == 0:
			negative = True
			holdNum= holdNum[1:]
		#Find 'decimal point' 
		dotIndex = holdNum.find('.')
		
		#Pure whole Number
		if dotIndex == -1:
			return self.charCheck(holdNum,_list)
		#Has a decimal
		else:
			#Decimal Point is first character
			if dotIndex ==0:
				return self.charCheck(holdNum[1:],_list)
			#Check if all num characters pass before and after decimal point
			if self.charCheck(holdNum[:dotIndex],_list) and self.charCheck(holdNum[dotIndex + 1:],_list):
				return True
		#Num failed either before or after decimal
		return False


	def charCheck(self,num,_list):
		#go through each character and confirm it is the ones we are looking for. 
		for char in num:
			valid = False
			upperChar = char.upper()
			for hex in _list:
				if upperChar == hex:
					valid = True
			if not valid:
				return False
		return True

	def sameLengthAfterDot(self, num1, num2):
		add1 = num1.upper()
		dotIndex1 = add1.find('.')
		if(dotIndex1 == -1):
			add1 = add1 +'.0'
			dotIndex1 = add1.find('.')
		fractionLen1 = len(add1) - (dotIndex1 +1)

		add2=num2.upper()
		dotIndex2 = add2.find('.')
		if(dotIndex2 == -1):
			add2 = add2 +'.0'
			dotIndex2 = add2.find('.')
		fractionLen2 = len(add2) - (dotIndex2 +1)

		#FractionLen 1 has more characters after point so we will add 0 to match them
		if fractionLen1 > fractionLen2:
			zeroes = fractionLen1 - fractionLen2
			for i in range(0, zeroes):
				add2 = add2+'0'

		#FractionLen 2 has more characters after point so we will add 0 to match them
		elif fractionLen2 > fractionLen1:
			zeroes = fractionLen2 - fractionLen1
			for i in range(0, zeroes):
				add1 = add1+'0'

		return [add1,add2]

	#Takes in a string and an int and returns a string
	def truncateAfterDotSpecific(self, num1, length):
		holdNum1 = num1

		dotIndex1 = holdNum1.find('.')
		if dotIndex1 == -1:
			holdNum1 = holdNum1 +'.'
			for i in range(length+1):
				holdNum1 = holdNum1 +'0'
			return holdNum1

		numLen = len(holdNum1)
		truncNum = dotIndex1 + length+1
		if truncNum > numLen:
			return holdNum1

		return holdNum1[:truncNum]

	def truncateAfterDot(self, num1):
		holdNum1 = num1

		dotIndex1 = holdNum1.find('.')
		if dotIndex1 == -1:
			holdNum1 = holdNum1 +'.'
			for i in range(self.sigFig+1):
				holdNum1 = holdNum1 +'0'
			return holdNum1
	
		numLen = len(holdNum1)
		truncNum = dotIndex1 + self.sigFig+1
		if truncNum > numLen:
			return holdNum1

		return holdNum1[:truncNum]

	def truncateLenBig(self, num1):
		holdNum1 =num1

		if len(holdNum1) >50:
			return holdNum1[:50]
		return holdNum1


	def BaseOptions(self):																	#HEXA
		num = self.baseOption_Entry.get()

		#Correct numeric value, if invalid: num=36
		if not num.isnumeric() :
			num = 36
			self.baseOption_Entry.delete(0, 'end')
			self.baseOption_Entry.insert(0, '36')
		else: 
			num = int(num)
			if num <2 or num >36:
				num = 36
				self.baseOption_Entry.delete(0, 'end')
				self.baseOption_Entry.insert(0, '36')

		#Adjust hexa
		self.Hexa = []
		for i in range(num):
			self.Hexa.append(self.MASTER[i])





my_calculator = HexaCalculator()