def photu_de(r, ser, cap):
count = 0
while True:
ret, frame = cap.read()
frame = frame[int(r[1]):int(r[1] + r[3]), int(r[0]):int(r[0] + r[2])]
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
aruco_dict = aruco.Dictionary_get(aruco.DICT_6X6_250)
parameters = aruco.DetectorParameters_create()
corners, ids, rejectedImgPoints = aruco.detectMarkers(
gray, aruco_dict, parameters=parameters)
if corners:
return corners
count += 1
Signal.stop(ser)
if count > 20:
Signal.rev(ser)
time.sleep(0.5)
Signal.right(ser)
time.sleep(0.5)
Signal.left(ser)
time.sleep(0.4)
Signal.stop(ser)
gray = aruco.drawDetectedMarkers(gray, corners)
cv2.imshow('frame', gray)
if cv2.waitKey(1) & 0xFF == ord('q'):
break
def strategy(self, stockNo):
if stockNo is not None:
try:
nowDate = datetime.datetime.now()
endDateStr = nowDate.strftime(Config.FORMAT_STR)
startDateStr = (
nowDate -
datetime.timedelta(days=self.dateDelta)).strftime(
Config.FORMAT_STR)
df = ts.get_hist_data(stockNo,
start=startDateStr,
end=endDateStr)
if (df is not None) and (len(df.index) >= self.dateDelta):
ma20 = df[u'ma20']
close = df[u'close']
underline = True
for index in range(1, self.dateDelta - 1):
if close[index] > ma20[index]:
underline = False
break
if underline and close[0] > ma20[0]:
#存入买入股票编码
redisService.sadd(self.buyKey, stockNo)
return Signal.Signal(stockNo=stockNo,
buy=True,
dateStr=endDateStr)
upline = True
for index in range(1, self.dateDelta - 1):
if close[index] < ma20[index]:
upline = False
break
if upline and close[0] < ma20[0]:
#存入买入股票编码
redisService.sadd(self.sellKey, stockNo)
return Signal.Signal(stockNo=stockNo,
sell=True,
dateStr=dateStr)
#如果前3天的收盘价在20天均线下方，而当前收盘价在均线上方，则发出买入信号
# if close[1] < ma20[1] and close[2] < ma20[2] and close[3] < ma20[3] and close[0] > ma20[0] :
#存入买入股票编码
# redisService.sadd(self.buyKey,stockNo)
# return Signal.Signal(stockNo=stockNo,buy=True,dateStr=dateStr)
#如果前3天的收盘价在20天均线上方，而当前收盘价在均线上方，则发出买入信号
# if close[1] > ma20[1] and close[2] > ma20[2] and close[3] > ma20[3] and close[0] < ma20[0] :
# redisService.sadd(self.sellKey,stockNo)
# return Signal.Signal(stockNo=stockNo,sell=True,dateStr=dateStr)
return None
except:
print(self.strategyName, "策略出现异常:", sys.exc_info()[0])
finally:
#让出线程
time.sleep(1)
return None
return None
def test_linkedSignal():
# Arrange
test = SignalReceiver()
signal_1 = Signal.Signal()
signal_2 = Signal.Signal()
signal_1.connect(signal_2)
signal_2.connect(test.slot)
# Act
signal_1.emit()
assert test.getEmitCount() == 1
def test_disconnectLinkedSignal():
# Arrange
test = SignalReceiver()
signal_1 = Signal.Signal()
signal_2 = Signal.Signal()
signal_1.connect(signal_2)
signal_2.connect(test.slot)
# Break the chain
signal_1.disconnect(signal_2)
# Act
signal_1.emit()
assert test.getEmitCount() == 0
def main():
db = OppDF()
db.populate("../results/pickles")
db_view = OppSelect(db)
unique_pids = list(db.df['PID'].unique())
unique_locomotions = list(db.df['Locomotion'].unique())
unique_run_ids = list(db.df['RunID'].unique())
signal_info = NestedDefaultDict()
for pid in unique_pids:
for run_id in unique_run_ids:
db_view.run_indexing({'PID': pid, 'RunID': run_id})
for locomotion in unique_locomotions[1:]:
db_view.label_indexing({'Locomotion': locomotion})
time = db_view.df['Time']
for signal in range(1, 243):
data = db_view.df.iloc[:, signal]
temp_fs = Signal.FuzzySet(data)
signal_name = data.name
signal_info[pid][run_id][locomotion][signal_name][
'fs'] = temp_fs
print("---" * 10)
print(f"\tSignal:\t{signal_name}")
print(f"\tMin:\t{min(data)}")
print(f"\tMax:\t{max(data)}")
db_view.restart()
db_view.restart()
result = dict(signal_info)
print(result)
print(type(result))
with open('../results/fs/signal_info.pkl', 'wb') as f:
pickle.dump(result, f)
def genNote(self, note, beats, type):
"""Generates a signal object that includes the audio wave
converted into binary and the raw audio wave data (y coordinates for a wave
function) for a specific note, duration and wave type"""
signalObject = Signal.Signal()
duration = self.BPS * beats
if len(note) > 0:
frequency = self.m.returnFreq(note)
phase = self.samplerate / float(frequency)
omega = np.pi * 2 / phase
else:
frequency = 0
phase = 0
omega = 0
A = 1
samples = duration * self.samplerate
period = np.arange(int(phase), dtype=np.float) * omega
if type == "sin":
y = A * np.sin(period)
elif type == "saw":
y = A - ((A / np.pi) * period)
ydata = self.volume * y
signal = np.resize(ydata, (samples, ))
ssignal = ''
for i in range(len(signal)):
signalObject.signalData.append(signal[i] / self.volume)
signalObject.binary += wave.struct.pack('h', signal[i])
return signalObject
def getSignalWaveMon():
query = "wavemon -d | grep signal"
output = subprocess.check_output(query.split())
output = output[output.index("signal")+14:]
output = output[:output.index("mW)")+3]
dBm = int(output[:output.index("dBm")])
mW = float(output[output.index("(")+1:output.index(")")-3])
return Signal(dBm,mW)
def __init__(self, events, event_queue):
self.events = events
self.event_queue = event_queue
self.event_names = tuple(sorted(events))
for event in events:
event = event.replace(' ', '_')
setattr(self, event, Signal.Signal())
def test_disconnectAll():
test = SignalReceiver()
signal = Signal.Signal()
signal.connect(test.slot)
# Act
signal.disconnectAll()
signal.emit()
# Assert
assert test.getEmitCount() == 0
def test_signal():
# Arrange
test = SignalReceiver()
signal = Signal.Signal()
signal.connect(test.slot)
# Act
signal.emit()
# Assert
assert test.getEmitCount() == 1
def __init__(self, events, event_queue):
threading.Thread.__init__(self)
self.setDaemon(True)
self._stop = False
self.events = events
self.event_queue = event_queue
self.event_names = tuple(sorted(events))
for event in events:
event = event.replace(' ', '_')
setattr(self, event, Signal.Signal())
def Get_signalInfo(self, dbc_path):
with open(dbc_path) as f:
dbc_str = f.readlines()
self.msg_array = []
self.nodeName_array = []
msg_array_index = 0
message_flag = False
oldtime = time.time()
for line in dbc_str:
if re.match('BO_ (\d+) (\S+): (\d+) (\S+)', line) != None:
message_flag = True
if True == message_flag:
if re.match('BO_ (\d+) (\S+): (\d+) (\S+)', line) != None:
message_groups = re.search('BO_ (\d+) (\S+): (\d+) (\S+)',
line).groups()
msg_id = message_groups[0]
msg_name = message_groups[1]
msg_dlc = message_groups[2]
msg_node = message_groups[3]
message_ins = Message.Message(msg_id, msg_name, msg_dlc,
msg_node)
if ('VECTOR__INDEPENDENT_SIG_MSG' == message_ins.msg_name
) | ('Test_' in message_ins.msg_name):
message_flag = False
else:
self.msg_array.append(message_ins)
self.nodeName_array.append(message_ins.msg_node)
elif re.match(
' SG_ (\S+) : \d+\|\d+@0\+ \((\d+\.?\d*),(-?\d+)\) \[(-?\d+\.?\d*)\|(-?\d+\.?\d*)\] "(\S+)"*',
line) != None:
signal_groups = re.search(
' SG_ (\S+) : \d+\|(\d+)@0\+ \((\d+\.?\d*),(-?\d+)\) \[(-?\d+\.?\d*)\|(-?\d+\.?\d*)\] "(\S+)"*',
line).groups()
signal_name = signal_groups[0]
signal_dlc = signal_groups[1]
signal_factor = signal_groups[2]
signal_offset = signal_groups[3]
signal_minValue = signal_groups[4]
signal_maxValue = signal_groups[5]
signal_unit = signal_groups[6]
signal_ins = Signal.signal(signal_name, signal_dlc,
signal_factor, signal_offset,
signal_minValue,
signal_maxValue, signal_unit)
self.msg_array[msg_array_index].__signal_add(signal_ins)
pass
elif '\n' == line:
msg_array_index = msg_array_index + 1
message_flag = False
if re.match('CM_ .*', line) != None:
self.nodeName_array = list(set(self.nodeName_array))
break
def __init__(self, parent=None, label="Default"):
super(SignalWaveAndOperation, self).__init__(parent)
self.top_hbox = QtGui.QHBoxLayout()
self.signalOperation = SignalOperation_UI.SignalOperation_UI()
self.mplGraph = QtMpl.QtMpl(parent)
self.top_hbox.addLayout(self.signalOperation.getLayout())
self.top_hbox.addWidget(self.mplGraph)
self.Signal = Signal.Signal()
return
def MixedSignalPushButton_Clicked(self):
print("Mixed Signals Clicked")
temp = Signal.Signal(
start_time=self.graph.list_of_signals[0].start_time,
end_time=self.graph.list_of_signals[0].end_time,
sample_frequency=self.graph.list_of_signals[0].sample_frequency)
temp.CreateSawTooth()
print(len(self.graph.list_of_signals))
for x in self.graph.list_of_signals:
print(len(x.data))
print(x.data)
temp.data = temp.data + x.data
self.graph.addSignal(temp)
return
def Initialize():
global plane
global signal
print("=====> Initializing the program")
plane = Plane()
signal = Signal()
print("Moving to initial positions")
plane.MoveToInitial()
plane.MakeVertical()
# Sleep for adjustments to complete
time.sleep(3)
def __init__(self, parent=None, label="Default"):
super(SignalWaveAndConfig, self).__init__(parent)
self.top_hbox = QtGui.QHBoxLayout()
self.signalConfig = SignalConfig_UI.SignalConfig_UI()
self.mplGraph = QtMpl.QtMpl(parent)
self.top_hbox.addLayout(self.signalConfig.getLayout())
self.top_hbox.addWidget(self.mplGraph)
self.Signal = Signal.Signal()
self.connect(self.signalConfig.displayButton,
QtCore.SIGNAL("clicked()"), self.displayButtonClicked)
return
def genChord(self, notes, duration, type):
"""Generates a chord by first generating the individual notes, then halving the amplitudes of
the resulting wave functions of the notes and then adding them all together"""
signalObject = Signal.Signal()
notedata = []
signalDatas = []
for note in notes:
signal = self.genNote(note, duration * 2, type)
signalDatas.append(signal.signalData)
decodeddata = np.fromstring(signal.binary, np.int16)
notedata.append(decodeddata * 0.5)
signalObject.signalData = sum(map(np.array, signalDatas))
signalObject.binary = sum(notedata).astype(np.int16)
return signalObject
def main():
d = 20 #m
angle = 1.8 #rad
coords = [[0.005, 0.005], [0.005, -0.005], [-0.005, -0.005],
[-0.005, 0.005]]
freq = 45 #kHz
sos = 1.5 #m/ms
sr = 1000 #kHz
read = 1500 #ms
noise = 1 #standard deviation
time_on = 100 #ms --ping duration
ping_period = 1000 #ms
ping_start = random.random() * ping_period
#create an array containing the simulated readings arrays of each sensor
signals = []
for i in range(len(coords)):
signals.append(
Signal.Signal(d, angle, coords[i], freq, sos, sr, read, noise,
time_on, ping_period, ping_start).signals)
times = numpy.arange(0, read, 1 / sr)
print(times, signals)
graph_signals(times, signals)
cv2.destroyAllWindows()
# Refining Image
r = KMeans.refine_image()
# Generating all shapes and colors along with position of different blocks
arena, shape = Arena_Gen.generate_arena()
death_e, weapons = Death_E.generate_deatheater()
# Start moving bot
d_pos = []
for i in range(5):
for j in range(5):
if death_e[i][j]:
d_pos.append(5*i + j)
Signal.up(ser)
time.sleep(4)
for i in d_pos:
index = []
for j in range(5):
for k in range(5):
if arena[j][k] == 4:
index.append(5*j + k)
corners = Aruco_Webcam.capture(r, ser, cap)
corners = np.asarray(corners)
corners = corners.reshape(4, 2)
mid = 0
for j in range(4):
mid = mid + corners[j]
mid = mid / 4
cx = int(int(mid[0]) * 5 / shape[0])
@author: AZheltov
"""
import Signal
import Modulation
# Моделирование М-последовательностей
psi = Modulation.Modulation(128)
psi.M()
# Моделирование ситуации с 9ю целями
vim = [2000.0, 2000.0, 2030.0, 4000.0, 4000.0, 4030.0, 6000.0, 6000.0, 6030.0]
d = [50.0, 51.0, 51.0, 800.0, 801.0, 801.0, 3000.0, 3001.0, 3001.0]
sig = Signal.Signal(1.0, 0.23, 60.0, 40.0, vim, d, 10.0, 0.0, psi.psi,
'M9Targets')
sig.Generate()
sig.Doppler()
sig.todB()
sig.Surf()
sig.Image()
sig.PlotKD()
sig.PlotDF()
def mover(n, r, src, end, ser, cap, index):
path_x, path_y = Path_mom.path_vec(n, src, end, index)
last_x = path_x[-1]
last_y = path_y[-1]
for i in range(len(path_x) - 1):
mu, md, mid = bot_vec(r, ser, cap)
pv = [path_x[i + 1] - mid[0], path_y[i + 1] - mid[1]]
pv = np.asarray(pv)
bv = mu - md
angle = np.angle(complex(bv[0], bv[1]) / complex(pv[0], pv[1]),
deg=True)
print("new pv:", pv, "midf:", mid)
while (la.norm(
np.asarray([path_x[i + 1] - mid[0], path_y[i + 1] - mid[1]])) >
20 and (path_x[i + 1] != last_x
or path_y[i + 1] != last_y)) or angle > 5 or angle < -5:
print(
"new distance:",
la.norm(
np.asarray(
[path_x[i + 1] - mid[0], path_y[i + 1] - mid[1]])))
bv = mu - md
# print(bv, pv)
# angle = ((np.cross(bv, pv)) / (la.norm(bv) * la.norm(pv))) * 180 / np.pi
angle = np.angle(complex(bv[0], bv[1]) / complex(pv[0], pv[1]),
deg=True)
m = 0.01
m1 = 0.003
c = 0.08
c1 = 0.02
print("angle", angle)
if angle > 5:
Signal.left(ser)
time.sleep(m1 * angle + c1)
Signal.stop(ser)
elif angle < -5:
Signal.right(ser)
time.sleep(-1 * m1 * angle + c1)
Signal.stop(ser)
elif la.norm(
np.asarray([
path_x[i + 1] - mid[0], path_y[i + 1] - mid[1]
])) > 20 and (path_x[i + 1] != last_x
or path_y[i + 1] != last_y):
Signal.fwd(ser)
time.sleep(m * (la.norm(
np.asarray(
[path_x[i + 1] - mid[0], path_y[i + 1] - mid[1]]))) +
c)
Signal.stop(ser)
Signal.stop(ser)
time.sleep(0.03)
mu, md, mid = bot_vec(r, ser, cap)
def run(self):
global x_axis_range, Start, nivel_tanque, channel, overshoot, overshootPercentual
global flag_malha, flag_signal, periodo, offset, conn, valor_entrada, flag_pid, Kp, Ki, Kd, taud, taui, PID
tensao = 0.0
read = 0.0
t_init = time.time()
PID = 0.0
##planta:
##startConnection('10.13.99.69',20081)
##servidor:
startConnection('localhost', 20074)
while (Start):
t = float(time.time() - t_init)
if (flag_malha == 0):
if (flag_signal == 1):
set_point = Signal.waveStep(valor_entrada, offset)
elif (flag_signal == 2):
set_point = Signal.waveSine(valor_entrada, periodo, offset,
t)
elif (flag_signal == 3):
set_point = Signal.waveSquare(valor_entrada, periodo,
offset, t)
elif (flag_signal == 4):
set_point = Signal.waveSawtooth(valor_entrada, periodo,
offset, t)
elif (flag_signal == 5):
set_point = Signal.waveRandom(valor_entrada, periodo,
offset, t)
altura = float(getAltura(channel))
tensao = writeTensao(0, set_point)
v = float(quanser.getTension())
read = float(readSensor(channel))
nivel_tanque = altura # atualiza o nivel do tanque
x_axis_range = float(t) # atualiza o range do grafico
atualizaListas(t, v, read, altura,
set_point) #atualiza os valores plotados
elif (flag_malha == 1):
if (flag_signal == 1):
set_point = Signal.waveStep(valor_entrada, offset)
elif (flag_signal == 2):
set_point = Signal.waveSine(valor_entrada, periodo, offset,
t)
elif (flag_signal == 3):
set_point = Signal.waveSquare(valor_entrada, periodo,
offset, t)
elif (flag_signal == 4):
set_point = Signal.waveSawtooth(valor_entrada, periodo,
offset, t)
elif (flag_signal == 5):
set_point = Signal.waveRandom(valor_entrada, periodo,
offset, t)
if (tipo_controle == 0):
altura = float(getAltura(channel))
saida = controlePID_K(set_point, altura, Kp, Kd, Ki)
elif (tipo_controle == 1):
altura_tanque1 = float(getAltura(0))
altura_tanque2 = float(getAltura(1))
setpoint_ME = controlePID_K_Cascata(
set_point, altura_tanque2, Kp, Kd, Ki, 0)
saida = controlePID_K_Cascata(setpoint_ME, altura_tanque1,
Kp, Kd, Ki, 1)
tensao = writeTensao(0, saida)
v = float(quanser.getTension())
read = float(readSensor(channel))
nivel_tanque = altura # atualiza o nivel do tanque
x_axis_range = float(t) # atualiza o range do grafico
atualizaListas(t, v, read, altura,
set_point) #atualiza os valores plotados
calculaOvershoot(set_point, altura)
atualizaTempos(t)
calculaTempoSubida(set_point, altura, t)
calculaTempoAcomodacao(set_point, altura, t)
endConnection(channel)
sys.exit()
def getSignal(self):
for tic, sym in self._symbols.items():
if Signal.is_near_super_trend_support(sym):
print("[%s] It trading near SuperTrend Support # %0.2f" % (tic, sym.close.iloc[-1]))
"""
import Signal
import Modulation
# Моделирование М-последовательностей
psi = Modulation.Modulation(128)
psi.M()
# Моделирование ситуации с 9ю целями
vim = [2000.0, 2000.0, 2030.0, 4000.0, 4000.0, 4030.0, 6000.0, 6000.0, 6030.0]
d = [50.0, 51.0, 51.0, 800.0, 801.0, 801.0, 3000.0, 3001.0, 3001.0]
sig = Signal.Signal(1.0, 0.23, 60.0, 40.0, vim, d, 10.0, 1.0, psi.psi,
'M9Targets')
sig.Generate()
sig.Doppler()
sig.todB()
sig.Surf()
sig.Image()
sig.PlotKD()
sig.PlotDF()
# Одна цель, изменение скорости
def __init__(self, parent=None):
super(UI_InputSignal, self).__init__(parent)
vbox = QtGui.QVBoxLayout()
label = QtGui.QLabel("Input Signal")
vbox.addWidget(label)
self.Signal = Signal.Signal()
self.StartTimeLabel = QtGui.QLabel("Start Time:")
self.StartTimeInput = QtGui.QLineEdit("-3")
self.StartTimeHBox = QtGui.QHBoxLayout()
self.StartTimeHBox.addWidget(self.StartTimeLabel)
self.StartTimeHBox.addWidget(self.StartTimeInput)
vbox.addLayout(self.StartTimeHBox)
self.EndTimeLabel = QtGui.QLabel("End Time:")
self.EndTimeInput = QtGui.QLineEdit("3")
self.EndTimeHBox = QtGui.QHBoxLayout()
self.EndTimeHBox.addWidget(self.EndTimeLabel)
self.EndTimeHBox.addWidget(self.EndTimeInput)
vbox.addLayout(self.EndTimeHBox)
self.SampleFrequencyLabel = QtGui.QLabel("Sample Frequency:")
self.SampleFrequencyInput = QtGui.QLineEdit("1000")
self.SampleFrequencyHBox = QtGui.QHBoxLayout()
self.SampleFrequencyHBox.addWidget(self.SampleFrequencyLabel)
self.SampleFrequencyHBox.addWidget(self.SampleFrequencyInput)
vbox.addLayout(self.SampleFrequencyHBox)
self.SignalTypeLabel = QtGui.QLabel("Signal Type:")
self.SignalTypeHBox = QtGui.QHBoxLayout()
self.SignalTypeComboBox = QtGui.QComboBox()
self.SignalTypeComboBox.addItem("sine")
self.SignalTypeComboBox.addItem("square")
self.SignalTypeComboBox.addItem("triangle")
self.SignalTypeHBox.addWidget(self.SignalTypeLabel)
self.SignalTypeHBox.addWidget(self.SignalTypeComboBox)
vbox.addLayout(self.SignalTypeHBox)
self.AmplitudeLabel = QtGui.QLabel("Amplitude:")
self.AmplitudeInput = QtGui.QLineEdit("0.75")
self.AmplitudeHBox = QtGui.QHBoxLayout()
self.AmplitudeHBox.addWidget(self.AmplitudeLabel)
self.AmplitudeHBox.addWidget(self.AmplitudeInput)
vbox.addLayout(self.AmplitudeHBox)
self.FrequencyLabel = QtGui.QLabel("Signal Frequency:")
self.FrequencyInput = QtGui.QLineEdit("1")
self.FrequencyHBox = QtGui.QHBoxLayout()
self.FrequencyHBox.addWidget(self.FrequencyLabel)
self.FrequencyHBox.addWidget(self.FrequencyInput)
vbox.addLayout(self.FrequencyHBox)
self.PhaseLabel = QtGui.QLabel("Phase:")
self.PhaseInput = QtGui.QLineEdit("0")
self.PhaseHBox = QtGui.QHBoxLayout()
self.PhaseHBox.addWidget(self.PhaseLabel)
self.PhaseHBox.addWidget(self.PhaseInput)
vbox.addLayout(self.PhaseHBox)
self.DataLabel = QtGui.QLabel("Data Size:")
self.DataInput = QtGui.QLineEdit("0")
self.DataHBox = QtGui.QHBoxLayout()
self.DataHBox.addWidget(self.DataLabel)
self.DataHBox.addWidget(self.DataInput)
vbox.addLayout(self.DataHBox)
self.GraphPushButton = QtGui.QPushButton("Graph It")
vbox.addWidget(self.GraphPushButton)
self.MixSignalsPushButton = QtGui.QPushButton("Mix Signals")
vbox.addWidget(self.MixSignalsPushButton)
self.RemovePushButton = QtGui.QPushButton("Remove Last Graph")
vbox.addWidget(self.RemovePushButton)
self.WriteDataPushButton = QtGui.QPushButton("Write File")
vbox.addWidget(self.WriteDataPushButton)
self.setLayout(vbox)
return
class Test:
testSignal = Signal.Signal()
import SegmentAnalysis as sa
import Signal
import pickle
import os
import multiprocessing
pth = '/home/jbox/Documents/MicroPulse-L-FBHScans-10DegreeWedge/'
dref = pickle.load(open('/home/jbox/Documents/5L32-25mmReferenceBlock.p',
'rb'))
pd = Signal.EstimateProbeDelays(dref['AScans'][0], dref['SamplingFrequency'],
0.6, 25.)
d = os.listdir(pth)
d = [dd for dd in d if dd.endswith('.p')]
# d = d[0:2]
def ImageWeld(x):
print(x)
wld = pickle.load(open(pth + x, 'rb'))
F = sa.FMC(wld['AScans'], wld['SamplingFrequency'])
F.Calibrate(ProbeDelays=pd)
F.FusionLineFocus()
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Jan 7 11:08:56 2021
@author: RileyBallachay
"""
import pandas as pd
import Signal as Signal
path = '/Users/RileyBallachay/Documents/Fifth Year/RNNSystemIdentification/Model Validation/Paper Results.csv'
df = pd.read_csv(path)
df = df.loc[:, ~df.columns.str.contains('Unnamed')]
sig = Signal(inDimension, outDimension, numTrials, numPlots=plots)
suite = unittest.TestSuite()
suite.addTest(Datetime.suite())
suite.addTest(Parameter.suite())
suite.addTest(MarketInfo.suite())
suite.addTest(StockTypeInfo.suite())
suite.addTest(Stock.suite())
suite.addTest(KData.suite())
suite.addTest(Indicator.suite())
suite.addTest(TradeCost.suite())
suite.addTest(Environment.suite())
suite.addTest(Environment.suiteTestCrtEV())
suite.addTest(Condition.suite())
suite.addTest(Condition.suiteTestCrtCN())
suite.addTest(MoneyManager.suite())
suite.addTest(MoneyManager.suiteTestCrtMM())
suite.addTest(Signal.suite())
suite.addTest(Signal.suiteTestCrtSG())
suite.addTest(Stoploss.suite())
suite.addTest(Stoploss.suiteTestCrtST())
suite.addTest(ProfitGoal.suite())
suite.addTest(ProfitGoal.suiteTestCrtPG())
suite.addTest(Slippage.suite())
suite.addTest(Slippage.suiteTestCrtSL())
suite.addTest(AllocateFunds.suite())
unittest.TextTestRunner(verbosity=2).run(suite)
#unittest.main()
length = 300
"""
Get configured do-mpc modules:
"""
A = np.array([
[-0.04, 0.1],
[0.3, -0.09],
])
B = np.array([
[0.09, 0],
[0.04, .05],
])
PRBS_gen = Signal(1, 1, 1)
prbs = PRBS_gen.PRBS()
model = template_model(A, B)
mpc = template_mpc(model, prbs)
simulator = template_simulator(model)
estimator = do_mpc.estimator.StateFeedback(model)
"""
Set initial state
"""
np.random.seed(99)
e = np.full([model.n_x, 1], prbs[0])
x0 = e # Values between +3 and +3 for all states
mpc.x0 = x0
simulator.x0 = x0