def makeFuzzyProbabilisticFunction(possibleDataBaseValues, patternSet, targetSet):
fpfX = []
possibleDataBaseValuesDataFrame = pd.DataFrame(possibleDataBaseValues).T
#print("df",possibleDataBaseValuesDataFrame)
possibleDataBaseValuesDataFrame.columns = patternSet.axes[1]
#print("ndf",possibleDataBaseValuesDataFrame)
for label in possibleDataBaseValuesDataFrame.axes[1]:
labelFPF = []
if(type(possibleDataBaseValuesDataFrame[label].values[0]) != list):
for val in possibleDataBaseValuesDataFrame[label].values:
args = Arguments.Arguments()
args.fitX(label,val,patternSet,targetSet)
labelFPF.append( args )
fpfX.append(labelFPF)
else:
for val in possibleDataBaseValuesDataFrame[label].values[0]:
args = Arguments.Arguments()
args.fitX(label,val,patternSet,targetSet)
labelFPF.append( args )
fpfX.append(labelFPF)
#print("makeFPF",fpf)
fpfY = Arguments.Arguments()
fpfY.fitY(targetSet)
return (fpfX,fpfY)
def main():
archivo_coordenadas = Arguments().getArgs()
csv_reader = csv.reader(archivo_coordenadas, delimiter=',')
p_list = [[float(i[0]), float(i[1])] for i in list(csv_reader)]
xmin = get_minimo(p_list, 0, len(p_list) - 1, 0)
ymin = get_minimo(p_list, 0, len(p_list) - 1, 1)
xmax = get_maximo(p_list, 0, len(p_list) - 1, 0)
ymax = get_maximo(p_list, 0, len(p_list) - 1, 1)
print('[', xmin, ymin, xmax, ymax, ']')
# Impresion de resultados en forma grafica
Xsq = [xmin, xmin, xmax, xmax, xmin]
Ysq = [ymin, ymax, ymax, ymin, ymin]
ft_list = np.array(p_list)
fig, ax = plt.subplots()
ax.plot(Xsq, Ysq)
ax.plot(ft_list[:, 0], ft_list[:, 1])
fig.suptitle('Algoritmo Caso 2')
plt.show()
return
def main():
archivo_coordenadas = Arguments().getArgs()
csv_reader = csv.reader(archivo_coordenadas, delimiter=',')
p_list = list(csv_reader)
[xmin, ymin, xmax, ymax] = getMbr(p_list)
print(xmin, ymin, xmax, ymax)
return
def main():
args = Arguments.SetupArguments()
PrintArgs(args)
if not os.path.exists(args.resultsDir):
os.makedirs(args.resultsDir)
if not os.path.exists(args.resultsDir):
os.makedirs(args.resultsDir)
pSystem = System.SingleImageSystem(args)
pTrainData = DataHandler.SingleImageDataset("TrainSingleImage", args)
pEvalData = DataHandler.SingleImageDataset("TrainSingleImage", args)
pSystem.StartTraining(pTrainData, pEvalData)
if mnemonic in MnemonicsList.pseudoInstructionsList:
print("--Pseudoinstruction found: ", mnemonic)
if mnemonic in MnemonicsList.mnemonicsList:
addressString = str(hex(address)[2:])
addressString = addressString.zfill(2)
address = address + 1
destLineCounter = destLineCounter + 1
opcode = MnemonicsList.opcodeDictionary(mnemonic)
#Register
if mnemonic in MnemonicsList.RtypeList:
riTypeAuxOpcode = MnemonicsList.extractAuxOpcode(mnemonic)
regSource1 = Arguments.extractRegister(arg1)
regSource2 = Arguments.extractRegister(arg2)
regDestination = regSource1
immediate = 0
aluCode = MnemonicsList.extractAluCode(mnemonic)
binaryInstruction = riTypeAuxOpcode + regSource2 + regSource1 + aluCode + regDestination + opcode
#Immediate
elif mnemonic in MnemonicsList.ItypeList:
regSource1 = Arguments.extractRegister(arg1)
regSource2 = 0
regDestination = regSource1
aluCode = MnemonicsList.extractAluCode(mnemonic)
riTypeAuxOpcode = MnemonicsList.extractAuxOpcode(mnemonic)
if mnemonic in MnemonicsList.ShiftImmediateList:
shiftAmount = Arguments.extract5BitShift(arg2)
import json
import Formatter
import Config
import Arguments
import Logger
args = Arguments.Parse()
cfg = Config.Get()
@Formatter.Register("json")
def json_formatter(components):
""" Formats the component list as JSON """
columns = cfg['columns']
newList = [
] # New list of only dictionaries with column attributes to marshall
for component in components:
newComp = {}
for column in columns:
try:
newComp[column] = component[column]
except:
newComp[column] = cfg['emptyValue']
newList.append(newComp)
result = json.dumps(newList)
def __init__(self): self.parser = Arguments.Arguments()
import sys
sys.path.insert(0, '../')
sys.path.append('./')
import Arguments
import CustomErrors
arguments = Arguments.Arguments()
def test1():
arguments.parseCommandString("search")
name = arguments.getStringArgument("name")
if name == "search" and len(arguments.arguments) == 1:
print "No1 OK"
else:
print "No1 Failed"
print arguments.arguments
def test2():
arguments.parseCommandString("search")
try:
arguments.getIntegerArgument("index")
except CustomErrors.ArgumentNotFound:
if len(arguments.arguments) == 1:
print "No2 OK"
return
print "No2 Failed"
print arguments.arguments
from Arguments import *
import Constant as p
import matplotlib.pyplot as plt
import numpy as np
import csv
archivo_coordenadas = Arguments().getArgs()
csv_reader = csv.reader(archivo_coordenadas, delimiter=',')
xy_0 = csv_reader.__next__()
Xmin = float(xy_0[0])
Xmax = float(xy_0[0])
Ymin = float(xy_0[1])
Ymax = float(xy_0[1])
Xprnt = []
Yprnt = []
for row in csv_reader:
x = float(row[0])
y = float(row[1])
Xprnt.append(x)
Yprnt.append(y)
if x < Xmin:
Xmin = x
if x > Xmax:
Xmax = x
if y < Ymin:
from Arguments import *
from Huffman import *
from ComprimirYDescomprimir import *
import Constant as p
decode, archivo_frecuencia, archivo_entrada, archivo_salida = Arguments(
).getArgs()
"""Creamos un Huffman que lee el archivo de frecuencias y procesa los datos ingresados,
almacena dos diccionarios de codificiación y decodificacion """
huff = Huffman(archivo_frecuencia.name)
huff.procesarHuffman()
#Dependiendo de lo ingresado en teclado, llamará a la funcion codificar o decodificar
if not decode:
codificar(archivo_entrada.name, archivo_salida.name,
huff.getDicCodificar())
else:
decodificar(archivo_entrada.name, archivo_salida.name,
huff.getDicDecodificar())