def search_loop(self, searchlist, generator, maxinner=20):
"""
searchlist = k1
generator = self.sobol_seq
key = k1.pop()
key = k2.pop()
key = k3.pop()
why in the world are there two BulbLength vars ??!!
"""
redolist = []
for key in searchlist:
loop = True
inner = 0
while loop and inner < maxinner:
#c += 1
x = generator.next()
lastnode = self.rgp.env.get_latest_child()
checker, env = self.set_this(key, x)
if checker:
nextnode = lp.States(env.states, parent=lastnode)
lastnode.children.append(nextnode)
self.rgp.env.states = nextnode.states
break
else:
print 'now get the states one level up'
self.rgp.env.states = env.states
inner += 1
if not checker:
redolist.append(key)
return set(redolist)
def set_this(self, key, x, design_sq):
"""TODO,
if something goes wrong, back up one level
and breadth first search
"""
val = self.hdp(key)[0]
if isinstance(val, ia):
val = self.hdp(key)[0].getpoint(x)
val = ia(val, val)
self.hdp.__setattr__(key.name, val)
lastnode = design_sq.get_latest_child()
nextnode = lp.States(self.hdp.states, parent=lastnode)
lastnode.children.append(nextnode)
self.hdp.states = nextnode.states
print 'done ', key, '=>', val
else:
print 'skipped ', key
return design_sq
def tree_search(self, Nd=1, initial_state=None, sobol_seq=None):
"""
sobol 'dive' into the design space...
reference bckwds w/ str :: lwl <-> candidate[str(ds.hdp.lwl)]
"""
"""
Each time we choose next parameter
to pick values from
we move one level further down the tree
"""
"""
starts out as depth first search
"""
self.saved_space = copy.deepcopy(self.hdp)
#
if sobol_seq is None: sobol_seq = self.sobol_seq
if initial_state is None:
initial_state = self.hdp #hullclp( ds.hdp.states[0])
#
SMALL = DesignSpace.SMALL
#
design = initial_state
keys = design.keys
k1 = set(design.Primary)
k2 = set(design.Coefficients)
k3 = set(design.Areas)
k4 = set(design.BowCurveCoeff) & set(design.SternCurveCoeff)
ksac = set(design.list_SAC)
kr = set(keys) - k1 - k2 - k3 - k4 - ksac
design_sq = lp.States(self.hdp.states)
#self.hdp.states = design_sq.states
self.design_sq = design_sq
design_sq = self.search_loop(design_sq, k2, sobol_seq)
design_sq = self.search_loop(design_sq, k1, sobol_seq)
design_sq = self.search_loop(design_sq, ksac, sobol_seq)
design_sq = self.search_loop(design_sq, k3, sobol_seq)
design_sq = self.search_loop(design_sq, k4, sobol_seq)
design_sq = self.search_loop(design_sq, kr, sobol_seq)
self.feasible_designs.append(design_sq.get_latest_child())
return
def __call__(self, *args):
return eval(self.body, Env(self.parms, args, self.env))
if __name__ == "__main__":
x = lp.Variable('x')
y = lp.Variable('y')
z = lp.Variable('z')
a = lp.Variable('a')
b = lp.Variable('b')
c = lp.Variable('c')
d = lp.Variable('d')
s = lp.State(values={
x: None,
y: None,
z: None,
a: None,
b: None,
c: None,
d: None
})
st = lp.States(s)
h = parse('(states + (a,b,(states c)) - (x,y,z) )')
#eval(parse('(define circle-area (lambda (r) (* pi (* r r))))'))
#eval(parse('(circle-area 3)'))
#global_env.update({x:y})
#eval(parse('equal? x y'))(lp.State(values=global_env))
A_mid = A_mid == ia(10., 20.) #issue: order of assignment "matters"
BulbBeam = BulbBeam == ia(5., 10.)
CBulbMid = CBulbMid == ia(.5, 1.)
print 'problem:'
BulbDepth = BulbDepth == ia(0.1, 40.) #makes it blow down
#BulbDepth = BulbDepth == ia(0.05,0.2)
print 'BulbDepth = BulbDepth == ia(0.,40.) #makes it blow down'
##
##----
##
#"""
# add CBuldMid to st
#"""
#initialize, if not already done
st, vars_ = CBulbMid.construct(CBulbMid, lp.States(lp.State({})), {})
fundict = CBulbMid.compile(CBulbMid, vars_)
for el in fundict:
st = fundict[el](st)
#"""
#add A_mid to st
#initialize, if not already done
#st, vars_ = A_mid.construct(A_mid,
# lp.States(lp.State({})),
# {})
st, vars_ = A_mid.construct(A_mid, st, {})
fundict = A_mid.compile(A_mid, vars_)
for el in fundict:
st = fundict[el](st)
y = lp.Variable('y')
z = lp.Variable('z')
a = lp.Variable('a')
b = lp.Variable('b')
c = lp.Variable('c')
d = lp.Variable('d')
s = lp.State(values={
x: None,
y: None,
z: None,
a: None,
b: None,
c: None,
d: None
})
st = lp.States(s)
#st1 = (st == (y,ia(1.,3.)))
#st1 = (st == (ia(-100.,100.),x))
#st1 = (st1 * (x,ia(2.,2.),y))
#st1 = (st1 ** (x,2.,y))
#st1 = (st1 ** (y,.5,x))
#st1 = (st1 ** (y,-1.,x))
# finding exponenets must have positive y
#st1 = (st == (y,ia(1.,3.)))
#st1 = (st1 ** (ia(1.73205080757,1.73205080757) , x, y ) )
st1 = (st == (y, ia(-1., 3.)))
#st1 = (st1 ** (y,-2.,x))
#self.rgp._verbose = True
#print self.rgp.env
#type(self.rgp.nodes[0].vars['ship_beam'])
low_down_dirty_testing = False
x1 = lp.PStates(name='x1')
x2 = lp.PStates(name='x2')
x3 = lp.PStates(name='x3')
#x4 = lp.PStates(name='x4')
x1 = x1 == ia(1., 10.)
x2 = x2 == ia(1., 10.)
x3 = x3 == ia(1., 10.)
env = lp.States(lp.State())
# add x1 rule to env
env, vars_ = x1.construct(x1, env, {})
fundict = x1.compile(x1, vars_)
for el in fundict:
env = fundict[el](env)
# add x2 rule to env
env, vars_ = x2.construct(x2, env, vars_)
fundict = x2.compile(x2, vars_)
for el in fundict:
env = fundict[el](env)
# add x3 rule to env
env, vars_ = x3.construct(x3, env, vars_)
y = lp.Variable('y')
z = lp.Variable('z')
a = lp.Variable('a')
b = lp.Variable('b')
c = lp.Variable('c')
d = lp.Variable('d')
s = lp.State(values={
x: None,
y: None,
z: None,
a: None,
b: None,
c: None,
d: None
})
st = lp.States(s)
#st1 = (st == (y,ia(1.,3.)))
#st1 = (st == (ia(-100.,100.),x))
#st1 = (st1 * (x,ia(2.,2.),y))
#st1 = (st1 ** (x,2.,y))
#st1 = (st1 ** (y,.5,x))
#st1 = (st1 ** (y,-1.,x))
# finding exponenets must have positive y
#st1 = (st == (y,ia(1.,3.)))
#st1 = (st1 ** (ia(1.73205080757,1.73205080757) , x, y ) )
st1 = (st == (y, ia(-1., 3.)))
#st1 = (st1 ** (y,-2.,x))
