def radRatio(inequalDict):
chebRad = randomWalk.chebyshev(inequalDict)[1]
cheb = randomWalk.chebyshev(inequalDict)[0]
maxRad = -sys.maxint
for l in inequalDict.values():
for inequal in l:
r = inequal[2] - cheb[inequal[1]] + cheb[inequal[0]]
maxRad = max(r, maxRad)
return chebRad / maxRad
def avgMinRadRatio(inequalDict):
chebRad = randomWalk.chebyshev(inequalDict)[1]
cheb = randomWalk.chebyshev(inequalDict)[0]
radSum = 0.0
for l in inequalDict.values():
currRad = sys.maxint
for inequal in l:
r = inequal[2] - cheb[inequal[1]] + cheb[inequal[0]]
currRad = min(r, currRad)
radSum += currRad
avgRad = radSum / len(inequalDict.values())
return chebRad / avgRad
def avgRadRatio(inequalDict):
chebRad = randomWalk.chebyshev(inequalDict)[1]
cheb = randomWalk.chebyshev(inequalDict)[0]
radSum = 0.0
count = 0
for l in inequalDict.values():
for inequal in l:
r = inequal[2] - cheb[inequal[1]] + cheb[inequal[0]]
radSum += r
count += 1
avgRad = radSum / count
return chebRad / avgRad
def uniformRandSched(S, numPoints=100):
pointList = []
# start at arbitrary point, we take cheb
curr = randomWalk.chebyshev(S)[0]
# print curr
curr = [0] + [coord - curr[0] for coord in curr[1:]]
# print curr
# retrieve a list of the constraints
constraints = getList(S)
# go through the number of points to cycle through
i = 0
while i < numPoints + 100:
# set up a vector in a random direction
vector = [0 for n in range(len(S.keys()))]
for j in range(1, len(vector)):
vector[j] = np.random.normal(0, 0.1, 1)[0]
# print vector
# calculate magnitude of this vector]
magnitude = 0.0
for j in range(1, len(vector)):
magnitude += vector[j]**2
magnitude = magnitude**0.5
# print magnitude
for j in range(1, len(vector)):
vector[j] /= magnitude
# print vector
# initialize thetas for determining the lower and upper bounds for traveling along vector
theta_pos = 10000
theta_neg = -10000
# loop through the bounds and calculate distance to each, updating thetas as we go, to get bounds
for bound in constraints:
const = bound[2]
start = bound[0]
end = bound[1]
dist_to_bound = (const -
(curr[end] - curr[start])) / (vector[end] -
vector[start])
if dist_to_bound > 0: theta_pos = min(theta_pos, dist_to_bound)
if dist_to_bound < 0: theta_neg = max(theta_neg, dist_to_bound)
# print theta_pos
# print theta_neg
# print vector
# initialize next point
# new_point = [0 for n in range(len(curr))]
new_point = copy.deepcopy(curr)
# uniformly choose displacement along vector and calculate the appropriate point
displacement = np.random.uniform(theta_neg, theta_pos)
for j in range(1, len(vector)):
new_point[j] += vector[j] * displacement
curr = new_point
if i > 99:
pointList.append(curr)
i += 1
# print 'i = ' + str(i)
return pointList
def mpRandomShaver(tup):
genstn = tup[0]
numShaves = tup[1]
numRandos = tup[2]
cent = randomSchedule.centroid(genstn)
cheb = randomWalk.chebyshev(genstn)[0]
mid = randomSchedule.midPoint(genstn)
centAvg = 0.0
chebAvg = 0.0
randoAvg = 0.0
midAvg = 0.0
for i in range(numRandos):
rando = randomSchedule.simpleRandSched(genstn)
for j in range(numShaves):
randoAvg += randomShave(genstn, rando)
randoAvg /= (numRandos * numShaves)
for j in range(numShaves):
centAvg += randomShave(genstn, cent)
chebAvg += randomShave(genstn, cheb)
midAvg += randomShave(genstn, mid)
centAvg /= float(numShaves)
chebAvg /= float(numShaves)
midAvg /= float(numShaves)
print "SHAAAVVVVEEEE " + str(tup[3])
return (chebAvg, centAvg, midAvg, randoAvg)
def mpPointBrawl(tup):
genstn = tup[0]
dim = len(genstn.keys()) - 1
sphereMet = metricFunctions.sphericalMetric(genstn, dim, "spherical")
burgerMet = metricFunctions.sphericalMetric(
genstn, dim, "burgers") / (dim * (dim - 1) / 2)
wilsonMet = metricFunctions.sphericalMetric(genstn, dim, "wilson") / dim
radRatio = metricFunctions.sphericalMetric(genstn, dim, "radRatio")
naiveMet = metricFunctions.sphericalMetric(genstn, dim, "hell")
cheb = randomWalk.chebyshev(genstn)[0]
cent = centroid(genstn)
birdie = earlyBird(genstn)
mid = midPoint(genstn)
randAvg = 0.0
randAvgRay = 0.0
randAvgRayPos = 0.0
#randAvgShaves = 0.0
for i in range(100):
curr = simpleRandSched(genstn)
for j in range(numWalks):
randAvg += randomWalk.perturb(genstn, curr, 1, 0, 0)
randAvgRay += randomWalk.perturb(genstn, curr, 0, 0, 1)
randAvgRayPos += randomWalk.perturb(genstn, curr, 0, 1, 1)
#andAvgShaves += randomMelt.randomShave(genstn, curr)
randAvg /= i * j
randAvgRay /= i * j
randAvgRayPos /= i * j
#randAvgShaves /= i*j
chebAvg = 0.0
chebAvgRay = 0.0
chebAvgRayPos = 0.0
#chebAvgShaves = 0.0
centAvg = 0.0
centAvgRay = 0.0
centAvgRayPos = 0.0
#centAvgShaves = 0.0
birdAvg = 0.0
birdAvgRay = 0.0
birdAvgRayPos = 0.0
#birdAvgShaves = 0.0
midAvg = 0.0
midAvgRay = 0.0
midAvgRayPos = 0.0
#midAvgShaves = 0.0
for i in range(numWalks):
chebAvg += randomWalk.perturb(genstn, cheb, 1, 0, 0)
chebAvgRay += randomWalk.perturb(genstn, cheb, 0, 0, 1)
chebAvgRayPos += randomWalk.perturb(genstn, cheb, 0, 1, 1)
#chebAvgShaves += randomMelt.randomShave(genstn, cheb)
centAvg += randomWalk.perturb(genstn, cent, 1, 0, 0)
centAvgRay += randomWalk.perturb(genstn, cent, 0, 0, 1)
centAvgRayPos += randomWalk.perturb(genstn, cent, 0, 1, 1)
#centAvgShaves += randomMelt.randomShave(genstn, cent)
birdAvg += randomWalk.perturb(genstn, birdie, 1, 0, 0)
birdAvgRay += randomWalk.perturb(genstn, birdie, 0, 0, 1)
birdAvgRayPos += randomWalk.perturb(genstn, birdie, 0, 1, 1)
#birdAvgShaves += randomMelt.randomShave(genstn, bird)
midAvg += randomWalk.perturb(genstn, mid, 1, 0, 0)
midAvgRay += randomWalk.perturb(genstn, mid, 0, 0, 1)
midAvgRayPos += randomWalk.perturb(genstn, mid, 0, 1, 1)
#midAvgShaves += randomMelt.randomShave(genstn, mid)
chebAvg /= numWalks
chebAvgRay /= numWalks
chebAvgRayPos /= numWalks
#chebAvgShaves /= numWalks
centAvg /= numWalks
centAvgRay /= numWalks
centAvgRayPos /= numWalks
#centAvgShaves /= numWalks
birdAvg /= numWalks
birdAvgRay /= numWalks
birdAvgRayPos /= numWalks
#birdAvgShaves /= numWalks
midAvg /= numWalks
midAvgRay /= numWalks
midAvgRayPos /= numWalks
#midAvgShaves /= numWalks
print "TRIAL!! " + str(tup[1])
return [
genstn, dim, sphereMet, burgerMet, wilsonMet, radRatio, naiveMet,
chebAvg, centAvg, birdAvg, midAvg, randAvg, chebAvgRay, centAvgRay,
birdAvgRay, midAvgRay, randAvgRay, chebAvgRayPos, centAvgRayPos,
birdAvgRayPos, midAvgRayPos, randAvgRayPos
]
def pointBrawl(numTrials,
dim,
manWalk=False,
posTime=False,
randDim=False,
multi=False,
ray=False):
chebMargin = 0
centMargin = 0
birdMargin = 0
chebVCentMargin = 0
chebVBirdMargin = 0
centVBirdMargin = 0
# Matric to store all the different quantities we may want to compute in a
# simulation. The numbers on the right refer to indices of the matrix
lol = [
[], # sphereMetric 0
[], # burgerMetric 1
[], # wilsonMetric 2
[], # radRatio 3
[], # naiveMetric 4
[], # chebMargin 5
[], # centMargin 6
[], # birdMargin 7
[], # chebVCentMargin 8
[], # chebVBirdMargin 9
[], # centVBirdMargin 10
[], # randomWalkCheb 11
[], # randomWalkCent 12
[], # randomWalkBird 13
[], # randomWalkManyPoints 14
[], # dimension 15
[], # STNs. 16
]
# Run the point arena on numTrials number of STNs
procPool = mp.Pool(2)
for i in range(numTrials):
print "\nTrial " + str(i)
chebAvg = 0
centAvg = 0
birdAvg = 0
randAvg = 0
numWalks = 100
# Randomly choose the dimension between 2 and 10 events
if randDim:
dim = random.randint(2, 10)
# generate STN with dim events, each constrained by 0 to 50
genstn = stnConverter.matrixToDict(test.generateRandomSTN(dim, 0, 50))
# minimize the STN because why not
genstn = stnConverter.matrixToDict(
test.minimal(stnConverter.dictToMatrix(genstn)))
lol[15].append(dim)
lol[16].append(genstn)
# Metrics for analyzing an STN depending on what we are looking for.
# This could be how "spherelike" the solution space is,
sphereMet = metricFunctions.sphericalMetric(genstn, dim, "spherical")
burgerMet = metricFunctions.sphericalMetric(genstn, dim, "burgers")
wilsonMet = metricFunctions.sphericalMetric(genstn, dim, "wilson")
radRatio = metricFunctions.sphericalMetric(genstn, dim, "radRatio")
naiveMet = metricFunctions.sphericalMetric(genstn, dim, "hell")
# Compute the possible "centers", or points we think may be optimal
cheb = randomWalk.chebyshev(genstn)[0]
cent = centroid(genstn)
birdie = earlyBird(genstn)
# Append the computed metric values to their respective rows
lol[0].append(sphereMet)
lol[1].append(burgerMet)
lol[2].append(wilsonMet)
lol[3].append(radRatio)
lol[4].append(naiveMet)
# Take the average of 100 randomWalks using 100 different points
if not multi:
for i in range(100):
curr = simpleRandSched(genstn)
for i in range(numWalks):
randAvg += randomWalk.perturb(genstn, curr, not ray,
posTime, ray)
else:
tuplist = [(genstn, numWalks, posTime, ray)] * 100
results = procPool.map(mpRandoRandomWalker, tuplist)
randAvg = sum(results)
randAvg /= 100 * float(numWalks)
# Take the average of 100 randomWalks starting at each "center"
if not multi:
for i in range(numWalks):
chebAvg += randomWalk.perturb(genstn, cheb, not ray, posTime,
ray)
centAvg += randomWalk.perturb(genstn, cent, not ray, posTime,
ray)
birdAvg += randomWalk.perturb(genstn, birdie, not ray, posTime,
ray)
else:
tup = [(genstn, cheb, cent, birdie, posTime, ray)] * numWalks
results = procPool.map(mpCenterRandomWalker, tup)
chebAvg = sum([res[0] for res in results])
centAvg = sum([res[1] for res in results])
birdAvg = sum([res[2] for res in results])
chebAvg /= float(numWalks)
centAvg /= float(numWalks)
birdAvg /= float(numWalks)
print "cheb " + "Average: " + str(chebAvg)
print "cent " + "Average: " + str(centAvg)
print "bird " + "Average: " + str(birdAvg)
print "rand " + "Average: " + str(randAvg)
# Compute the different margins of the centers vs each other
if chebAvg == 0 and centAvg == 0:
chebVCentMargin = 0
else:
chebVCentMargin = 2 * (chebAvg - centAvg) / (chebAvg + centAvg)
if chebAvg == 0 and birdAvg == 0:
chebVBirdMargin = 0
else:
chebVBirdMargin = 2 * (chebAvg - birdAvg) / (chebAvg + birdAvg)
if centAvg == 0 and centAvg == 0:
centVBirdMargin = 0
else:
centVBirdMargin = 2 * (centAvg - birdAvg) / (centAvg + birdAvg)
# Compute the different margins of the centers vs random points
if chebAvg == 0 and randAvg == 0:
chebMargin = 0
else:
chebMargin = 2 * (chebAvg - randAvg) / (chebAvg + randAvg)
if centAvg == 0 and randAvg == 0:
centMargin = 0
else:
centMargin = 2 * (centAvg - randAvg) / (centAvg + randAvg)
if birdAvg == 0 and randAvg == 0:
birdMargin = 0
else:
birdMargin = 2 * (birdAvg - randAvg) / (birdAvg + randAvg)
# Append the computed margins to their respective rows
lol[5].append(chebMargin)
lol[6].append(centMargin)
lol[7].append(birdMargin)
lol[8].append(chebVCentMargin)
lol[9].append(chebVBirdMargin)
lol[10].append(centVBirdMargin)
# Append the computed randomWalk lengths starting at each center to
# their respective rows
lol[11].append(chebAvg)
lol[12].append(centAvg)
lol[13].append(birdAvg)
lol[14].append(randAvg)
print "SPHEERE " + str(sphereMet)
print "BURGERS " + str(burgerMet)
print "WILSOON " + str(wilsonMet)
print "RAAAADD " + str(radRatio)
print "NAIIIVE " + str(naiveMet)
title = "THE_GRAND_BATTLE_ON_"
if randDim:
title += "MANY"
else:
title += str(dim)
title += "_DIMENSIONS_"
title += "AND_" + str(numTrials) + "_MILLION_TRIALS"
if posTime:
title += "_AS_TIME_MOVES_FORWARD!"
if ray:
title += "...IN A RAY!"
# Code to store data in a json file
with open(os.path.abspath('./Data/' + title + '.json'), 'w') as fp:
json.dump(lol, fp)
return lol
def distMetric(S, dim):
one = randomWalk.chebyshev(S)[0]
cent = centroid(S)
return randomWalk.distance(one, cent)
def sphereVol(S, dim):
chebsph = randomWalk.chebyshev(S)
return test.sphereVolume(float(chebsph[1]), dim) / (
test.naiveVolFlex(stnConverter.dictToMatrix(S)) + 0.00000001)
def spherical(STN, dim):
rad = randomWalk.chebyshev(STN)[1]
return sphereVolume(rad, dim)**(1.0 / dim)
def mpHelper(tup):
genstn = tup[0]
numWalks = tup[1]
dim = len(genstn.keys()) - 1
# Compute the STN flexibility metric values for the current STN
# Hunsberger, Wilson, and Naive are all adjusted to account for the
# different dimensions
sphereMet = metricFunctions.sphericalMetric(genstn, dim, "spherical")
burgerMet = metricFunctions.sphericalMetric(
genstn, dim, "burgers") / (dim * (dim - 1) / 2)
wilsonMet = metricFunctions.sphericalMetric(genstn, dim, "wilson") / dim
naiveMet = metricFunctions.sphericalMetric(genstn, dim, "hell") / dim
# Compute the centers of interest for the current STN
cheb = randomWalk.chebyshev(genstn)[0]
cent = randomSchedule.centroid(genstn, 100)
avgMid = randomSchedule.jimPoint(genstn)
# Lists to hold the disturbance lengths
randWalks = []
randShaves = []
# Lists to hold the durability metric values
randclosevals = []
randfurthvals = []
# randcubevals = []
randgeovals = []
# Compute the disturbance lengths and durability metric values for 100
# random schedules in the STN
pointList = randomMelt.uniformRandSched(genstn)
for i in range(100):
walk = 0.0
shave = 0.0
# curr = randomSchedule.simpleRandSched(genstn)
# print len(pointList)
curr = pointList[i]
randclosevals.append(schedMetrics.sphereMet(genstn, curr))
randfurthvals.append(randomSchedule.furthestBoundary(genstn, curr))
# randcubevals.append(schedMetrics.wilsonCubeMet(genstn, curr))
randgeovals.append(schedMetrics.geoMet(genstn, curr))
for j in range(numWalks):
walk += randomWalk.perturb(genstn, curr, 1, 0, 0)
shave += randomMelt.randomShave(genstn, curr)
walk /= numWalks
shave /= numWalks
randWalks.append(walk)
randShaves.append(shave)
# Compute averages for the disturbance lengths and durability metric
# values for the 100 STNs
randAvg = sum(randWalks) / len(randWalks)
randAvgShaves = sum(randShaves) / len(randShaves)
randClose = sum(randclosevals) / len(randclosevals)
randFurth = sum(randfurthvals) / len(randfurthvals)
# randCube = sum(randcubevals)/len(randcubevals)
randGeo = sum(randgeovals) / len(randgeovals)
# Compute correlation coefficients for the disturbance lengths vs each of
# our durability metrics
try:
walk_close_corr = np.corrcoef(randclosevals, randWalks)[1][0]
except:
walk_close_corr = 0.0
try:
walk_furth_corr = np.corrcoef(randfurthvals, randWalks)[1][0]
except:
walk_furth_corr = 0.0
# try:
# walk_cube_corr = np.corrcoef(randcubevals, randWalks)[1][0]
# except:
# walk_cube_corr = 0.0
try:
walk_geo_corr = np.corrcoef(randgeovals, randWalks)[1][0]
except:
walk_geo_corr = 0.0
try:
shave_close_corr = np.corrcoef(randclosevals, randShaves)[1][0]
except:
shave_close_corr = 0.0
try:
shave_furth_corr = np.corrcoef(randfurthvals, randShaves)[1][0]
except:
shave_furth_corr = 0.0
# try:
# shave_cube_corr = np.corrcoef(randcubevals, randShaves)[1][0]
# except:
# shave_cube_corr = 0.0
try:
shave_geo_corr = np.corrcoef(randgeovals, randShaves)[1][0]
except:
shave_geo_corr = 0.0
# walk_close_corr = 0.0
# walk_cube_corr = 0.0
# walk_geo_corr = 0.0
# shave_close_corr = 0.0
# shave_cube_corr = 0.0
# shave_geo_corr = 0.0
if math.isnan(walk_close_corr):
walk_close_corr = 0.0
if math.isnan(walk_furth_corr):
walk_furth_corr = 0.0
if math.isnan(walk_geo_corr):
walk_geo_corr = 0.0
if math.isnan(shave_close_corr):
shave_close_corr = 0.0
if math.isnan(shave_furth_corr):
shave_furth_corr = 0.0
if math.isnan(shave_geo_corr):
shave_geo_corr = 0.0
# Placeholders for disturbance lengths for centers of interest
chebAvg = 0.0
chebAvgShaves = 0.0
centAvg = 0.0
centAvgShaves = 0.0
midAvg = 0.0
midAvgShaves = 0.0
# Compute disturbance lengths for centers of interest multiple times
for i in range(numWalks):
chebAvg += randomWalk.perturb(genstn, cheb, 1, 0, 0)
chebAvgShaves += randomMelt.randomShave(genstn, cheb)
centAvg += randomWalk.perturb(genstn, cent, 1, 0, 0)
centAvgShaves += randomMelt.randomShave(genstn, cent)
midAvg += randomWalk.perturb(genstn, avgMid, 1, 0, 0)
midAvgShaves += randomMelt.randomShave(genstn, avgMid)
# Compute average disturbance lengths for centers of interest
chebAvg /= numWalks
chebAvgShaves /= numWalks
centAvg /= numWalks
centAvgShaves /= numWalks
midAvg /= numWalks
midAvgShaves /= numWalks
# Compute durability metric values for centers of interest
cheb_close = schedMetrics.sphereMet(genstn, cheb)
cent_close = schedMetrics.sphereMet(genstn, cent)
mid_close = schedMetrics.sphereMet(genstn, avgMid)
cheb_furth = randomSchedule.furthestBoundary(genstn, cheb)
cent_furth = randomSchedule.furthestBoundary(genstn, cent)
mid_furth = randomSchedule.furthestBoundary(genstn, avgMid)
# cheb_cube = schedMetrics.wilsonCubeMet(genstn, cheb)
# cent_cube = schedMetrics.wilsonCubeMet(genstn, cent)
# mid_cube = schedMetrics.wilsonCubeMet(genstn, avgMid)
cheb_geo = schedMetrics.geoMet(genstn, cheb)
cent_geo = schedMetrics.geoMet(genstn, cent)
mid_geo = schedMetrics.geoMet(genstn, avgMid)
print "TRIAL!! " + str(tup[2])
return [
genstn, dim, cheb, cent, avgMid, sphereMet, burgerMet, wilsonMet,
naiveMet, randAvg, randAvgShaves, randClose, randFurth, randGeo,
walk_close_corr, walk_furth_corr, walk_geo_corr, shave_close_corr,
shave_furth_corr, shave_geo_corr, chebAvg, chebAvgShaves, centAvg,
centAvgShaves, midAvg, midAvgShaves, cheb_close, cent_close, mid_close,
cheb_furth, cent_furth, mid_furth, cheb_geo, cent_geo, mid_geo
]
