def main():
commandline_reminder()
swRouteFile = '../Geant/Geant_sw_route.json'
with open(swRouteFile, 'rb') as ff:
sw_route = json.load(ff)
""" Result for four dataset in Geant"""
print "Generating largeFlow throughRate for four dataset in GEANT network ..."
multi_results = []
ydelta = 0
numrows = 2
numcols = 2
legend = ['Geant_0108', 'Geant_0215', 'Geant_0324', 'Geant_0401']
for infile in infile_lst:
traffic = csvread.csvread(infile)
traffic = postprocess_traffic(traffic)
post_sw_route = process_sw_route(sw_route)
result = largeFlowThrough(traffic, post_sw_route)
multi_results.append(result)
outfile = 'largeFlowThroughSwitch.jpg'
fig = draw.Draw(outfile) # create Draw object
x_axis = sorted([int(sw) for sw in sw_route])
fig.multidraw_bar_subplot(x_axis, multi_results, numrows, numcols, legend)
fig.set_title('Avg largeFlow through for each switch, GEANT')
fig.set_xlabel('Switch ID')
fig.set_ylabel('LargeFlow through (%)')
fig.savefig()
def diy_weapen_callback(self):
global img_name
img_name = draw.Draw()
print(img_name)
doc_num = input("请输入你想要保存的存档编号：(1-4):")
save(img_name, True, doc_num)
animation.model2_skin.refresh(load(True, doc_num)[0])
self.level_1_callback()
def test_draw_from_video(self):
file_name = "test.mp4"
vp = processing.VideoProcessor(file_name)
frames = vp.get_n_stills(12)
ip = processing.ImgProcessor(frames)
color_list = ip.average_list()
draw = d.Draw(color_list)
draw.draw_image("poster", 3900, 5700)
def diy_char_callback(self):
img_name2 = draw.Draw()
image.image_process(img_name2)
damage = input("请分配你创建角色的攻击值：（攻击+生命+速度=300）")
life = input("请分配你创建角色的生命值：（攻击+生命+速度=300）")
speed = 300 - eval(damage) - eval(life)
print("damage,life,speed", damage, life, speed)
doc_num = input("请输入你想要保存的存档编号：(1-4):")
save(img_name2, False, doc_num, damage, life, speed)
animation.diy_skin1.refresh(load(False, doc_num)[0])
self.level_1_callback()
def drawMarker(pos, color=(1, 1, 1), size=1):
"""Draw a marker.
\param pos Marker position
\param color Marker color
\param size Marker size (radius)
"""
try:
drw = getScene().worldObject("Global_Draw")
except KeyError:
drw = draw.Draw(name="Global_Draw")
drw.marker(pos, color, size)
def drawLine(pos1, pos2, color=(1, 1, 1), size=1):
"""Draw a line.
\param pos1 First line point
\param pos2 Second line point
\param color Line color
\param size Line width
"""
try:
drw = getScene().worldObject("Global_Draw")
except KeyError:
drw = draw.Draw(name="Global_Draw")
drw.line(pos1, pos2, color, size)
def run_project(args):
opt = options.Options()
parsed_args = opt.parse(args[1:])
y = parsed_args.slice_yplus
if y:
print('Hello! ', y)
# for key in f.prange.keys():
# c.write_to_file(f.file_path_write+key+".csv",key)
data = draw.Draw()
# data.draw_ur(f.file_path_main + "ur.pdf")
# data.draw_urnorm2(f.file_path_main + "urnorm2.pdf")
data.draw_alpha(f.file_path_main + "alpha.pdf")
def main(infile):
with open(infile, 'rb') as ff:
G = pickle.load(ff)
nodeDegree = {}
for node in G:
swID = node.get_id()
nodeDegree[swID] = len(node.get_connections()) + 1 # plus its own subnet
outfile = 'nodeDegreeinTopo.jpg'
fig = draw.Draw(outfile) # create Draw object
x = sorted([swID for swID in nodeDegree.keys()])
y = [nodeDegree[swID] for swID in x]
fig.draw_bar(x, y)
fig.set_title('Node degrees in topology, Geant')
fig.set_xlabel('Switch ID')
fig.set_ylabel('Degrees')
fig.savefig()
def show_draw_command(self):
try:
patern = "^(0$|-?[1-9]\d*(\.\d*[1-9]$)?|-?0\.\d*[1-9])$"
str_a = self.input_a.get()
str_b = self.input_b.get()
str_c = self.input_c.get()
str_d = self.input_d.get()
str_y = self.input_y.get()
str_start_point = self.input_start_point.get()
str_finish_point = self.input_finish_point.get()
float_a = float(str_a) if (re.match(patern, str_a)
is not None) else 0.0
float_b = float(str_b) if (re.match(patern, str_b)
is not None) else 0.0
float_c = float(str_c) if (re.match(patern, str_c)
is not None) else 0.0
float_d = float(str_d) if (re.match(patern, str_d)
is not None) else 0.0
float_y = float(str_y) if (re.match(patern, str_y)
is not None) else 0.0
float_start_point = float(str_start_point) if (re.match(
patern, str_start_point) is not None) else 0.0
float_finish_point = float(str_finish_point) if (re.match(
patern, str_finish_point) is not None) else 0.0
if (float_finish_point < float_start_point):
temp = float_finish_point
float_finish_point = float_start_point
float_start_point = temp
bool_is_sigma = self.is_sigma.get()
self.intersection_points = points.SearchIntersectionPoint(
float_a, float_b, float_c, float_d,
bool_is_sigma).return_list_intersection_points(
float_start_point, float_finish_point, float_y)
draw.Draw(float_a, float_b, float_c,
float_d).create_draw(float_start_point,
float_finish_point, float_y,
self.intersection_points)
except BaseException as ex:
messagebox.showinfo("Error", ex.args)
def beam_search(self, beam_width):
start_time = time.process_time()
#this is the priority queue, prepopulated with the start node
#the first number is f(state): the total cost up to this point
#plus the heuristic value of this point
#the second number is the cost up to this point, and the third number is
#the number of nodes we have explored before getting here
pq = [(self.h(self.model.startState()), 0, 0, self.model.startState())]
#the future explored set, currently empty
#this has to be a dict so there is constant time lookup of whether a node is explored
#else on large networks where the explored set is very long, each node we check whether
#it has been explored is O(N) which is unacceptable
explored = {}
#create a dict that will store the parent of each node as it is visited
parents = {}
parents[self.model.startState()] = self.model.startState(), 0
if draw:
d = dr.Draw(self.model.startState())
d.drawGoals(self.model.goalStates())
else:
d = None
path_found = False
max_frontier_size = 1
while(len(pq) > 0 and not path_found):
#pop a node from the pq
heuristic_cost, cost_to_now, priority, current = heapq.heappop(pq)
if draw:
d.visitPoint(current)
#check if the neighbor is a goal
if self.model.goal(current):
end_time = time.process_time()
path_found = True
self.output_ans(current, start_time, end_time, parents, max_frontier_size, path_found, d)
break
if(current in explored):
continue
self.nodecount += 1
explored[current] = 1
#expand the node
actions = self.model.actions(current)
for action in actions:
neighbor = self.model.result(current, action)
#store away the parent of a possible neighbor, plus the cost to get there
if neighbor not in explored:
if draw:
d.explorePoint(neighbor)
#else add them to the queue if they are not seen yet
path_cost = cost_to_now + self.model.cost(current, action)
heuristic_cost = path_cost + self.h(neighbor)
heapq.heappush(pq, (heuristic_cost, path_cost, self.next_id, neighbor) )
self.next_id += 1
if neighbor not in parents or parents[neighbor][2] > path_cost:
parents[neighbor] = current, self.model.cost(current, action), path_cost
max_frontier_size = max(max_frontier_size, len(pq))
#print("Len before pruning:", len(pq))
pq = self.prune(pq, beam_width)
#print("Len after pruning:", len(pq))
if not path_found:
end_time = time.process_time()
self.output_ans(self.model.startState(), start_time, end_time, parents, max_frontier_size, path_found, d)
if draw:
input()
d.reset()
optimizer = GradDesc(net_cfg['optimizer'][1])
elif net_cfg['optimizer'][0] == 'decay_gradient':
optimizer = DecayGradDesc(net_cfg['optimizer'][1],
net_cfg['optimizer'][2])
net = Net(layer_list, cost_func, optimizer, one_hot=net_cfg['one_hot'])
return net
if __name__ == '__main__':
cfg = util.config('config.1.json')
one_hot = cfg['net']['one_hot']
x = util.read_data(cfg['dataset']['x_path'])
y = util.read_data(cfg['dataset']['y_path'])
# x, y = x[38:44], y[38:44]
x_test_mg, x_test = util.generate_test_data(x)
draw = draw.Draw(x, y, x_test_mg, one_hot=one_hot, C=cfg['class'])
net = establish_net(cfg['net'], x)
if one_hot:
y = util.encode_onehot(y, cfg['class'])
sample_num = x.shape[0]
batch_size = cfg['batch_size']
for epoch in range(100000):
cost_avg = 0
for it in range(sample_num // batch_size):
beg_idx = it * batch_size
end_idx = sample_num if beg_idx + batch_size > sample_num else beg_idx + batch_size
x_train = x[beg_idx:end_idx]
y_train = y[beg_idx:end_idx]
cost = net.train(x_train, y_train)
# if (epoch * (sample_num // batch_size) + it) % 50 == 0:
# draw.drawLoss(epoch * (sample_num // batch_size) + it, cost)
#!/usr/local/bin/python3
import random
import turtle as my_turtle
import color_bucket
import draw
color_bucket_obj = color_bucket.ColorBucket()
draw_obj = draw.Draw()
print(color_bucket_obj.colors)
print(color_bucket.ColorBucket.description)
my_turtle.Screen().bgcolor('black')
while True:
size = random.choice(range(5, 50))
x = random.choice(range(-200, 200))
y = random.choice(range(-200, 200))
draw_obj.draw_star(my_turtle, size, color_bucket_obj.get_color(), x, y, 8)
def close_application_command(self):
draw.Draw().close_draw()
self.__app.destroy()
def ExecuteTrendFollowing(self, exchange, moneta, tool, risultato):
#Attention: static stoploss and dynamic stoploss cannot be activated simultaneously
tool.attivazione_stoploss_statico = 0 #with zero not activated, with 1 activated
tool.attivazione_stoploss_dinamico = 1 # with zero not activated, with 1 activated
tool.profitto = 0.4 #minimum percentage of profit
tool.stoploss_1 = 0.8 #percentage of stoploss
tool.stoploss_2 = 2.0 #second level stoploss percentage (not active for now)
tool.commissioni = 0.25 #percentage of fees in buy and sell
tool.nrtransizioni = 2000 #do not use
tool.stoploss_dinamico_moltiplicatore = 0.997 #multiplier of the trailing stop
tool.stoploss_dinamico_formula = "row.close * tool.stoploss_dinamico_moltiplicatore" #formula per il calcolo dello stoploss dinamico (trailing stop)
tool.attivazione_stoploss_dinamico_limiti = 1 #with zero not activated, with 1 activated. It works if dynamic stoploss is activated
tool.stoploss_dinamico_min_profitto = 0.30 #minimum profit compared to lastbuy if activated stoploss_dinamico_limiti
tool.stoploss_dinamico_max_perdita = 2 #max loss in percentage compared to lastbuy if activated stoploss_dinamico_limiti
tool.hours = 36 #timedelta from now
tool.periodo = '5m' #candlestick timeframe
self.nome = " Test Strategy Trend Following "
candle = candlestick.Candlestick()
self.df1 = candle.getCandle(exchange, moneta, tool.hours, tool.periodo)
moneta = moneta
exchange = exchange
self.df1 = self.df1.apply(pd.to_numeric)
#-------------Indicators and oscillators
self.df1['rsi'] = ta.RSI(self.df1.close.values, timeperiod=14)
self.df1['adx'] = ta.ADX(self.df1['high'].values,
self.df1['low'].values,
self.df1['close'].values,
timeperiod=14)
# Bollinger bands with qtpylib--------------------------------------
""" bollinger = qt.bollinger_bands(qt.typical_price(self.df1), window=20, stds=2)
self.df1['lower'] = bollinger['lower']
self.df1['middle'] = bollinger['mid']
self.df1['upper'] = bollinger['upper'] """
#------------------------------------------------------------------
# Bollinger bands with TA library
self.df1['upper'], self.df1['middle'], self.df1['lower'] = ta.BBANDS(
self.df1['close'].values, timeperiod=5,nbdevup=1,nbdevdn=1, matype=1)
self.df1['upper2'], self.df1['middle2'], self.df1[
'lower2'] = ta.BBANDS(self.df1['close'].values, timeperiod=5,nbdevup=1.6,nbdevdn=1.6, matype=1)
self.df1['upper3'], self.df1['middle3'], self.df1[
'lower3'] = ta.BBANDS(self.df1['close'].values, timeperiod=5,nbdevup=2,nbdevdn=2, matype=1)
#------------------------------------------------------------------
self.df1['PrezzoMed'] = self.df1['close'].mean()
self.df1['STDDEV'] = ta.STDDEV(self.df1['close'].values,
timeperiod=15,
nbdev=1)
self.df1['macd'], self.df1['macdsignal'], self.df1[
'macdhist'] = ta.MACD(self.df1.close.values,
fastperiod=12,
slowperiod=26,
signalperiod=9)
self.df1['minus_di'] = ta.MINUS_DI(self.df1['high'].values,
self.df1['low'].values,
self.df1['close'].values,
timeperiod=25)
self.df1['plus_di'] = ta.PLUS_DI(self.df1['high'].values,
self.df1['low'].values,
self.df1['close'].values,
timeperiod=25)
self.df1['sar'] = ta.SAR(self.df1['high'].values,
self.df1['low'].values,
acceleration=0,
maximum=0)
self.df1['mom'] = ta.MOM(self.df1['close'].values, timeperiod=14)
self.df1['atr'] = ta.ATR(self.df1['high'].values,
self.df1['low'].values,
self.df1['close'].values,
timeperiod=14)
self.df1['ema'] = ta.EMA(self.df1['close'].values, timeperiod=20)
self.df1['ema1'] = ta.EMA(self.df1['close'].values, timeperiod=28)
self.df1['ema2'] = ta.EMA(self.df1['close'].values, timeperiod=35)
self.df1['ema3'] = ta.EMA(self.df1['close'].values, timeperiod=48)
self.df1['ema50'] = ta.EMA(self.df1['close'].values, timeperiod=50)
self.df1['dema20']= ta.DEMA(self.df1['close'].values, timeperiod=20)
self.df1['dema50']= ta.DEMA(self.df1['close'].values, timeperiod=50)
self.df1['tema20']= ta.TEMA(self.df1['close'].values, timeperiod=5)
self.df1['tema50']= ta.TEMA(self.df1['close'].values, timeperiod=20)
self.df1['cci'] = ta.CCI(self.df1['high'].values,
self.df1['low'].values,
self.df1['close'].values,
timeperiod=14)
#ta lib moving average
self.df1['shortma']= ta.SMA(self.df1['close'].values, timeperiod=10)
self.df1['longma']= ta.SMA(self.df1['close'].values, timeperiod=20)
# MFI
self.df1['mfi'] = ta.MFI(self.df1['high'].values,self.df1['low'].values, self.df1['close'].values, self.df1['volume'].values, timeperiod=14)
# Stoch
self.df1['slowk'],self.df1['slowd'] = ta.STOCH(self.df1['high'].values,self.df1['low'].values, self.df1['close'].values)
# Hammer: values [0, 100] - pattern recognised
self.df1['CDLHAMMER'] = ta.CDLHAMMER(self.df1['open'].values,self.df1['high'].values,self.df1['low'].values, self.df1['close'].values)
# Inverted Hammer: values
self.df1['CDLINVERTEDHAMMER'] = ta.CDLINVERTEDHAMMER(self.df1['open'].values,self.df1['high'].values,self.df1['low'].values, self.df1['close'].values)
# Engulfing
self.df1['CDLENGULFING'] = ta.CDLENGULFING(self.df1['open'].values,self.df1['high'].values,self.df1['low'].values, self.df1['close'].values)
# Hiddake
self.df1['CDLHIKKAKE'] = ta.CDLHIKKAKE(self.df1['open'].values,self.df1['high'].values,self.df1['low'].values, self.df1['close'].values)
# Doji
self.df1['CDLDOJI'] = ta.CDLDOJI(self.df1['open'].values,self.df1['high'].values,self.df1['low'].values, self.df1['close'].values)
# DojiStar
self.df1['CDLDOJISTAR'] = ta.CDLDOJISTAR(self.df1['open'].values,self.df1['high'].values,self.df1['low'].values, self.df1['close'].values)
# Stoch fast
self.df1['fastk'], self.df1['fastd'] = ta.STOCHF(self.df1.high.values, self.df1.low.values, self.df1.close.values)
# Inverse Fisher transform on RSI, values [-1.0, 1.0] (https://goo.gl/2JGGoy)
rsi = 0.1 * (self.df1['rsi'] - 50)
self.df1['fisher_rsi'] =(np.exp(2 * rsi) - 1) / (np.exp(2 * rsi) + 1)
# EMA - Exponential Moving Average
self.df1['ema5'] = ta.EMA(self.df1.close.values, timeperiod=5)
self.df1['ema10'] = ta.EMA(self.df1.close.values, timeperiod=10)
self.df1['ema50'] = ta.EMA(self.df1.close.values, timeperiod=50)
self.df1['ema100'] = ta.EMA(self.df1.close.values, timeperiod=100)
# SMA - Simple Moving Average
self.df1['sma'] = ta.SMA(self.df1.close.values, timeperiod=40)
#-----------------------------------------------------------------------
self.df1['Sellsignal'] = 0
self.df1['Buysignal'] = 0
#---------------------example 1 strategy buy and sell ----------------------------------------
#-------------Buy conditions----------------------------------------------------------
""" self.df1.loc[(((
(self.df1['macd'] > self.df1['macdsignal']) &
(self.df1['cci'] <= -50.0)))),'BuySignal'] = 1 """
#-------------Sell conditions----------------------------------------------------------
""" self.df1.loc[(((
(self.df1['macd'] < self.df1['macdsignal']) &
(self.df1['cci'] >= 100.0)))),'SellSignal'] = -1 """
#------------------------example 2 strategy buy and sell---------------------------------------
#-------------Buy conditions----------------------------------------------------------
""" self.df1.loc[(((
(self.df1['adx'] > 25) &
(self.df1['mom'] < 0) &
(self.df1['minus_di'] > 25) &
(self.df1['plus_di'] < self.df1['minus_di'])))),'BuySignal'] = 1 """
#-------------Sell conditions----------------------------------------------------------
""" self.df1.loc[(((
(self.df1['adx'] > 25) &
(self.df1['mom'] > 0) &
(self.df1['minus_di'] > 25) &
(self.df1['plus_di'] > self.df1['minus_di'])))),'SellSignal'] = -1 """
# --------------------------------------------------------------------------
#example 3 strategy macd and midprice with qtpylib Sell & Buy
#-------------Sell conditions----------------------------------------------------------
self.df1.loc[(((
self.qt.crossed_below(self.df1['macd'], self.df1['macdsignal'])))), 'Sellsignal'] = -1
#-------------Buy conditions----------------------------------------------------------
self.df1.loc[(((
self.qt.crossed_above(self.df1['macd'], self.df1['macdsignal'])) & (self.df1['close'] < self.df1['PrezzoMed']))), 'Buysignal'] = 1
# --------------------------------------------------------------------------
#example 4 strategy Bollinger Bands with rsi
#-------------Buy conditions----------------------------------------------------------
""" self.df1.loc[
((self.df1['close'] < self.df1['lower']) &
(self.df1['rsi'] < 30)
),'Buysignal'] = 1
#-------------Sell conditions----------------------------------------------------------
self.df1.loc[
((self.df1['close']>self.df1['upper']) |
(self.df1['rsi'] > 70)
),'Sellsignal'] = -1 """
#---------------------------------------------------------------------------
#example 5 Bollinger Bands with rsi qtpylib library Sell & Buy
#-------------Buy conditions----------------------------------------------------------
""" self.df1.loc[
(
(self.df1['rsi'] < 30) &
(self.df1['close'] < self.df1['lower'])
),
'Buysignal'] = 1
#------------Sell conditions--------------------------------------------
self.df1.loc[
(
(self.df1['rsi'] > 70)
),
'Sellsignal'] = -1 """
# --------------------------------------------------------------------------
#example 6 strategy longma and shortma with qtpylib Sell & Buy
#-------------Sell conditions----------------------------------------------------------
""" self.df1.loc[(((
self.qt.crossed_below(self.df1['shortma'], self.df1['longma'])))), 'Sellsignal'] = -1
#-------------Buy and Sell conditions----------------------------------------------------------
self.df1.loc[(((
self.qt.crossed_above(self.df1['shortma'], self.df1['longma'])) & (self.df1['close'] < self.df1['PrezzoMed']))), 'Buysignal'] = 1
"""
#--------------------------------------------------------------------------
#example 7 strategy with qtpylib and TA-lib Sell & Buy
#-------------Buy conditions--------------------------------
""" self.df1.loc[
(
(self.df1['rsi'] < 28) &
(self.df1['rsi'] > 0) &
(self.df1['close'] < self.df1['sma']) &
(self.df1['fisher_rsi'] < -0.94) &
(self.df1['mfi'] < 16.0) &
(
(self.df1['ema50'] > self.df1['ema100']) |
(qt.crossed_above(self.df1['ema5'], self.df1['ema10']))
) &
(self.df1['fastd'] > self.df1['fastk']) &
(self.df1['fastd'] > 0)
),
'Buysignal'] = 1
#------------Sell conditions---------------------------------------------
self.df1.loc[
(
(self.df1['sar'] > self.df1['close']) &
(self.df1['fisher_rsi'] > 0.3)
),
'Sellsignal'] = -1 """
# ----------------------------------------------------------------------
#example 8 strategy - multiple indicators with pattern indicator HAMMER
#------------------Sell conditions--------------------------------------
""" self.df1.loc[
(
(self.df1['rsi'] < 30) &
(self.df1['slowk'] < 20) &
(self.df1['lower'] > self.df1['close']) &
(self.df1['CDLHAMMER'] == 100)
),
'Buysignal'] = 1
#---------------Buy conditions------------------------------------------
self.df1.loc[
(
(self.df1['sar'] > self.df1['close']) &
(self.df1['fisher_rsi'] > 0.3)
),
'Sellsignal'] = -1 """
# ----------------------------------------------------------------------
#example 9 strategy pattern strategy ENGULFING strategy Sell and Buy
#---------------Sell conditions------------------------------------------
""" print(self.df1['CDLENGULFING'].values)
self.df1.loc[
(
(self.df1['CDLENGULFING'].values < -99)
),
'Buysignal'] = 1
#---------------Buy conditions------------------------------------------
self.df1.loc[
(
(self.df1['CDLENGULFING'].values > 99)
),
'Sellsignal'] = -1 """
#---------------------------------------------------------------------------------
#example 10 strategy Bollinger Bands with rsi with technical indicators Sell & Buy
"""risultati_index_buy = self.df1.index[self.df1['CDLINVERTEDHAMMER'] == 100].tolist()
risultato_last_index = self.df1.index[-1]
if ((risultati_index_buy == None) or (risultato_last_index == None) or (risultato_last_index == '') or (len(risultati_index_buy) == 0)):
print('None Result')
else:
risultato_last_index = str(risultati_index_buy[-1])
risultato_last_index = risultato_last_index[:-3]
risultato_last_index = (str(risultato_last_index))[:-3] #rimozione dei tre caratteri
data1 = datetime.fromtimestamp(int(risultato_last_index))
data2 = datetime.fromtimestamp(int(risultato_last_index))
print(data2,data1)
print(self.df1)
#------------------Buy conditions----------------------------------
self.df1.loc[(
self.df1['CDLINVERTEDHAMMER'] == 100
),'CDLHIKKAKE_CLOSE'] = self.df1['close']
self.df1.loc[
(
(self.df1['close'] < self.df1['lower3'])
)
,'Buysignal'] = 1
#------------------Sell conditions----------------------------------
self.df1.loc[
(
self.qt.crossed_above(self.df1['dema20'], self.df1['dema50'])
),'Sellsignal'] = -1
"""
#----------------------------------------------------------------------
#example 11 strategy DOJISTAR strategy Sell and Buy
#---------------Buy conditions------------------------------------------
""" self.df1.loc[
(
(self.df1['CDLDOJISTAR'].values == -100)
),
'Buysignal'] = 1
#---------------Sell conditions----------------------------------------
self.df1.loc[
(
(self.df1['CDLHIKKAKE'].values == 200)
),
'Sellsignal'] = -1 """
#-----------------------------------------------------------------------
#example 12 strategy DEMA of EMA BuySignal and SellSignal
#---------------Buy conditions------------------------------------------
""" self.df1.loc[(((
self.qt.crossed_below(self.df1['ema50'], self.df1['dema200'])))), 'BuySignal'] = 1
#---------------Sell conditions------------------------------------------
self.df1.loc[
(
(self.df1['CDLHIKKAKE'].values > 99)
),
'Sellsignal'] = -1 """
#---------------------------trailing stoploss---------------------------
#example 1
#tool.stoploss_dinamico_formula = "row.close * tool.stoploss_dinamico_moltiplicatore" #formula for calculating dynamic stoploss (trailing stop)
#example 2
tool.stoploss_dinamico_formula = "row.ema3"
x = []
y = []
balance = []
lower_vect = []
lower2_vect = []
upper_vect = []
upper2_vect = []
pattern_vect = []
close_vect = []
buysignal_vect = []
sellsignal_vect = []
prezzmed_vect = []
stdev_vect = []
stoplosssignal_vect = []
stoplossprezzo_vect = []
ema_vect = []
ema_long_vect = []
ema_short_vect = []
date = []
volume_vect = []
macd_vect = []
macd_signal_vect = []
macd_hist_vect = []
atr_vect = []
rsi_vect = []
i = 0
for row in self.df1.itertuples():
a = row.Index / 1000.0
b = datetime.fromtimestamp(a)
self.stoploss = self.getStoploss(row, i, tool)
logging.info("-----------Loop line processing " + str(i))
logging.info("1) self.stoploss value = " + str(self.stoploss))
if (i > 0):
stoplossprezzo_vect.append(self.stoplossprezzo)
logging.info(
"2) Value of i greater than zero not first loop for i =" +
str(i))
logging.info("2.1) Value of self.stoplossprezzo = " +
str(self.stoplossprezzo))
else:
self.stoplossprezzo = row.close * 0.99
logging.info(
"2) Value of i equal to zero first loop for i = " + str(i))
stoplossprezzo_vect.append(self.stoplossprezzo)
logging.info("2.1) Value of self.stoplossprezzo = " +
str(self.stoplossprezzo))
if (self.stoploss == 1):
logging.info(
"3) self.stoploss value = 1 after getstoploss method ")
x.append(i)
y.append(row.close)
if (row.Sellsignal == 0
and self.stoploss == 0) or (row.Sellsignal == 1
and self.stoploss == 1):
logging.info("4) Value of self.stoploss before If for sell " +
str(self.stoploss))
logging.info("4.1) Value of row.Sellsignal " +
str(row.Sellsignal))
sellsignal_vect.append(np.nan)
stoplosssignal_vect.append(np.nan)
else:
if (self.stoploss == 1):
logging.info("5) self.stoploss value = 1 else before if ")
logging.info(
"5.1) Indication of sell in presence of self.stoploss = 1"
)
if (self.sell == 0) and (self.buy == 1):
logging.info(
"5.2) Sell with self.stoploss = 1 self.stoploss = "
+ str(self.stoploss))
logging.info(
"5.2.1) Sell with self.stoploss = 1 self.sell = " +
str(self.sell))
logging.info(
"5.2.2) Sell with self.stoploss = 1 self.buy = " +
str(self.buy))
#increases variable by 1 num_of_trades by one
self.nr_of_trades = self.nr_of_trades+1
sellsignal_vect.append(row.close)
stoplosssignal_vect.append(row.close)
percentualecommissioni = (
float(row.close) / 100) * float(tool.commissioni)
logging.info(
"5.3) Percentage of fees in presence of self.stoploss = 1"
+ str(percentualecommissioni))
balance.append(
[row.close - (percentualecommissioni), 1])
if ((row.close - percentualecommissioni) > self.lastbuy):
self.nr_positive_trades = self.nr_positive_trades +1
elif ((row.close - percentualecommissioni) < self.lastbuy):
self.nr_negative_trades = self.nr_negative_trades +1
else:
print('Non risulta positiva ne negativa')
self.totalecommissioni = self.totalecommissioni + percentualecommissioni
logging.info(
"5.4) Total fees in presence of self.stoploss = 1 "
+ str(self.totalecommissioni))
self.sell = 1
self.buy = 0
self.stoploss = 0
logging.info(
"5.5) Assign value zero to self.stoploss = " +
str(self.stoploss))
logging.info("5.6) Assign value 1 to self.sell = " +
str(self.sell))
logging.info("5.7) Assign value zero to self.buy = " +
str(self.buy))
else:
sellsignal_vect.append(np.nan)
stoplosssignal_vect.append(np.nan)
self.stoploss = 0
else:
stoplosssignal_vect.append(np.nan)
if ((self.sell == 0) and (self.buy == 1)
and (tool.attivazione_stoploss_dinamico == 0)):
logging.info(
"6.0) Sell normal not in the presence of dynamic stoploss"
)
logging.info("6.1) Value of self.sell: " +
str(self.sell))
logging.info("6.2) Value of self.buy: " +
str(self.buy))
logging.info(
"6.3) Dynamic stoploss activation parameter value: "
+ str(tool.attivazione_stoploss_dinamico))
price1 = float(self.lastbuy) + (
(float(self.lastbuy)) / 100) * float(tool.profitto)
logging.info("6.4) Value of self.lastbuy: " +
str(self.lastbuy))
logging.info("6.5) Price1 price of sell: " +
str(price1))
logging.info("6.6) Profit parameters: " +
str(tool.profitto))
if (float(row.close) > float(price1)):
logging.info(
"6.7) Sell in presence of row.close greater than value of price1"
)
logging.info("6.8) Value of row.close: " +
str(row.close))
logging.info("6.9) Value of sell price: " +
str(price1))
#increases variable by 1 num_of_trades by one
self.nr_positive_trades = self.nr_positive_trades +1
sellsignal_vect.append(row.close)
percentualecommissioni = (float(
row.close) / 100) * float(tool.commissioni)
logging.info(
"6.9.1) Percentage of fees in presence of self.stoploss = 1 "
+ str(percentualecommissioni))
balance.append(
[row.close - (percentualecommissioni), 1])
self.totalecommissioni = self.totalecommissioni + percentualecommissioni
logging.info(
"6.9.2) Total of fees in presence of self.stoploss = 1"
+ str(self.totalecommissioni))
self.sell = 1
self.buy = 0
self.stoploss = 0
logging.info(
"6.9.3) Assign value zero to self.stoploss = "
+ str(self.stoploss))
logging.info(
"6.9.4) Assign value 1 to self.sell = " +
str(self.sell))
logging.info(
"6.9.5) Assign value 0 to self.buy = " +
str(self.buy))
else:
sellsignal_vect.append(np.nan)
else:
sellsignal_vect.append(np.nan)
if ((row.Buysignal == 0 or row.Buysignal == '0')):
logging.info(
"7) Value of self.stoploss in if row.BuySignal = 0 " +
str(self.stoploss))
logging.info("7.1) Value of row.Buysignal " +
str(row.Buysignal))
buysignal_vect.append(np.nan)
else:
if ((row.Buysignal == 1 or row.Buysignal == '1')):
logging.info("8) Value of row.Buysignal " +
str(row.Buysignal))
if (self.buy == '0' or self.buy == 0):
logging.info(
"8.1) Buy in presence of self.stoploss = " +
str(self.stoploss))
logging.info("8.2) Value of self.sell = " +
str(self.sell))
logging.info("8.3) Value of self.buy = " +
str(self.buy))
buysignal_vect.append(row.close)
percentualecommissioni = (
float(row.close) / 100) * float(tool.commissioni)
logging.info(
"8.4) Percentage of fees in presence of self.stoploss = 1 "
+ str(percentualecommissioni))
self.totalecommissioni = self.totalecommissioni + percentualecommissioni
logging.info(
"8.5) Total of fees in presence of stoploss = 1" +
str(self.totalecommissioni))
balance.append([(-row.close - percentualecommissioni),
0])
self.buy = 1
self.sell = 0
logging.info(
"8.5.1) Assign value zero to self.stoploss = " +
str(self.stoploss))
logging.info(
"8.5.2) Assign value zero to self.sell = " +
str(self.sell))
logging.info("8.5.3) Assign value 1 to self.buy = " +
str(self.buy))
if (tool.attivazione_stoploss_dinamico == 1):
logging.info(
"8.6) Value of tool.attivazione_stoploss_dinamico equal to : "
+ str(tool.attivazione_stoploss_dinamico))
self.stoplossprezzo = eval(
tool.stoploss_dinamico_formula)
logging.info(
"8.6.1) Value of self.stoplossprezzo " +
str(self.stoplossprezzo))
else:
self.stoplossprezzo = (row.close - (
(row.close / 100) * tool.stoploss_1))
logging.info(
"8.7) Value of self.stoplossprezzo with tool.attivazione_stoploss_dinamico equal to 1 = "
+ str(self.stoplossprezzo))
self.lastbuy = row.close
logging.info("8.8) Value of self.lastbuy" +
str(self.lastbuy))
logging.info("8.9.0) Value of self.stoploss = " +
str(self.stoploss))
logging.info("8.9.1) Value of self.sell = " +
str(self.sell))
logging.info("8.9.2) Value of self.buy = " +
str(self.buy))
logging.info("8.9.3) Value of self.stoplossprezzo = " +
str(self.stoplossprezzo))
logging.info("8.9.4) Value of self.lastbuy = " +
str(self.lastbuy))
logging.info(
"8.9.5) Value of tool.attivazione_stoploss_dinamico = "
+ str(tool.attivazione_stoploss_dinamico))
logging.info(
"8.9.6) Value of tool.attivazione_stoploss_statico = "
+ str(tool.attivazione_stoploss_statico))
else:
buysignal_vect.append(np.nan)
else:
buysignal_vect.append(np.nan)
#add indicators,oscillators and others
prezzmed_vect.append(row.PrezzoMed)
stdev_vect.append(row.STDDEV)
ema_vect.append(row.ema3)
date.append(b)
rsi_vect.append(row.rsi)
#pattern_vect.append(row.CDLHIKKAKE_CLOSE)
volume_vect.append(row.volume)
lower2_vect.append(row.lower2)
upper2_vect.append(row.upper2)
ema_long_vect.append(row.tema50)
ema_short_vect.append(row.tema20)
lower_vect.append(row.lower)
upper_vect.append(row.upper)
macd_vect.append(row.macd)
macd_signal_vect.append(row.macdsignal)
macd_hist_vect.append(row.macdhist)
atr_vect.append(row.atr)
i = i + 1
self.valorestrategia = self.getValoreStrategia(balance)
tool.setVisualizzaGrafico(1)
if (tool.visualizzagrafico == 1 or tool.visualizzagrafico == '1'):
ds = draw.Draw()
ds.setNrGrafici(2)
ds.draw_graphic(moneta, x, y, self.nr_of_trades, self.nr_positive_trades,self.nr_negative_trades, buysignal_vect, sellsignal_vect,
prezzmed_vect, stoplossprezzo_vect, stdev_vect,
self.nome, self.valorestrategia, date, ema_vect,
rsi_vect,pattern_vect,volume_vect,lower2_vect,
upper2_vect,ema_short_vect,ema_long_vect,lower_vect,upper_vect,macd_vect,macd_signal_vect,macd_hist_vect,atr_vect)
def GoToDo():
nonlocal switcher
while True:
#Draw the list
os.system('clear')
a = draw.Draw(today.todolist, today.name)
b = draw.Draw(future.todolist, future.name)
c = draw.Draw(post.todolist, post.name)
d = draw.Draw(comp.todolist, comp.name)
a.draw_TODO()
b.draw_TODO()
c.draw_TODO()
d.draw_TODO()
print("-" * 40)
#Here is a problem
if switcher % 4 == 0:
try:
future.todolist[future.cursor[0]][2] = '[ ]'
except:
pass
current = today
print("Your Current position: Today")
elif switcher % 4 == 1:
try:
today.todolist[today.cursor[0]][2] = '[ ]'
except:
pass
current = future
print("Your Current position: Future")
elif switcher % 4 == 2:
try:
post.todolist[post.cursor[0]][2] = '[ ]'
except:
pass
current = post
print("Your Current position: Gone")
elif switcher % 4 == 3:
try:
comp.todolist[post.cursor[0]][2] = '[ ]'
except:
pass
current = comp
print("Your Current position: Complete")
print("* * * * * * * Description * * * * * * *\n")
try:
print("->", current.todolist[current.cursor[0]][3])
except:
print("Nothing here")
print("- - - - - - - - - - - - - - - - - - - -")
action = useraction.get_user_action()
if action == 'Switch':
switcher += 1
continue
if action in useraction.moves:
while True:
try:
movement.moves(action, current)
break
except IndexError:
print("Uhoh..Out of Range..")
break
continue
else:
op = operation.Operation(current, post, comp, future, today)
if op.execution(action, userid) == 0:
return False
def test_draw(self):
draw = d.Draw(["#A250B2", "#B2B250", "#5054B2"])
draw.draw_image("test", 1000, 1000)
while True:
tasks = [
fetchData('http://www.xm.com', pd.Xm),
fetchData(
'http://biz.aetoscg.com/content/get-ratio!callback.json?ln=0&group=TOOL&callback=showToolsLAS&_=1458550863266',
pd.Atos),
fetchData(calendar_url, pd.Calendar)
]
future = asyncio.Future()
asyncio.ensure_future(pd.Database(future))
try:
loop.run_until_complete(future)
engine = future.result()
loop.run_until_complete(asyncio.wait(tasks))
except Exception:
print('exception happend.')
loop.run_until_complete(pd.CloseDB())
continue
if engine:
loop.run_until_complete(draw.Draw(engine))
n += 1
print(n, ' rounds completed.')
time.sleep(600)
timenow = dt.now() - delta
if timenow.isoweekday() == 6:
break
loop.close()
else:
return
def predict(self, x):
y_ = self.forward(x)
return y_
if __name__ == '__main__':
x = util.read_data('ex4x.dat')
y = util.read_data('ex4y.dat', squeeze=True)
x_avg, x_std = util.compute_normal_param(x)
x1_test_mg, x2_test_mg, x_test = util.generate_test_data(x)
draw = draw.Draw(x, y, x1_test_mg, x2_test_mg)
sub1 = SubConstant(x_avg)
div1 = DivConstant(x_std)
fc1 = Linear(2, 10)
active1 = Sigmoid()
fc2 = Linear(10, 1)
active2 = Sigmoid()
layer_list = [sub1, div1, fc1, active1, fc2, active2]
cost_func = LeastSquare()
optimizer = GradDesc(0.1)
net = Net(layer_list, cost_func, optimizer)
sample_num = x.shape[0]
batch_size = 1
for epoch in range(1000):
# 'ytick.labelsize': 16,
# # 'text.usetex': True,
# #'text.latex.unicode': True,
# 'figure.figsize': [10,10]}
#matplotlib.rcParams.update(params)
fig = plt.figure(figsize=(14, 14))
ax1 = fig.add_subplot(1, 1, 1)
plt.grid(False)
plt.style.use("grayscale")
mat_valor = cv2.imread("roi.png")
#plt.show()
print("aqui")
ax1.clear()
pen = draw.Draw(ax1)
pen.mat_grid(2, 2, 10, 10, mat_valor[:, :0])
print(mat_valor)
#plt.imshow(mat_valor)
plt.savefig("mat.png", dpi=90)
plt.show()
# kernel=np.ones((3,3))/9
# ft=cv2.filter2D(mat_valor,-1,kernel)
# plt.imshow(ft)
# plt.show()
#ax1.clear()
#pen=draw.Draw(ax1)
#pen.mat_grid(2,2,3,3,mat_valor)
#plt.show()
x = self.norm(x)
x = self.fc1(x)
x = torch.sigmoid(x)
x = self.fc2(x)
x = torch.sigmoid(x)
return x
if __name__ == '__main__':
x = util.read_data('ex4x.dat', use_torch=True)
y = util.read_data('ex4y.dat', use_torch=True)
x_avg, x_std = util.compute_normal_param(x, use_torch=True)
x1_test_mg, x2_test_mg, x_test = util.generate_test_data(x, use_torch=True)
draw = draw.Draw(x, y, x1_test_mg, x2_test_mg, use_torch=True)
net = Net(x_avg, x_std)
print(net)
optimizer = optim.SGD(net.parameters(), lr=0.03)
criterion = nn.MSELoss()
# TODO implement one-hot and cross-entropy-loss
# criterion = nn.CrossEntropyLoss()
sample_num = x.shape[0]
batch_size = 5
for epoch in range(1000):
loss_avg = 0
for it in range(sample_num // batch_size):
beg_idx = it * batch_size
end_idx = sample_num if beg_idx + batch_size > sample_num else beg_idx + batch_size
net.zero_grad()
i = (i - 1) % width
j -= 1
for i in range(size - len(obst)):
# 距離が最小値の点を抽出
v = unSearch.index(min(unSearch))
dist[v] = unSearch[v]
unSearch[v] = END
searchDist(v)
searchRoute()
upHeight()
print(routeHeight)
d1 = draw.Draw(30, n)
for i in range(size):
if (unSearch[i] == 20001):
d1.drawObst(sufToCd(i), (192, 192, 192))
for i in range(size):
if (parent[i] != -1):
d1.drawLine(sufToCd(i), sufToCd(parent[i]), (0, 0, 255))
for i in range(size):
if (unSearch[i] == 20001):
col = (128, 128, 128)
else:
col = (0, 128, 0)
d1.drawChara(sufToCd(i), str(dist[i]))
d1.drawRect(sufToCd(i), col)
"""
integration_list: List[float] = []
for i in range(repeat_count):
integration_list.append(self.generate_integration(each_sample))
mean: float = round(np.mean(integration_list), 5)
variance: float = round(np.var(integration_list), 5)
return integration_list, mean, variance
if __name__ == "__main__":
approximate_integration = ApproximateIntegration(0, 1.0, lambda x: x**3)
test_case: List[int] = (5, 10, 20, 30, 40, 50, 60, 70, 80, 100)
means: List[float] = []
variances: List[float] = []
for each_sample in test_case:
cur_result: Tuple[List[float], float,
float] = approximate_integration.generate_repeat(
each_sample=each_sample, repeat_count=100)
means.append(cur_result[1])
variances.append(cur_result[2])
print('N = {} : {}'.format(each_sample, cur_result[0]))
draw.Draw().draw_mean_variance(abscissa=test_case,
mean=means,
variance=variances)
#!/usr/bin/python
# -*- coding:utf-8 -*-
import display
import draw
import signalk
import json
import time
import atexit
target = display.DrawTarget()
dashboard = draw.Draw(target)
def on_message(ws, message):
msg = json.loads(message)
if not "updates" in msg:
return
for update in msg["updates"]:
for value in update["values"]:
if value["path"] == "navigation.state":
if dashboard.display != value["value"]:
dashboard.set_display(value["value"])
signalk.subscribe(ws, dashboard.get_paths())
dashboard.variable_loop()
else:
dashboard.update_value(value, update["timestamp"])
def on_error(ws, error):
message = str(error)
print(message)
def draw(self):
draw.Draw()
import processing
import draw
import sys
import os
if __name__ == "__main__":
file_name = input(
"Place the file you wish to convert in the 'input' folder and type its name: "
)
poster_name = input("Name your poster png: ")
num_stills = int(
input("Select the number of layers you want your image to have"))
vp = processing.VideoProcessor(file_name)
frames = vp.get_n_stills(num_stills)
ip = processing.ImgProcessor(frames)
color_list = ip.average_list()
draw = draw.Draw(color_list)
draw.draw_image("output/" + poster_name, 3900, 5700)
exit(0)
def search(self):
start_time = time.process_time()
#this is the queue, prepopulated with the start node
q = [self.model.startState()]
#the future explored set, currently empty
#this has to be a dict so there is constant time lookup of whether a node is explored
#else on large networks where the explored set is very long, each node we check whether
#it has been explored is O(N) which is unacceptable
explored = {}
#create a dict that will store the parent of each node as it is visited
parents = {}
parents[self.model.startState()] = self.model.startState(), 0
if draw:
d = dr.Draw(self.model.startState())
d.drawGoals(self.model.goalStates())
else:
d = None
path_found = False
max_frontier_size = 1
while (len(q) > 0 and not path_found):
#pop a node from the q
current = q.pop(0)
if draw:
d.visitPoint(current)
if (current in explored):
#print("skipping explored node")
continue
self.nodecount += 1
# if self.nodecount % 500 == 0:
# print("Expanded:", self.nodecount)
# print("Len explored:", len(explored))
#break
explored[current] = 1
#expand the node
actions = self.model.actions(current)
for action in actions:
neighbor = self.model.result(current, action)
#store away the parent of a possible neighbor, plus the cost to get there
#check if the neighbor is a goal
if self.model.goal(neighbor):
if draw:
d.explorePoint(neighbor)
parents[neighbor] = current, self.model.cost(
current, action)
end_time = time.process_time()
path_found = True
self.outputAns(neighbor, start_time, end_time, parents,
max_frontier_size, path_found, d)
elif neighbor not in explored:
if draw:
d.explorePoint(neighbor)
#else add them to the queue if they are not seen yet
q.append(neighbor)
if neighbor not in parents:
parents[neighbor] = current, self.model.cost(
current, action)
max_frontier_size = max(max_frontier_size, len(q))
if not path_found:
end_time = time.process_time()
self.outputAns(self.model.startState(), start_time, end_time,
parents, max_frontier_size, path_found, d)
if draw:
input()
d.reset()
def search(self):
start_time = time.process_time()
#this is the priority queue, prepopulated with the start node
#the first number is the cost up to this point, the second number is
#the number of nodes we have explored before getting here
pq = [(0, 0, self.model.startState())]
#the future explored set, currently empty
#this has to be a dict so there is constant time lookup of whether a node is explored
#else on large networks where the explored set is very long, each node we check whether
#it has been explored is O(N) which is unacceptable
explored = {}
#create a dict that will store the parent of each node as it is visited
#the tuple is formatted as follows:
#parent, cost to traverse parent to child, path cost to this point
parents = {}
parents[self.model.startState()] = self.model.startState(), 0, 0
if draw:
d = dr.Draw(self.model.startState())
d.drawGoals(self.model.goalStates())
else:
d = None
path_found = False
max_frontier_size = 1
while(len(pq) > 0 and not path_found):
#pop a node from the pq
cost_to_now, priority, current = heapq.heappop(pq)
if draw:
d.visitPoint(current)
#check if the neighbor is a goal
if self.model.goal(current):
end_time = time.process_time()
path_found = True
self.outputAns(current, start_time, end_time, parents, max_frontier_size, path_found, d)
break
if(current in explored):
#print("skipping explored node")
continue
self.nodecount += 1
# if self.nodecount % 500 == 0:
# print("Expanded:", self.nodecount)
# print("Len explored:", len(explored))
#break
explored[current] = 1
#expand the node
actions = self.model.actions(current)
for action in actions:
neighbor = self.model.result(current, action)
#store away the parent of a possible neighbor, plus the cost to get there
if neighbor not in explored:
if draw:
d.explorePoint(neighbor)
#add them to the queue if they are not seen yet
path_cost = cost_to_now + self.model.cost(current, action)
heapq.heappush(pq, (path_cost, self.next_id, neighbor) )
self.next_id += 1
if neighbor not in parents or parents[neighbor][2] > path_cost:
parents[neighbor] = current, self.model.cost(current, action), path_cost
heapq.heapify(pq)
#print("Current was:", current, "heap is:", pq)
max_frontier_size = max(max_frontier_size, len(pq))
if not path_found:
end_time = time.process_time()
self.outputAns(self.model.startState(), start_time, end_time, parents, max_frontier_size, path_found, d)
if draw:
input()
d.reset()
