In [1]:
import networkx as nx
import numpy as np
import matplotlib.pyplot as plt
import sqlite3
import json
import pandas as pd
import importlib
from IPython.core.display import display, HTML
import os
os.chdir("./shared_code")
import RHgenerate_states
import RHcomponents
import RHdisplay
import RHdistance_partition
import RHutilities
%matplotlib inline
In [4]:
#conn = sqlite3.connect('database\\rush_hour.db')
#cur = conn.cursor()
In [2]:
comb_class = RHgenerate_states.generate_states(4,2)
In [3]:
len(comb_class),comb_class[23]
Out[3]:
In [ ]:
importlib.reload(RHcomponents)
comps = RHcomponents.components(comb_class)
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 [ ]: