def main():
#screenOne = screen.createScreen(500,500)
#draw.circle(edgeMatrix, 250, 250, 0, 50, .00001)
#matrix.drawEdges(screenOne, edgeMatrix, green)
# screen.display(screenOne)
screenOne = screen.createScreen(500, 500)
parser.parseFile('script3', screenOne, green, edgeMatrix, transformMatrix)
matrix.drawEdges(screenOne, edgeMatrix, green)
screen.display(screenOne)
def __init__(self):
parser.parseFile()
self.neuron = Neuron(self.inputCount())
self.neuron.randomize(-1.0, 1.0)
self.teachingStep = 0
self.prevResponse = 0
self.prevError = 0
self.curResponse = 0
self.curError = 0
def run(k):
# 1) Load data files
x_training = parseFile("../data/X_original.txt")
y_training = parseFile("../data/Y_original.txt")
x_testing = parseFile("../data/X_test.txt")
y_testing = parseFile("../data/Y_test.txt")
# 2) Get the maximums from the training data
# (for normalization of _all_ data)
x_maximums = maxColumns(x_training)
y_maximums = maxColumns(y_training)
# 3) Normalize data
x_training_normal = normalize(x_maximums, x_training)
y_training_normal = normalize(y_maximums, y_training)
x_testing_normal = normalize(x_maximums, x_testing)
y_testing_normal = normalize(y_maximums, y_testing)
# 4) Compute error for each row in the Training Data.
training_errors = []
for row_index in range(len(x_training_normal)):
# A) Get K nearest neighbor indexes for the row.
# When k = 1, we should just return the corresponding row index,
# since the error will be 0. We only do this for the training data, though.
if k == 1:
neighbors = [row_index]
else:
neighbors = kNearestNeighbors(k, x_training_normal[row_index], x_training_normal)
# B) Record the absolute value of the error.
training_errors.append( abs(y_training_normal[row_index][0] - averageNeighborOutput(neighbors, y_training_normal)) )
# 5) Get the MAE for the Training Data.
training_mae = sum(training_errors)/len(training_errors)
# 6) Get the R_MSE for the Training Data.
training_r_mse = sqrt(sum( [pow(error,2) for error in training_errors] )/len(training_errors))
# 7) Compute the error for each row of the Test Data.
testing_errors = []
for row_index in range(len(x_testing_normal)):
# A) Get K nearest neighbor indexes for the row.
neighbors = kNearestNeighbors(k, x_testing_normal[row_index], x_training_normal)
# B) Record the absolute value of the error.
testing_errors.append( abs( y_testing_normal[row_index][0] - averageNeighborOutput(neighbors, y_training_normal)) )
# 8) Get the MAE for the Testing Data.
testing_mae = sum(testing_errors)/len(testing_errors)
# 9) Get the R_MSE for the Testing Data.
testing_r_mse = sqrt(sum( [pow(error, 2) for error in testing_errors] )/len(testing_errors))
return (training_mae, training_r_mse, testing_mae, testing_r_mse)
def main():
parser = argparse.ArgumentParser(
description='Work with recipe markdown files')
parser.add_argument(
'-i',
metavar='mdfile',
type=argparse.FileType('r'),
help='name of the markdown file to process, default: use stdin',
default=sys.stdin)
parser.add_argument('-o',
metavar='output',
type=argparse.FileType('wb'),
help='name of the output file, default: use stdout',
default=sys.stdout.buffer)
parser.add_argument(
'-t',
metavar='outtype',
choices=['xml', 'json'],
help='output type to generate (xml, json), default: xml',
default='xml')
parser.add_argument(
'--xslt',
metavar='xslt',
help=
'xslt to reference in PI of generated XMLs, ignored if outtype is not "xml"',
default=None)
args = parser.parse_args()
recipes = parseFile(args.i)
if args.t == 'xml':
xs.dump(args.o, recipes, args.xslt)
else:
js.dump(args.o, recipes)
def run_bowtie(bowtie_index, contents, frequency_tree):
reads_to_be_analyzed = 2500
outputs = []
for i in range(len(contents)):
# print("############# BEGINING SEQUENCING " + str(i + 1) + " OF " + str(len(contents)) + " #############", file = sys.stderr)
# print("############# BEGINING SEQUENCING " + str(i + 1) + " OF " + str(len(contents)) + " #############", file = sys.stderr)
args = shlex.split("/software/bowtie2/bowtie2 --quiet -x " +
bowtie_index + " --sra-acc " + contents[i][1] +
" --sample-sra " + str(reads_to_be_analyzed) +
" --threads 4 --no-head >> temp.sam")
# args = shlex.split("/software/bowtie2/bowtie2 -x " + bowtie_index + " --sra-acc " + contents[i][1] + " --sample-sra " + str(reads_to_be_analyzed) + " --threads 4 --no-head >> temp.sam")
print("ARGS = " + str(args))
p = subprocess.Popen(args)
p.wait()
# print("############# FINISHED SEQUENCING " + str(i + 1) + " OF " + str(len(contents)) + " #############", file = sys.stderr)
try:
data = parseFile("temp.sam", frequency_tree)
# arr = [contents[0], contents[1]]
# arr += data
outputs.append(data)
except:
continue
if os.path.exists("temp.sam"):
os.remove("temp.sam")
return outputs
def process(obj_id, target, xslt = None):
""" get file from git, process, write to target folder
Arguments:
obj_id -- git object id of the file (as string)
target -- target folder path (as string, with trailing slash)
xslt -- xslt file path if xml-stylesheet PI should be included,
no PI will be included if null (which is default)
"""
stream = io.TextIOWrapper(git.blob_file_handle(obj_id), encoding='utf8')
r = parseFile(stream)
dump(target, r, xslt)
def process( obj_id, target):
""" get file from git, process, write to target folder
Arguments:
obj_id -- git object id of the file (as string)
target -- target folder path (as string, with trailing slash)
"""
stream = io.TextIOWrapper( git.blob_file_handle(obj_id), encoding='utf8')
r = parseFile(stream)
rec = serializeRecipes(r)
rec.addprevious(etree.ProcessingInstruction('xml-stylesheet', 'type="text/xsl" href="' + settings.XSLT + '"'))
et = etree.ElementTree(rec)
et.write(target,xml_declaration=True,pretty_print=True,encoding='UTF-8')
def main():
global args, facts, goals, rules, dic
args = parseArg()
facts, goals, rules, dic = parseFile(args.filename, args.default)
print(goals)
if args.verbose:
print(bc.GREEN + 'Facts:', list(facts.keys()), bc.RES, "\n")
print(bc.BLUE + 'Goals:', list(goals.keys()), bc.RES, "\n")
printdic(dic)
printrules(rules)
solve = Solver(rules, goals, dic, args)
solve.solver()
def main():
parser = argparse.ArgumentParser(description='Work with recipe markdown files')
parser.add_argument('-i', metavar='mdfile', type=argparse.FileType('r'), help='name of the markdown file to process, default: use stdin', default=sys.stdin)
parser.add_argument('-o', metavar='output', type=argparse.FileType('wb'), help='name of the output file, default: use stdout', default=sys.stdout.buffer)
parser.add_argument('-t', metavar='outtype', choices=['xml', 'json'], help='output type to generate (xml, json), default: xml', default='xml')
parser.add_argument('--xslt', metavar='xslt', help='xslt to reference in PI of generated XMLs, ignored if outtype is not "xml"', default=None)
args = parser.parse_args()
recipes = parseFile(args.i)
if args.t == 'xml':
xs.dump(args.o, recipes, args.xslt)
else:
js.dump(args.o, recipes)
def kmeans():
l1, l2 = list(), list()
X = parser.parseFile(config.csv_file_name)
for i, row in enumerate(X):
sublist = [float(row['latitude']), float(row['longitude'])]
l1.append(sublist)
l2.append(row)
ss = StandardScaler(with_mean=False, with_std=False)
X = ss.fit_transform(l1)
km = KMeans(n_clusters=100,
init='k-means++',
n_init=10,
max_iter=300,
tol=0.0001,
precompute_distances=True,
verbose=0,
random_state=None,
copy_x=True,
n_jobs=1)
km.fit(X)
labels = km.labels_
cluster_centers = km.cluster_centers_
labels_unique = numpy.unique(labels)
n_clusters_ = len(labels_unique) - 1
#We generate the list of dicts representing the center of our clusters.
#cluster is the ID of the cluster
#x and y are the coordinates for the center of this cluster
#number is the number of points in that cluster
centers = list()
for i, row in enumerate(cluster_centers):
centers.append({
'cluster': i,
'x': row[0],
'y': row[1],
'number': labels.tolist().count(i)
})
points = list()
for i, row in enumerate(X):
#-1 means that the point doesn't belong to any cluster (has been rejected).
#So we don't want to return these points and throw them away.
if labels[i] != -1:
l2[i]['cluster'] = labels[i]
points.append(l2[i])
return centers, points
def meanShift():
l1, l2 = list(), list()
X = parser.parseFile(config.csv_file_name)
for i, row in enumerate(X):
#attention a prendre un nombre suffisant de donnee pour que meanshift marche
sublist = [float(row['latitude']), float(row['longitude'])]
l1.append(sublist)
l2.append(row)
ss = StandardScaler(with_mean=False, with_std=False)
X = ss.fit_transform(l1)
bandwidth = estimate_bandwidth(X, quantile=0.01, n_samples=1000)
ms = MeanShift(bandwidth=bandwidth,
bin_seeding=True,
cluster_all=False,
min_bin_freq=15)
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_
labels_unique = numpy.unique(labels)
n_clusters_ = len(labels_unique) - 1
#We generate the list of dicts representing the center of our clusters.
#cluster is the ID of the cluster
#x and y are the coordinates for the center of this cluster
#number is the number of points in that cluster
centers = list()
for i, row in enumerate(cluster_centers):
centers.append({
'cluster': i,
'x': row[0],
'y': row[1],
'number': labels.tolist().count(i)
})
points = list()
for i, row in enumerate(X):
#-1 means that the point doesn't belong to any cluster (has been rejected).
#So we don't want to return these points and throw them away.
if labels[i] != -1:
l2[i]['cluster'] = labels[i]
points.append(l2[i])
return centers, points
def meanShift():
l1, l2 = list(), list()
X = parser.parseFile(config.csv_file_name)
for i, row in enumerate(X):
#attention a prendre un nombre suffisant de donnee pour que meanshift marche
sublist = [float(row['latitude']), float(row['longitude'])]
l1.append(sublist)
l2.append(row)
ss = StandardScaler(with_mean=False, with_std=False)
X = ss.fit_transform(l1)
bandwidth = estimate_bandwidth(X, quantile=0.01, n_samples=1000)
ms = MeanShift(bandwidth=bandwidth, bin_seeding=True, cluster_all=False, min_bin_freq=15)
ms.fit(X)
labels = ms.labels_
cluster_centers = ms.cluster_centers_
labels_unique = numpy.unique(labels)
n_clusters_ = len(labels_unique) - 1
#We generate the list of dicts representing the center of our clusters.
#cluster is the ID of the cluster
#x and y are the coordinates for the center of this cluster
#number is the number of points in that cluster
centers = list()
for i, row in enumerate(cluster_centers):
centers.append({'cluster': i, 'x': row[0], 'y': row[1], 'number': labels.tolist().count(i)})
points = list()
for i, row in enumerate(X):
#-1 means that the point doesn't belong to any cluster (has been rejected).
#So we don't want to return these points and throw them away.
if labels[i] != -1:
l2[i]['cluster'] = labels[i]
points.append(l2[i])
return centers, points
def main(filePath):
graph, sequence = parseFile(filePath)
# Get all the possible Euler circuits in given graph.
eulerCircuits = graphutils.getEulerianCircuits(graph)
longestCommonSStrings = []
circuitLabels = []
# For each of the circuits found, get the circuit label string and also the longest common substring.
for circuit in eulerCircuits:
circuitLabel = graphutils.getLabelsForPath(graph, circuit)
circuitLabels.append(circuitLabel)
longestCommonSStrings.append(
graphutils.longestCommonSubstring(sequence, circuitLabel))
# Out of all the substrings, find the longest
longestIndex = 0
longestString = 0
for i in range(len(longestCommonSStrings)):
if len(longestCommonSStrings[i]) > longestString:
longestString = len(longestCommonSStrings[i])
longestIndex = i
# The following is all for nice output
print 'Eulerian Circuit: %s' % eulerCircuits[longestIndex]
print 'Symbols on path: %s' % circuitLabels[longestIndex]
print 'Sequence: %s' % sequence
print 'Matched Substring: %s' % longestCommonSStrings[longestIndex]
startIndexSeq = findStringIndex(sequence,
longestCommonSStrings[longestIndex])
startIndexCircuit = findStringIndex(circuitLabels[longestIndex],
longestCommonSStrings[longestIndex])
lengthSString = len(longestCommonSStrings[longestIndex]) - 1
print 'Found sequence: %d-%d and subsequence: %d-%d' % (
startIndexSeq, startIndexSeq + lengthSString, startIndexCircuit,
startIndexCircuit + lengthSString)
def kmeans():
l1, l2 = list(), list()
X = parser.parseFile(config.csv_file_name)
for i, row in enumerate(X):
sublist = [float(row['latitude']), float(row['longitude'])]
l1.append(sublist)
l2.append(row)
ss = StandardScaler(with_mean=False, with_std=False)
X = ss.fit_transform(l1)
km = KMeans(n_clusters=100, init='k-means++', n_init=10, max_iter=300, tol=0.0001, precompute_distances=True, verbose=0, random_state=None, copy_x=True, n_jobs=1)
km.fit(X)
labels = km.labels_
cluster_centers = km.cluster_centers_
labels_unique = numpy.unique(labels)
n_clusters_ = len(labels_unique) - 1
#We generate the list of dicts representing the center of our clusters.
#cluster is the ID of the cluster
#x and y are the coordinates for the center of this cluster
#number is the number of points in that cluster
centers = list()
for i, row in enumerate(cluster_centers):
centers.append({'cluster': i, 'x': row[0], 'y': row[1], 'number': labels.tolist().count(i)})
points = list()
for i, row in enumerate(X):
#-1 means that the point doesn't belong to any cluster (has been rejected).
#So we don't want to return these points and throw them away.
if labels[i] != -1:
l2[i]['cluster'] = labels[i]
points.append(l2[i])
return centers, points
#!/usr/bin/python
import parser
import os
import os.path
HAND_HISTORY_PATH = "/home/msharman/HandHistory/antler88"
for f in os.listdir( HAND_HISTORY_PATH ):
path = os.path.join( HAND_HISTORY_PATH, f )
try:
print "Parsing %s:"%f
parser.parseFile( path )
except Exception as e:
print "Exception parsing %s: %s"%(f,e)
exit()
from parser import parseFile
from requestHandler import requestSPARQL
from fileManager import save, FILE
values = parseFile('./data/training_set_91_91.tsv')
data = []
l = len(values)
i = 1
for value in values:
ind = '{0:03}'.format(i)
print "[%s/%d] Request for (%s, %s)" % (ind, l, value[0], value[1]),
res = requestSPARQL(gene=value[0], drug=value[1])
if res.status_code == 200:
print "\t[OK]"
data.append({
'gene': value[0],
'drug': value[1],
'asso': value[2],
'json': res.content
})
else:
print "\t\t[FAIL]",
i += 1
print "\n",
save(data, FILE)
import re
import unittest
from os import listdir
from os.path import isfile, join
from main import main
from parser import parseFile
from problem import Problem
from test_operations import TestOperation
# all the test files in /tests
testfiles = [f for f in listdir("./tests") if isfile(join("./tests", f))]
# solutions to problems
solutions = []
# display for a solution
def printSolution(s):
print("alg: ", s[0][0:6], "error: ", s[1], "result: ", s[2], "steps: ", s[3], "time: ", s[4],"nodes: ", s[5], "max depth: ", s[6], "branching f: ", len(s[7].ops))
for file in testfiles:
if re.match('test', file) is not None:
solutions.append(main(parseFile("tests/" + file), False))
for fi in range(0, len(testfiles), 2):
printSolution(solutions[fi])
printSolution(solutions[fi+1])
print("----------------------------------------")
for key in keys:
sds[key] = 0
for house in l:
sds[key] += (float(house[key]) - means[key])**2
for key in keys:
sds[key] = (sds[key] / (len(l) - 1))**0.5
#print('statistic info : ')
#print(means, sds)
return (means, sds)
def softmax(x, mean, sd) -> float:
return 1 / (1 + math.exp(-(x - mean) / sd))
(data, prices) = preprocess(parseFile('database.txt'))
#print(data)
#print(prices)
matdata = numpy.zeros((len(data), 10))
matprices = numpy.zeros((len(data)))
(means, sds) = findStats(data, ['floor', 'm2', 'age', 'numrooms'])
priceMean = numpy.mean(prices)
priceSD = numpy.std(prices)
for (i, house) in enumerate(data):
matdata[i][0] = house['furnished']
matdata[i][1] = softmax(house['floor'], means['floor'], sds['floor'])
matdata[i][2] = softmax(house['m2'], means['m2'], sds['m2'])
matdata[i][3] = softmax(house['age'], means['age'], sds['age'])
for j in range(4, 9):
matdata[i][j] = 0
def setUp(self):
import parser
self.t = parser.parseFile('data/v5_b.xml')
def _test_parse_file(self, inputfile, result): self.assertEqual(parseFile(inputfile).alg, result.alg) self.assertEqual(parseFile(inputfile).startnum, result.startnum) self.assertEqual(parseFile(inputfile).targetnum, result.targetnum) self.assertEqual(parseFile(inputfile).time, result.time) self.assertEqual(parseFile(inputfile).ops, result.ops)
inktype = info.flags & 0x3f # TODO: correct?
if inktype in inktypes.keys():
ink = inktypes[inktype]
else:
ink = "<unknown (%02x)>" % inktype
item.addChild(QTreeWidgetItem(["Ink", ink]))
trails = "No"
if info.flags & 0x40:
trails = "Yes"
item.addChild(QTreeWidgetItem(["Trails", trails]))
antialias = "Off"
if info.flags & 0x2000:
antialias = "Low"
elif info.flags & 0x4000:
antialias = "Mid"
if info.flags & 0x6000 == 0x6000:
antialias = "High"
item.addChild(QTreeWidgetItem(["Antialias", antialias]))
self.info.addTopLevelItem(item)
self.info.expandItem(item)
self.info.resizeColumnToContents(0)
app = QApplication([])
movie = parser.parseFile(sys.argv[1])
win = MyMainWindow()
win.resize(1024, 768)
win.show()
app.exec_()
for s in previousScore2:
if prec == -1:
prec = s
bestNext = previousScore3[i]
else:
if prec > s:
prec = s
bestNext = previousScore3[i]
i += 1
return bestNext, previousScore
if __name__ == '__main__':
# Call parser
G = nx.Graph()
G, nbCars, Totaltime, intersections, streets, nodeStart = parser.parseFile("paris_54000.txt")
print "totaltime : ", str(Totaltime)
print "nbCars : ", str(nbCars)
print "streets nb : ", str(len(streets))
print "intersections nb : ", str(len(intersections))
# street info a Street[Distance,Time]
global _addCoef
_addCoef = 130
# create some structure
global _outputCarsMovements
_outputCarsMovements = []
global _totalTimeForTheCard
_totalTimeForTheCard = []
def setUp(self):
import parser
self.t = parser.parseFile('data/v5_b.xml')
def parse():
for dev_file in Path('./atdf').glob('*.atdf'):
yield from parseFile(str(dev_file.resolve()))
#!/usr/bin/python
import parser
import os
import os.path
HAND_HISTORY_PATH = "/home/msharman/HandHistory/antler88"
for f in os.listdir(HAND_HISTORY_PATH):
path = os.path.join(HAND_HISTORY_PATH, f)
try:
print "Parsing %s:" % f
parser.parseFile(path)
except Exception as e:
print "Exception parsing %s: %s" % (f, e)
exit()
import sys
from parser import parseFile, parse, simplifyTF
sys.setrecursionlimit(100000)
print('[*] Parsing')
symbols = parseFile(sys.argv[1])
print('[*] Running')
result = repr(symbols['_'].eval().simplify().alpha_norm())
result = simplifyTF(result)
print('[-] Result:', result)
except:
print('Unknow function at: ' + line)
exit()
if currentFunc.delay > tmpCycle:
tmpCycle = currentFunc.delay
currentFunc.computeCost(initialStocks)
for stockValue in initialStocks.values():
if stockValue < 0:
print('Invalid operation at: ' + line)
exit()
localCycle += tmpCycle
if localCycle != actualFileCycle:
print('Cycle count is wrong at: ' + line)
exit()
for func in splitedLine:
currentFunc = functions[func]
currentFunc.computeReward(initialStocks)
return localCycle
parseFile(data, initialStocks, processList, toOptimize)
functions = funcDictionaryBuild()
localCycle = 0
for line in output:
if len(line) == 0:
continue
if line.startswith('State of stock after'):
break
localCycle = parseLine(line, functions, localCycle)
print('This output is correct.')
else:
result = iterative.solve(problem)
val = result[0]
error = abs(val - problem.targetnum)
steps = result[1]
time = result[2]
nodes = result[3]
max = result[4]
endNode = result[5]
if debug == None or debug == True:
try:
endNode.print_path()
except:
print("No steps taken...")
print("Algorithm used: " + problem.alg)
print("Error: %r" % error)
print("Value found: %r" % val)
print("Steps taken: %r" % steps)
print("Time taken: %r" % time)
print("Nodes expanded: %r" % nodes)
print("Max depth traversed: %r" % max)
return (problem.alg, error, val, steps, time, nodes, max, problem)
if __name__ == "__main__":
main(parseFile(parseCommandLine(sys.argv[1:])), True)
D = []
for i in range(len(l)):
if (belong(D, l[i])) < 0:
D.append(l[i])
return len(D)
# Replaces character strings by numbers
def make_standard(data, s, max):
D = []
Used = []
for i in range(max):
if belong(Used, get_group(data, i, s)) < 0:
Used.append(get_group(data, i, s))
D.append(len(Used))
else:
D.append(belong(Used, get_group(data, i, s)))
return D
data1 = parser.parseFile("1epahttp.txt", "epahttp")
data2 = parser.parseFile("2sdschttp2.txt", "sdschttp")
data3 = parser.parseFile("3Calgaryaccess_log.txt", "calgaryhttp")
sample1 = make_standard(data1, "host", 25000)
sample2 = make_standard(data2, "host", 25000)
sample3 = make_standard(data3, "host", 25000)
print(ecart([sketch_cod2(sample1, sample2, 64, 0.0001) for i in range(100)]))
# print(count_min([sample1,sample2,sample3],0.000001,1024,25000))
import parser
from matrix import identity
from draw import newScreen
# Initialize the screen
screen = newScreen()
# Parse the script
parser.parseFile("script_c", identity(4), [], screen)
__author__ = "yaelcohen"
### go over the folder parse each file
## manage global ids
## create big diction
import glob
import pickle
id = 0
all = {}
all_nodes = []
path = "/Users/yaelcohen/Documents/cvs/cvs_out/*.html"
for fname in glob.glob(path):
# if (id > 1000):
# break
print "working on " + fname
cv, id = parseFile(fname, id)
all_nodes += cv
all[fname] = cv
print all
print id
pickle.dump(all, open("all_dict_2.p", "wb"))
pickle.dump(all_nodes, open("all_nodes_2.p", "wb"))
## all_nodes = pickle.load( open( "all_nodes.p", "rb" ) )
print "DONE"
import sys
from parser import parseFile, parse
from pylam import Variable
sys.setrecursionlimit(100000)
symbols = {}
symbols['M'] = Variable('M', showid=False)
symbols['I'] = Variable('I', showid=False)
symbols = parseFile('def.txt', symbols)
for k, v in symbols.items():
if k in 'YMI_':
continue
symbols[k] = v.eval().simplify()
assert len(symbols[k].freevar()) == 0, k
print(symbols['_'].alpha_norm())
