def test_for_checking_location(self):
"""
Test checks location of iterator.
iterator_list_first is the list
iterator_list_second is the secons list
"""
iterator_list_first = iter(it.Iterator(4))
iterator_list_second = iter(it.Iterator(4))
self.assertNotEqual(iterator_list_first, iterator_list_second)
def convert_extenso(extenso):
global newToken, auxToken
extensoQuebrado = extenso.lower().split(" ")
if len(extensoQuebrado) == 1 and simplifica(extensoQuebrado[0]) in und:
return extenso
nums = []
it = Iterator()
it.load(extensoQuebrado)
while (it.has_next()):
token = simplifica(it.get_token())
tokenAnterior = simplifica(it.get_token(-1))
if (token in und):
if (it.get_count() == 0):
nums.append(und[token])
else:
newToken = und[token] * int(nums[-1])
nums[-1] = newToken
else:
if (token in num):
auxToken = num[token]
elif (token not in und):
auxToken = extensoUnit(token)
if ((tokenAnterior not in und) and it.get_count() > 0):
newToken = int(auxToken) + int(nums[-1])
nums[-1] = newToken
else:
nums.append(auxToken)
return soma(nums)
def test_for_string_index(self):
"""
Checks for string error
"""
iterator_fisrt_index = it.Iterator("ULZ")
self.assertRaises(TypeError, iterator_fisrt_index)
def simplificar_sentenca(self, lista):
'''Simplifica a sentença para que possa evitar a ditalogia.
Como por exemplo a troca de uma palavra no plural para singular.
'''
lista_simplificada = list(lista)
it = Iterator()
it.load(lista_simplificada)
num = False
while (it.has_next()):
tag = it.get_ticket()
try:
num_romano = roman_to_int(it.get_word().encode('utf-8'))
if it.get_prev_ticket()[-2:] == "-F":
lista_simplificada[it.get_count()] = [
num_romano + "ª".decode('utf-8'), 'NUM-R'
]
else:
lista_simplificada[it.get_count()] = [
num_romano + "º".decode('utf-8'), 'NUM-R'
]
except:
pass
if tag == "NUM":
num = True
if tag != "NPR-P" and (tag[-2:] == "-P" or tag[-2:]
== "_P") and self.verificar_excecao_plural(
it.get_word()):
singular = self.analisar_plural(it.get_word())
lista_simplificada[it.get_count()][0] = singular
if num:
try:
lista_simplificada = self.converter_extenso(lista_simplificada)
except:
pass
return lista_simplificada
return self.__list__.getLast()
def __len__(self):
return len(self.__list__)
def toArray(self):
return self.__list__.toArray()
if __name__ == '__main__':
deque = Deque()
deque.addFirst(1)
deque.addFirst(2)
deque.addFirst(3)
deque.addLast(4)
deque.addLast(5)
iterator = Iterator.Iterator(deque)
while iterator.hasNext():
print(iterator.next())
deque.removeFirst()
deque.removeLast()
iterator = Iterator.Iterator(deque)
while iterator.hasNext():
print(iterator.next())
def createIterator(self):
return Iterator.NullIterator()
def createIterator(self):
if self.iterator is None:
self.iterator = Iterator.CompositeIterator(
Iterator.ListIterator(self.menu_components))
return self.iterator
# Array to hold predicted values of Temperature
predictedTemp = np.zeros((no_points, Temp_truth.shape[1],
Temp_truth.shape[2], Temp_truth.shape[3]))
predictedTemp[:, :, :, :] = np.nan # ensure any 'unforecastable' points display as NaNs
# Array to hold de-normalised outputs from model, i.e. DeltaTemp (before applying any AB-timestepping methods)
predictedDelT = np.zeros((no_points, Temp_truth.shape[1],
Temp_truth.shape[2], Temp_truth.shape[3]))
predictedDelT[:, :, :, :] = np.nan # ensure any 'unforecastable' points display as NaNs
for t in range(no_points):
print(t)
predT_temp, predDelT_temp, dummy, dummy, dummy = it.iterator(
data_name,
run_vars,
model,
1,
ds.isel(T=slice(t * skip_rate, t * skip_rate + 2)),
density[t * skip_rate:t * skip_rate + 2, :, :, :],
method='AB1')
# Note iterator returns the initial condition plus the number of iterations, so skip time slice 0
predictedTemp[t, :, :, :] = predT_temp[1, :, :, :]
predictedDelT[t, :, :, :] = predDelT_temp[1, :, :, :]
#Save as arrays
np.savez(pred_filename, np.array(predictedTemp), np.array(predictedDelT))
# Load in arrays of predictions
predicted_data = np.load(pred_filename)
predictedTemp = predicted_data['arr_0']
predictedDelT = predicted_data['arr_1']
def get_iter(self):
expr1 = self.get_expression()
tok = self.lex.get_next_token()
self.match(tok, TokenType.ITER_TOK)
expr2 = self.get_expression()
return Iterator.Iterator(expr1, expr2)
def __init__(self, prodType:ProductTypeEnum):
self.iterator = Iterator.ConcreteIterator(self, prodType)
def test_for_len_of_itterator(self):
"""
Test checks the size of fibonacci list
"""
self.assertEqual(len(list(it.Iterator(4))), 4)
def test_True_for_iteration(self):
"""
Test checks Trues of i
"""
self.assertTrue(it.Iterator(4))
def test_check_equality_of_list_iterator(self):
"""
Tests checks equality of the list fibonacci
"""
self.assertListEqual(list(it.Iterator(4)), list(it.Iterator(4)))
def test_full_list_of_iterator(self):
"""
Test checks full list of fibonacci
"""
self.assertEqual(list(it.Iterator(4)), [0, 1, 2, 3])
def aplicar_regras_morfo(self, lista, sint=False):
'''Aplica regras morfológicas na lista de tuplas.
'''
self.lista = list(lista) # Nova cópia da lista morfológica
self.lista_corrigida = [
] # Lista morfológica após a aplicação das regras
it = Iterator()
it.load(self.lista)
while (it.has_next()):
for morpho in self.__root.findall('morphological'):
self.has_rule = False # Boolean caso encontre encontre regra compativel
for rule in morpho.findall('rule'):
# Verifica se a regra está ativa e se o nome da regra, ou o ínicio, é igual a tag de classificação do token atual
if rule.find('active').text == "true" and rule.get(
'name').split("_")[0] == it.get_ticket():
count = int(rule.find('count').text)
self.lista_iteracoes = [
] # Lista que conterá todas tuplas referentes a quantidade de classes da regra
# Obtém o intervalo de tuplas de acordo com o número de classes da regra
try:
self.lista_iteracoes = it.get_interval(count)
#print '# LISTA DA ITERAÇÂO: '
#print self.lista_iteracoes
except:
continue
# Gera o nome da regra do intervalo de tuplas e verifica se é igual ao nome da regra em si
self.nome_regra = self.gerar_nome_regra(
self.lista_iteracoes)
if rule.get('name') == self.nome_regra:
self.has_rule = True
self.count_iteracao_regra = -1
#print "REGRA MORFOLÓGICA ENCONTRADA: " + rule.get('name')
self.lista_iteracao_regra = [
] # Lista temporária | Insere tokens após a aplicação das regras
for classe in rule.iter(
'class'): # for nas tags class
action = classe.find('action')
newprop = classe.find('newprop')
newtoken = classe.find('newtoken')
newtokenpos = classe.find('newtokenpos')
specific = classe.find('specific')
self.count_iteracao_regra += 1
tupla = self.lista_iteracoes[
self.count_iteracao_regra]
if specific is not None:
result_specific = self.__especificos[
specific.text](tupla[0])
if result_specific is False:
#print "REGRA MORFOLÓGICA " + rule.get('name') + " INVÁLIDA. PROCURANDO OUTRA..."
self.has_rule = False
break
if action is not None:
action_text = action.text
if action_text == "remove":
self.lista_iteracao_regra.append(None)
continue
elif action_text == "invert":
self.lista_iteracao_regra.reverse()
elif action_text in self.__acoes:
result_action = self.__acoes[
action_text](tupla[0]).lower()
self.lista_iteracao_regra.append(
[result_action, tupla[1]])
else:
self.lista_iteracao_regra.append(tupla)
if newprop is not None:
self.lista_iteracao_regra[
self.
count_iteracao_regra][1] = newprop.text
if newtoken is not None:
if newtokenpos.text == "next":
self.lista_iteracao_regra.append(
[newtoken.text.lower(), "NTK"])
elif newtokenpos.text == "previous":
self.lista_iteracao_regra.append(
self.lista_iteracao_regra[-1])
self.lista_iteracao_regra[-2] = [
newtoken.text.lower(), "NTK"
]
elif newtokenpos.text == "end":
print("TODO")
if self.has_rule:
it.skip(count - 1)
self.lista_corrigida.extend(
self.lista_iteracao_regra)
break
if self.has_rule is False:
#print 'NÃO ACHOU REGRA - ' + it.get_word().encode('utf-8')
self.lista_corrigida.append(it.get_token(
)) #se nao achou regra, entao adiciona a tupla original
if sint:
return self.lista_corrigida
return [_f for _f in self.lista_corrigida if _f]
def MultipleWindows(Files, OperatorSet=None, Windows=False, SliceProject=1):
"""
Attain multiple windows for different applied operators.
Data other than mesh are plotted individually as well.
"""
if Windows is False:
It.Iterator(Files, OperatorSet)
if Windows is True:
Pa.PathCreator() # Creates necessary folders.
Count = 1
# Load the plots without operators.
for item in Files:
Vi.SetActiveWindow(Count) # Select window to be worked in.
Image = Mk.MakeImages([item])
Image.Plot()
Image.Save()
Vi.ToggleLockViewMode() # Lock the view perspective.
Vi.AddWindow() # Add another window for next iteration.
Count += 1
try:
# Display plots with operators if defined.
for item in OperatorSet:
Vi.SetActiveWindow(Count) # Select window to be worked in.
It.Iterator(Files, [item], SliceProject=0)
Vi.DrawPlots() # Draw plots with operator.
Wi.WindowSettings()
Vi.ToggleLockViewMode() # Lock the view perspective.
Vi.AddWindow() # Add another window for next iteration.
Count += 1
except Exception:
pass
# Last window is always empty.
Vi.SetActiveWindow(Count)
Vi.DeleteWindow() # Delete last window.
# Compensate for odd number of windows.
if (Count - 1) < 2:
Vi.SetWindowLayout(1)
elif (Count - 1) == 2:
Vi.SetWindowLayout(2)
elif 2 < (Count - 1) <= 4:
Vi.SetWindowLayout(4)
elif 4 < (Count - 1) <= 6:
Vi.SetWindowLayout(6)
elif 6 < (Count - 1) <= 8:
Vi.SetWindowLayout(8)
elif (Count - 1) == 9:
Vi.SetWindowLayout(9)
elif 9 > (Count - 1) <= 16:
print "Too many windows to view nicely."
else:
print "Too many windows for ViSit to Support."
# Alternate saving scheme for multiple windows is used.
i = 0
while os.path.exists("../Sessions/XML_Original/sampleMulti%s.session" %
i):
i += 1
Vi.SaveSession("../Sessions/XML_Original/sampleMulti%s.session" % i)
return data
def peek(self):
if self.isEmpty():
raise EmptyError
return self.__list__.getFirst()
def __len__(self):
return len(self.__list__)
def toArray(self):
return self.__list__.toArray()
if __name__ == '__main__':
queue = Queue()
queue.enQueue(1)
queue.enQueue(2)
queue.enQueue(3)
queue.enQueue(4)
queue.enQueue(5)
print(queue.peek())
print(queue.deQueue())
iterator = Iterator.Iterator(queue)
while iterator.hasNext():
print(iterator.next())
arr = []
x = self.__head__.next
while x != None and x != self.__tail__:
arr.append(x.data)
x = x.next
return arr
if __name__ == '__main__':
list = LinkedList()
list.add(1)
list.add(2)
list.add(3)
list.add(4)
list.add(5)
list.add(6)
list.get(3)
list.remove(3)
list.get(3)
list.unlinkFirst()
list.unlinkLast()
iterator = Iterator.Iterator(list)
while iterator.hasNext():
print(iterator.next())