def __init__(self, progName = ''):
""" Load program (not doing anything yet),
and fill default command list """
# setup logging
logging.basicConfig(filename='../logs/AR2.warning.log', level=logging.WARNING)
logging.basicConfig(filename='../logs/AR2.debug.log', level=logging.DEBUG)
logging.basicConfig(filename='../logs/AR2.info.log', level=logging.INFO)
# load protocol
fileID = open('../conf/conf_commands.csv')
csvID = csv.reader(fileID, delimiter=',')
self._commands = {}
for row in csvID:
new_cmd = ProgramLine(int(row[0]), row[2], row[1], '', '')
self._commands[row[1]] = new_cmd
# initialise program
self.program_name = progName
self.program = program.Program()
# setup controller
self.number_of_joints = 6
self.controller = controller.Controller(self.number_of_joints)
def create_program(name, func, indim, outdim, num_equality=None, percentage_equality=.5): if num_equality is None: num_equality = min(indim, int(percentage_equality * (outdim - 1))) level_set_height = 5 radius = 50 perm = permutation(arange(outdim)) x0 = (radius / 2) * ones(indim) - radius * random(indim) curval = func(x0) class obj: def __init__(self, i): self.i = i def evaluate(self, x): return func(x)[self.i] - curval[self.i] if num_equality > 0: equality_constraints = functions.VectorFunction(indim) for i in range(1, 1 + num_equality): equality_constraints.add(obj(perm[i])) else: equality_constraints = None num_inequality = outdim - 1 - num_equality if num_inequality > 0: inequality_constraints = functions.VectorFunction(indim) for i in range(1 + num_equality, outdim): inequality_constraints.add(obj(perm[i])) else: inequality_constraints = None return program.Program(name, obj(perm[0]), equality_constraints, inequality_constraints, zeros(indim)), x0
def __init__(self):
self.Settings = exp_settings.ExperimentSettings()
self.DataFile = exp_datafile.ExperimentDataFile(self.Settings)
self.Program = program.Program(self.Settings)
self.Sensors = sensor_data.SensorData()
self.status = exp_settings.ExpState()
self.currentSensorData = None
self.currentRecordData = None
self.currentTargetData = None
def get(self, action_name, *args, **kwargs):
if action_name in self.actions.keys() + self.ramps.keys():
return self.tot_list()[action_name]["call"](*args, **kwargs)
elif action_name in self.programs.keys():
cmd = self.system.cmd_thread
return self.tot_list()[action_name]["call"]\
(lib_program.Program(self.system, action_name), cmd, *args, **kwargs)
else:
print "ERROR: action \"%s\" not found" % action_name
return None
def get_prg(self):
program = lib_program.Program(system=self.system,
name=self.name,
comment=self.comment)
t_ramp = []
x_ramp = []
if None not in [self.start_t, self.stop_t, self.n_points]:
t_ramp = linspace(self.start_t, self.stop_t, self.n_points)
if self.act_var_name is not None and None not in [
self.start_x, self.stop_x
]:
x_ramp = linspace(self.start_x, self.stop_x, self.n_points)
else:
x_ramp = t_ramp
elif None not in [self.start_t, self.step_t]:
if self.n_points is not None:
n_points = self.n_points
elif self.stop_t is not None and None in [
self.start_x, self.step_x, self.stop_x
]:
n_points = int((self.stop_t - self.start_t) / self.step_t)
elif None not in [
self.stop_t, self.start_x, self.step_x, self.stop_x
]:
n_points = min(int((self.stop_t - self.start_t) / self.step_t),
int((self.stop_x - self.start_x) / self.step_x))
else:
n_points = 0
print "ERROR: wrong call for \"%s\" with name \"%s\"" % (str(
type(self)), self.name)
t_ramp = arange(self.start_t, self.step_t * n_points, self.step_t)
if self.act_var_name is not None and None not in [
self.start_x, self.step_x
]:
x_ramp = arange(self.start_x, self.step_x * n_points,
self.step_x)
else:
x_ramp = t_ramp
else:
print "ERROR: wrong call for \"%s\" with name \"%s\"" % (str(
type(self)), self.name)
for tval, xval in zip(t_ramp, x_ramp):
act_args = self.act_parameters.items()
if self.act_var_name is not None:
act_args += [(self.act_var_name, xval)]
act_args = dict(act_args)
program.add(self.system.set_time(tval), self.act_name, **act_args)
return program
def log_train_results(self):
#Log results for Train Test Split
model_log = pd.read_csv(program.Program().rootDirectory +
"/models/log/catboost_model_log.csv")
new_data = {
"model": "CatBoost",
"run_time": self.input.date,
"random_state": self.input.random_state,
"test_size": self.input.test_size,
"iterations": self.input.iterations,
"depth": self.input.depth,
"learning_rate": self.input.learning_rate,
"loss_function": self.input.loss_function,
"logging_level": self.input.logging_level,
"continuous_variables": self.input.continuous_variables,
"categorical_variables": self.input.categorical_variables,
"submission_filename": self.input.CatBoost_submission_name,
"best_score": self.best_score,
"best_iteration": self.best_iteration,
"train_R2": self.train_R2,
"test_R2": self.test_R2,
"train_RMSE": self.train_RMSE,
"test_RMSE": self.test_RMSE,
"cv_train_RMSE": self.cv_train_RMSE,
"cv_test_RMSE": self.cv_test_RMSE
}
# Log results
model_log = model_log.append(new_data, ignore_index=True)
# Update log file
model_log.to_csv(program.Program().rootDirectory +
"/models/log/catboost_model_log.csv",
index=False)
print("Log Train Results Complete. Saved to: {}".format(
program.Program().rootDirectory +
"/models/log/catboost_model_log.csv"))
def load_input_file(self):
filename = self.get_file()
if filename == None: return
lines = self.get_lines(filename)
self.program = mips.Program(lines)
self.unlock_text()
self.update_input(lines)
self.update_bin()
self.update_stack()
self.update_registers()
self.lock_text()
self.step_button["state"] = "normal"
self.run_button["state"] = "normal"
def test_status(self):
status = [
'AC', 'CE', 'DSC', 'MLE', 'MLE(stack)', 'OLE', 'RE', 'TLE', 'WA'
]
for i in status:
with codecs.open(os.path.join('test_dir', i, 'test.cpp'), 'r',
'utf-8') as f:
code = f.read()
p = program.Program(
ProblemTask(id='test_status',
user_id=i,
language='C++',
code=code))
print(p.run().__dict__)
def __init__(self):
self.players = []
self.boardLock = threading.Lock()
self.program = program.Program()
self.started = False
self.commands = {
'move': self.makeMove,
'surrender': self.give_up,
'yield': self.give_up,
'castle': self.castle,
'say': self.say,
'print': lambda p: str('Hello, world')
}
self.player_color = WHITE
def test_languages(self):
languages = [
'C', 'C++', 'C#', 'Go', 'Java', 'Python3', 'Ruby', 'JavaScript'
] # ruby and js error output
user_id = 'Languages'
for i in languages:
with codecs.open(os.path.join('test_dir', user_id, i), 'r',
'utf-8') as f:
code = f.read()
p = program.Program(
ProblemTask(id='test_languages',
user_id=i,
language=i,
code=code))
print(p.run().__dict__)
def transpile(ast, filename=''):
prog = program.Program()
print(ast)
print
print '#####################'
print
if ast.type == 'stmt_list':
for t in ast.children:
print 'Type:', t.type
if t.type == 'fun':
prog.get_main_module().add_function(t)
# else:
# prog.get_main_module().add_main_statement(t)
prog.write_to_file(filename)
def __init__(self):
self.Settings = exp_settings.ExperimentSettings()
self.DataFile = exp_datafile.ExperimentDataFile(self.Settings)
self.status = exp_settings.ExpState()
self.Program = program.Program(self.Settings, self.status)
self.Sensors = sensor_data.SensorData()
self.WFD_freq = 0.0
self.prevStatus = copy.deepcopy(self.status)
self.currentAverageData = np.full(
shape=(Experiment.sensorDataVecLength),
fill_value=np.nan,
dtype=np.float)
self.currentAverageVoltage = np.full(
shape=(Experiment.sensorVoltageVecLength),
fill_value=np.nan,
dtype=np.float)
self.currentTargetData = np.full(shape=(Experiment.targetVecLength),
fill_value=np.nan,
dtype=np.float)
self.prevTargetData = np.full(shape=(Experiment.targetVecLength),
fill_value=np.nan,
dtype=np.float)
self.DataBufferPointer = 0
self.SensorVoltageBuffer = np.full(
shape=(self.Settings.avgBufferSize,
Experiment.sensorVoltageVecLength),
fill_value=np.nan,
dtype=np.float)
self.SensorDataBuffer = np.full(shape=(self.Settings.avgBufferSize,
Experiment.sensorDataVecLength),
fill_value=np.nan,
dtype=np.float)
self.SensorDataBuffer[:, 0] = 0.0
#time,load, friction, rpm, temperatura
self.RemovedOutliers = np.array([False, False, False, False, False],
dtype=np.bool)
self.Automation = Automation(self)
def __init__(self, prog=False):
if prog == False:
self.program = program.Program()
else:
self.program = prog
self.nextFreeVariable = self.program.nextVariable
self.instructionList = []
for i in self.program.instructionList:
self.instructionList.append(i)
self.seenIntegers = set([])
self.seenFloats = set([])
self.seenStrings = set([])
self.scopeAnalyzer = analyzer.ScopeAnalyzer(self.program)
self.scopeAnalyzer.doAnalyze()
self.contextAnalyzer = analyzer.ContextAnalyzer(self.program)
self.contextAnalyzer.doAnalyze()
self.typeAnalyzer = analyzer.TypeAnalyzer(self.program)
self.typeAnalyzer.doAnalyze()
self.registerFile['fs' + str(i)] = self.registerFile['f' + str(16 + i)]
for i in range(8, 12) :
self.registerFile['ft' + str(i)] = self.registerFile['f' + str(20 + i)]
#alias any extra floating point registers
for f in range(self.numFloatRegisters - 32) :
self.registerFile['ft' + str(12 + f)] = self.registerFile['f' + str(32 + f)]
def execProgram(self, p) :
self.prog = p
self.pc = self.memory.text[0]
while (self.pc != -1) :
# print(self.pc) #UNCOMMENT TO DEBUG BY PRINTING PC VALUE
inst = p.code[self.pc]
# print(inst) #UNCOMMENT TO DEBUG BY PRINTING INSTRUCTION TRACE
inst.exec()
print("Execution time: " + str(self.timingModel.getTotalTime()) + " cycles")
# machine = Machine(numIntRegisters = 64, numFloatRegisters = 64)
#### TEST ####
if __name__ == '__main__' :
p = program.Program()
p.buildCodeFromFile('testFile.asm')
config.machine.execProgram(p)
identifierTable = [] if __name__ == "__main__": # Open file with command line argument. Check for existence, then tokenize the file with open(sys.argv[1], 'r') as f: t = Tokenizer.Tokenizer(f) inData = [] if(len(sys.argv) > 2): # Grab the data from the inputFile and split it by spaces with open(sys.argv[2], 'r') as file: inData = re.split(r'[ \t]+', file.readline()) # Remove any leftover white spaces inData = [s.strip() for s in inData] for i in inData: if not int(i): print 'Your input data must be of type integer.' exit() # Initialize, parse, print, and then execute the input program program = program.Program(t, inData) program.parse() program.Print() program.execute() # Garbage collection t.__del__ program.__del__
def get_prog(self):
if self.prog == None:
self.prog = program.Program(self.db, self.get_prog_id())
return self.prog
q = functions.Quadratic(Q, b, c)
c1 = functions.Line(arr([1, 1]), -1)
#c2 = functions.Line(arr([1, -1]), 10)
c2 = functions.Wiggles()
equality = []
equality.append(c1)
inequality = []
inequality.append(c2)
x0 = arr([1, 2])
warnings.showwarning = warn_with_traceback
statement = program.Program(q, equality, inequality, x0)
#statement = program.DfoProgram("wiggles", q, equality, inequality, x0, plotImprovements=True)
constants = filter_linesearch.Constants(50 * filter_linesearch.theta(statement, x0))
#constants.plot = False
#import cProfile
#tot = cProfile.run('filter_linesearch.filter_line_search(statement, constants)')
results = filter_linesearch.filter_line_search(statement, constants)
print("number_of_iterations = " + str(results.number_of_iterations ))
print("restorations = " + str(results.restorations ))
print("ftype_iterations = " + str(results.ftype_iterations ))
print("filter_modified_count = " + str(results.filter_modified_count ))
print("pareto = " + str(results.pareto ))
def main():
app = program.Program()
app.exec()
def __init__(self):
self.aspectRatio = 1
self.angle = 0
self.startTime = dt.datetime.now()
# Initialize GLUT
def display():
gl.glClear(gl.GL_COLOR_BUFFER_BIT | gl.GL_DEPTH_BUFFER_BIT)
gl.glDrawArrays(gl.GL_TRIANGLES, 0,
self.getSubjectVertices().shape[0])
glut.glutSwapBuffers()
def reshape(width, height):
self.aspectRatio = float(width) / height
gl.glViewport(0, 0, width, height)
def keyboard(key, x, y):
sys.exit()
def setTransform():
self.program.setUniform(
'transformation',
trf.getPerspMat(self.fieldOfViewY, self.aspectRatio,
self.zNearFarVec) * self.getPositionMat())
def timer(dummy):
setTransform()
glut.glutTimerFunc(self.milliSecondsPerFrame, timer, None)
glut.glutPostRedisplay()
glut.glutInit()
glut.glutInitDisplayMode(glut.GLUT_DOUBLE | glut.GLUT_RGBA
| glut.GLUT_DEPTH | glut.GLUT_MULTISAMPLE)
glut.glutCreateWindow('Vertex and fragment shaders')
glut.glutReshapeWindow(self.windowSize, self.windowSize)
glut.glutReshapeFunc(reshape)
glut.glutDisplayFunc(display)
glut.glutKeyboardFunc(keyboard)
glut.glutTimerFunc(0, timer, None)
#gl.glEnable (gl.GL_LINE_SMOOTH)
#gl.glEnable (gl.GL_BLEND);
#gl.glEnable (gl.GL_MULTISAMPLE)
# gl.glDepthFunc (gl.GL_LESS)
gl.glClearColor(0.2, 0.2, 0.2, 1)
gl.glEnable(gl.GL_DEPTH_TEST)
#gl.glShadeModel (gl.GL_SMOOTH)
#gl.glHint (gl.GL_LINE_SMOOTH_HINT, gl.GL_DONT_CARE)
#gl.glBlendFunc (gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
# Initialize shaders
self.program = prg.Program(
prg.Shader(
'vertex', '''
uniform mat4 transformation;
attribute vec3 position;
attribute vec4 color;
varying vec4 varyingColor;
void main () {
gl_Position = vec4 (transformation * vec4 (position, 1));
varyingColor = color;
}
'''),
prg.Shader(
'fragment', '''
varying vec4 varyingColor;
void main () {
gl_FragColor = varyingColor;
}
'''),
)
# Set subject to be displayed
self.program.setAttributes(self.getSubjectVertices())
# Enter GLUT main loop
glut.glutMainLoop()
import program as program
import modules.settings as settings
import time
import json
prog = program.Program(settings.Settings())
def test_change_interval_task():
assert program.change_interval_task('test', 20, prog) == 20
program.cancel_task('test')
assert program.change_interval_task('test', 20) is None
def test_get_social_rating():
prog.settings.subjects = ['max verstappen']
assert len(prog.get_current_social_rating()) > 0
def test_program_mqtt():
prog.MQTT.subscribe_topic("[email protected]/app")
prog.MQTT.send_message("test")
time.sleep(1) # sleep because sending the message takes time
assert prog.MQTT.messages[0] == "test"
prog.MQTT.retrieve_message()
def test_check_messages_program():
msg = prog.check_messages()
assert msg == None
prog.MQTT.messages.append("testvalue")
parser.add_argument("--insts", action='store_true', help="count the number "
"of instructions in program, can be used only "
"with argument --stats")
parser.add_argument("--vars", action='store_true', help="count number of all "
"created variables in program, can be used only "
"with argument --stats")
# if -h is with any other argument should exit 10
try:
args = parser.parse_args()
except SystemExit:
exit(0)
if (not args.stats):
if (args.insts or args.vars):
print("ERROR: Arguments --vars and --insts can be"
" used only with argument --stats", file=sys.stderr)
exit(10)
if (args.source is None):
print("ERROR: Missing --source argument with source file", file=sys.stderr)
exit(10)
try:
parser = xmlParser.XmlParser(file_handle=args.source)
code = parser.parse()
program = program.Program(code)
program.interpret()
except InterpretException as e:
exit(e.exit_code)
import wx, program
if __name__ == "__main__":
app = wx.App()
frame = program.Program()
frame.Show()
app.MainLoop()
def getCurr(self):
if self.curr_handle in self.programdict:
return program.Program(self.s, self.programdict[self.curr_handle])
else:
return None
import csv
from program_relationships import relationships as edges
import terminal_colors
import program
all_programs = {}
with open('programs.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
line_count = 0
for row in csv_reader:
if line_count == 0:
line_count += 1
else:
id = int(row[0])
p = program.Program(id, row)
all_programs[id] = p #key = id, value = program obj
line_count += 1
graph = nx.DiGraph()
graph.add_edges_from(edges)
print('Passes DAG check: ')
passes_dag_check = nx.is_directed_acyclic_graph(graph)
if passes_dag_check:
print(
f'{terminal_colors.colors.OK}{str(passes_dag_check)}{terminal_colors.colors.ENDC}'
)
print('\n')
else:
print(
def __init__(self):
# Log parameter run time
self.date = datetime.now().strftime('%Y%m%d_%H%M%S')
'''
-------------------------
Select Test Variables
-------------------------
'''
# List of continuous variables
self.continuous_variables = [
'accommodates',
'bathrooms',
# 'first_review',
# 'host_response_rate',
# 'host_since',
# 'last_review',
'number_of_reviews',
# 'review_scores_rating',
'bedrooms',
# 'beds',
# 'amenities_count',
'description_length',
'latitude',
'longitude',
'zhvi'
]
# List of categorical variables
self.categorical_variables = [
'property_type',
'room_type',
# 'bed_type',
# 'cancellation_policy',
# 'cleaning_fee',
# 'city',
# 'host_since',
# 'description',
# 'host_has_profile_pic',
# 'host_identity_verified',
# 'instant_bookable',
# 'name',
'neighbourhood',
# 'thumbnail_url',
# 'zipcode'
]
'''
-------------------------
Preprocessing Parameters
-------------------------
'''
# Normalize Continuous Parameter (1: Min Max Scaler , 2: Z-Score Standard Scaler)
self.numeric_scaler_option = 2
# Normalize Categorical Parameter
self.one_hot_encode = False # Catboosting does not require one hot encoding - True to turn on, False to turn off
self.drop_first = False # True: to drop First one hot ecode, False: to not drop First
#Modeling Parameters: Train test split for repeatability
self.random_state = 420
self.test_size = 0.20
'''
-------------------------
CatBoost Parameters
-------------------------
'''
# Run load data and feature engineering
self.run_load_data = True
# Run Train - True turn train on. False turn train off
self.run_train = True
# Run Test - True turn test on. False turn test off
self.run_test = True
# General Parameters
self.output_submission_file = True # True creates csv file, False skips csv file
self.CatBoost_save_model_name = "CatBoostModel"
self.CatBoost_submission_name = program.Program().rootDirectory + "/models/submission/Sub_CatBoost {}.csv".format(self.date)
self.use_best_model = True
self.plot = True
self.verbose = True
# Modeling Parameter: Catboost Parameters (Final Prediction)
self.iterations = 1000 # Default 1000
self.depth = 5 # Default 5
self.learning_rate = 0.3 # Default 0.3
self.loss_function = 'RMSE'
self.logging_level = 'Silent'
# Cross Validation Parameters
self.fold_count = 3
self.shuffle = True
self.params = {'iterations': self.iterations,
'depth': self.depth,
'learning_rate': self.learning_rate,
'loss_function': self.loss_function,
'logging_level': self.logging_level}
def __init__(self):
self.la = language.Language()
self.pr = program.Program()
self.gu = guitar.Guitar()
self.st = star.Star()
def get_prg(self):
return lib_program.Program(self.system, "")
def getProgram(self, name):
return program.Program(self.s, name)
def copy(self, destination_name):
tools = self.gettools()
tools.set_curr_by_name(self.name)
tools.copy_program(destination_name)
return program.Program(self.s, destination_name)
def setUp(self):
""" """
self.program = program.Program()
