import numpy as np

import cycle

# from collections import Counter

# import sys

import itertools

# Load the adjacency matrix

G = np.loadtxt("graphs/dodecahedron.txt", int)

def order(G):

return len(G)

def size(G):

return int(np.sum(G) / 2)

def degree(G,v):

return np.sum(G[v])

def maxDegree(G):

return np.amax(np.sum(G, axis=1))

def minDegree(G):

return np.amin(np.sum(G, axis=1))

def degreeSequence(G):

return sorted(np.sum(G, axis=1), reverse=True)

def openNeighborhood(G, v):

return neighborhood

def closedNeighborhood(G, v):

return neighborhood

def isConnected(G):

return True if len(totalNeighbors) == order(G) else False

def powerset(iterable):

s = list(iterable)

return list(itertools.chain.from_iterable(itertools.combinations(s, r) for r in

range(len(s) + 1)))

def totalDomNumber(G):

return 1

def domNumber(G):

return 1

def isDom(S, G, neighbors = 'open'):

return (len(totalNeighbors) == order(G))

def indyNumber(G):

return len(filtered[j])

# print(filtered[j], independant)

def cliqueNumber(G):

return len(filtered[j])

# print(filtered[j], clique)

def distance(G, v1, v2):

return -1

# return 'not connected'

def eccentricity(G, v):

# print([distance(G, v, v2) for v2 in range(order(G)) if v != v2])

return np.amax([distance(G, v, v2) for v2 in range(order(G)) if v != v2])

def radius(G):

return np.amin([eccentricity(G, x) for x in range(order(G))])

def diameter(G):

return np.amax([eccentricity(G, x) for x in range(order(G))])

def girth(G):

return np.amax([cycle.find_cycle(G, x) for x in range(order(G))])

def residue(G):

return residue

def chromatic(G):

return len(set(coloring))

# return len(Counter(coloring).keys())

# NEW NOTES

# a graph with size 0 is the only graph with X(G) = 1

# a bipartite graph with at least one edge has X(G) = 2

# an odd-cycle has X(G) = 3

# if graph is complete, then maxDegree+1 colors are needed

# otherwise, chromatic number is at most maxDegree

# but it is greater than/equal to the clique number

# this means that at least we can restrict the range

# even if the algorithm itself is super slow

def complement(G):

return complement

# Function Calls

#print("The adjacency matrix of G is: ")

#print(G)

#print('\n')

#print('order of G:', order(G))

#print('size:', size(G))

#print('max degree:', maxDegree(G))

#print('min degree:', minDegree(G))

#print('degree sequence:', degreeSequence(G))

#print('connected:', isConnected(G))

#S = {2, 4}

#print('2 and 4 dominate?', isDom(S,G))

#print('domination number:', domNumber(G))

#print('total domination number:', totalDomNumber(G))

#print('independance number:', indyNumber(G))

#print('clique number:', cliqueNumber(G))

#print('distance between 2 and 0:', distance(G, 2, 0))

#for i in range(len(G)):

print('eccentricity of v{0}: {1}'.format(2, eccentricity(G, 2)))

#print('radius of G:', radius(G))

#print('diameter of G:', diameter(G))

#print('residue of G:', residue(G))

#print('length of cycle for v1:', cycle(G, 1))

#print('girth of G:', girth(G))

#print('chromatic:', chromatic(G))

#print('complement:\n', complement(G))

#print('\n')

#for i in range(0,order(G)):

# print('degree of %s:' % i, degree(G,i))

# print('open neighborhood of %s:' % i, openNeighborhood(G,i))

#print('closed neighborhood of %s:' % i, closedNeighborhood(G,i))