In [2]:
# some_file.py
import sys
sys.path.insert(0, './shared_code')
import networkx as nx
import numpy as np
import matplotlib.pyplot as plt
import sqlite3 as db
import json
import pandas as pd
import importlib
from IPython.core.display import display, HTML
import os
import RHgenerate_states
import RHcomponents
import RHdisplay
import RHdistance_partition
import RHutilities
%matplotlib inline
In [17]:
con = db.connect('data/rush_hour.db')
cur = con.cursor()
#states.to_sql('states',con,if_exists="append")
In [4]:
combinatorial_class = 36
class_36 = RHgenerate_states.generate_states(2,2)
num_nodes = len(class_36)
In [21]:
len(class_36),class_36[23]
Out[21]:
In [22]:
comps = RHcomponents.components(class_36)
In [32]:
# prep for processing generated list of components
SAVE_BATCH_SIZE = 2000 # Number of Graphs to save in batch; Equals number of rows in DataFrame
db_components = [None]*SAVE_BATCH_SIZE
comb_class_max_depth = 0
solvable_count = 0
unsolvable_count = 0
save_counter = 0
component_columns = ['comb_class','repr_board_int_s1','repr_board_int_s2',\
'repr_red_col', 'is_solvable','num_nodes',\
'density','max_solution_distance']
comb_class_columns = ['comb_class','num_nodes','num_components','num_solvable_components',\
'num_unsolvable_components','max_solution_depth']
for g in RHcomponents.gen_components(class_36):
save_counter +=1
if save_counter >= SAVE_BATCH_SIZE:
df = pd.DataFrame([x for x in db_components if x is not None],columns = component_columns)
df.to_sql('component',con,if_exists="append")
db_components = [None]*SAVE_BATCH_SIZE
save_counter = 1
if not g.graph['solvable']:
unsolvable_count +=1
node_dict = g.node[0]
max_soln_distance = None
else:
solvable_count += 1
RHdistance_partition.distance_partition(g)
max_soln_distance = max(g.graph['distance_partition'].keys())
if max_soln_distance > comb_class_max_depth:
comb_class_max_depth = max_soln_distance
for node in g.graph['distance_partition'][max_soln_distance]:
break
node_dict = g.node[node]
s1,s2 = RHutilities.split_int( node_dict['board_int'])
db_components.append( [\
combinatorial_class
,s1
,s2
,node_dict['red_col']
,g.graph['solvable']
,len(g.nodes())
,nx.density(g)
,max_soln_distance
]
)
if db_components.count(None) != len(db_components):
df = pd.DataFrame([x for x in db_components if x is not None],columns = component_columns)
df.to_sql('component',con,if_exists="append",index=False)
#comb_class_columns = ['comb_class','num_nodes','num_components','num_solvable_components',\
# 'num_unsolvable_components','max_solution_depth']
comb_class_data = [combinatorial_class,num_nodes,unsolvable_count + solvable_count,\
solvable_count,unsolvable_count, \
comb_class_max_depth]
df_class = pd.DataFrame(comb_class_data,columns = comb_class_columns)
df_class.to_sql('comb_class',con,if_exists="append",index=False)
In [39]:
In [33]:
df
Out[33]:
In [36]:
df2 = pd.read_sql_query("select * from comb_class",con)
df2
Out[36]:
In [69]:
if g.graph['solvable']:
RHdistance_partition.distance_partition(g)
max_distance = max(g.graph['distance_partition'].keys())
for node in g.graph['distance_partition'][max_distance]:
break
repr_node_dict = g.node[node]
else:
repr_node_dict = g.node[0]
max_distance = None
s1,s2 = RHutilities.split_int(repr_node_dict['board_int'])
red_col = repr_node_dict['red_col']
36, g.graph['solvable'],s1,s2,red_col, len(g.nodes()), nx.density(g),max_distance
Out[69]:
In [11]:
len(comps),sum(len(x.nodes()) for x in comps)
Out[11]:
In [12]:
len(comps[0].nodes())
Out[12]:
In [14]:
solvable_comps = [g for g in comps if g.graph['solvable']==True]
unsolvable_comps = [g for g in comps if g.graph['solvable'] == False]
In [15]:
df_solvable = pd.DataFrame([len(x.nodes()) for x in solvable_comps])
df_unsolvable = pd.DataFrame([len(x.nodes()) for x in unsolvable_comps])
In [18]:
#df.describe()
#%matplotlib inline
df_solvable.hist(bins=20)
Out[18]:
In [19]:
df_unsolvable.hist(bins=20)
Out[19]:
In [82]:
comp = comps[0]
min_int = min(comp.node[node]['board_int'] for node in comp.nodes())
min_int
Out[82]:
In [16]:
df_solvable.describe()
Out[16]:
In [17]:
df_unsolvable.describe()
Out[17]:
In [83]:
#node = 0
comp_repr_node = [comp[node] for node in comp.nodes() if comp.node[node]['board_int'] == min_int]
comp_repr_node
Out[83]:
In [113]:
len([g for g in comps if len(g.nodes())==1])
Out[113]:
In [37]:
n = solvable_comps[40].node[0]
#HTML(RHdisplay.svg_from_state(solvable_comps[40].nodes(0)))
HTML(RHdisplay.svg_from_state(n['board_int'],n['red_col']))
Out[37]:
In [39]:
df = pd.DataFrame( [ [len(g.nodes()),g.graph['solvable'] ] for g in comps])
In [55]:
g = solvable_comps[40]
g
Out[55]:
In [58]:
RHdistance_partition.distance_partition(g)
Out[58]:
In [72]:
df_dist = pd.DataFrame( [g.node[n]['soln_distance'] for n in g.nodes() ], columns = ['distance'])
In [74]:
df_dist.groupby(['distance']).size()
Out[74]:
In [76]:
HTML(RHdisplay.svg_from_state( g.node[0]['board_int'] , g.node[0]['red_col']))
Out[76]:
In [77]:
len(solvable_comps) , len(unsolvable_comps)
Out[77]:
In [79]:
len(solvable_comps) + len(unsolvable_comps)
Out[79]:
In [85]:
importlib.reload(RHdistance_partition)
for g in solvable_comps:
RHdistance_partition.distance_partition(g)
In [142]:
for g in solvable_comps:
g.graph['max_distance'] = max(g.graph['distance_partition'].keys())
for node in g.graph['distance_partition'][g.graph['max_distance']]:
break
node_dict = g.node[node]
split_board_int = RHutilities.split_int( node_dict['board_int'])
g.graph['repr_board_int_s1'] = split_board_int[0]
g.graph['repr_board_int_s2'] = split_board_int[1]
g.graph['repr_red_col'] = node_dict['red_col']
In [162]:
df_max_dist = pd.DataFrame( \
[ [g.graph['max_distance'],\
g.graph['repr_board_int_s1'],\
g.graph['repr_board_int_s2'],\
g.graph['repr_red_col']\
,len(g.nodes())\
,g.size()\
,nx.density(g)\
]\
for g in solvable_comps], columns=['distance','int_s1','int_s2','repr_red_col','num_nodes','num_edges','density'])
In [163]:
df_max_dist.sort_values(['distance'],ascending=False)
Out[163]:
In [164]:
board_int = RHutilities.combine_ints(21990316605814,11276634271252480)
red_col = 5
HTML(RHdisplay.svg_from_state(board_int,red_col))
Out[164]:
In [166]:
df_max_dist.groupby(['distance']).agg(['count'])
Out[166]:
In [119]:
df_max_dist.sort_values(by=['distance'] , ascending = False)
Out[119]:
In [135]:
df_max_dist.loc[df_max_dist['distance'] == 19]
#HTML(RHdisplay.svg_from_state(n['board_int'],n['red_col']))
Out[135]:
In [137]:
board_int = RHutilities.combine_ints(2748789558696,240243301154856)
red_col = 4
HTML(RHdisplay.svg_from_state(board_int,red_col))
Out[137]:
In [139]:
Out[139]:
In [ ]: