Changeset 618 for branches

Timestamp:

12/20/12 08:25:34 (3 years ago)

Author:

mmckerns

Message:

rename order to targets in build_constraint, takes list of variable names

File:

• branches/decorate/_symbolic.py (modified) (14 diffs)

branches/decorate/_symbolic.py

@@ -332 +332 @@
 
 
-def _build_linear(constraints, variables='x', nvars=None, order=None, **kwds):
+def _build_linear(constraints, variables='x', nvars=None, targets=None, **kwds):
     """Build a constraints function given a string of linear constraints.
 Returns a constraints function. 
@@ -356 +356 @@
         don't have the same base, and can include variables that are not
         found in the constraints equation string.
-    order -- tuple containing the order in which the variables should
-        be solved for. The first 'neqns' variables will be independent, and
-        the rest will be dependent.
-
-    NOTE: For example, if order=(3, 1, 2) and there are two
-        constraints equations, x3 and x1 will be constrained in terms of x2.
-        By default, increasing order (i.e. 1, 2, ...) is used. order
-        must enumerate all variables, hence len(order) == nvars.
+    targets -- list providing the order for which the variables will be solved.
+        If there are "N" constraint equations, the first "N" variables given
+        will be selected as the dependent variables. By default, increasing
+        order is used.
+
+    For example:
+        >>> constraints = '''x1 = x3 + 2.
+        ...     x3 = x4*2.'''
+        >>> f = _build_linear(constraints, nvars=4, targets=['x4','x3'])
+        >>> f([1.0, 0.0, 0.0, 1.0])
+        [1.0, 0.0, -1.0, -0.5]
 """
     """
@@ -402 +405 @@
 #   if kwds.has_key('lower_bounds'): lower_bounds = kwds['lower_bounds']
     #------------------------------------------------------------------
+    if targets in [None, False]:
+        targets = []
+    elif isinstance(targets, str):
+        targets = targets.split(',')
+    else:
+        targets = list(targets) # not the best for ndarray, but should work
 
     if list_or_tuple_or_ndarray(variables):
@@ -449 +458 @@
 #       permute = True
 
-    xinlist = xlist.split(',')[:-1]
-    if order:
-        order = tuple(asarray(order) - 1)
-        xorder = list(asarray(xinlist)[list(order)])
+    xperms = xlist.split(',')[:-1]
+    if targets:
+        [targets.remove(i) for i in targets if i not in xperms]
+        [targets.append(i) for i in xperms if i not in targets]
+    targets = tuple(targets)
 
     if permute:
@@ -460 +470 @@
         # to get different variables solved for.
         solns = []
-        xperms = list(permutations(xinlist)) #XXX Gets stuck here if nvars
-                                             # is on the order of 10....
-        if order:
-            xperms.remove(xorder)
-            xperms.insert(0, xorder)
+        xperms = list(permutations(xperms)) #XXX: takes a while if nvars is ~10
+        if targets:
+            xperms.remove(targets)
+            xperms.insert(0, targets)
         for perm in xperms: 
             tempcode = ""
@@ -524 +533 @@
         # If no bounds and guess, no need for permutations.
         # Just form code and get whatever solution sympy comes up with.
-        if order:
-            xlist = ','.join(xorder)
+        if targets:
+            xlist = ','.join(targets)
         code += 'soln = symsol([' + eqlist.rstrip(',') + '], [' + xlist.rstrip(',') + '])'
         exec code in globals(), locals() #FIXME: insecure
@@ -542 +551 @@
 
 
-def build_constraint(constraints, variables='x', nvars=None, order=None,**kwds):
+def build_constraint(constraints,variables='x',nvars=None,targets=None,**kwds):
     """Build a constraints function given a constraints string. 
 Returns a constraints function.
@@ -561 +570 @@
         ...     spread([x1,x2]) - 1.0 = mean([x1,x2])   
         ...     mean([x1,x2,x3]) = x3'''
-        >>> f = _build_nonlinear(constraints)
+        >>> f = build_constraint(constraints)
         >>> f([1.0, 2.0, 3.0])
         [1.0, 5.0, 3.0]
@@ -572 +581 @@
         don't have the same base, and can include variables that are not
         found in the constraints equation string.
-    order -- tuple containing the order in which the variables should
-        be solved for. The first 'neqns' variables will be independent, and
-        the rest will be dependent.
-
-    NOTE: For example, if order=(3, 1, 2) and there are two
-        constraints equations, x3 and x1 will be constrained in terms of x2.
-        By default, increasing order (i.e. 1, 2, ...) is used. order
-        must enumerate all variables, hence len(order) == nvars.
+    targets -- list providing the order for which the variables will be solved.
+        If there are "N" constraint equations, the first "N" variables given
+        will be selected as the dependent variables. By default, increasing
+        order is used.
+
+    For example:
+        >>> constraints = '''x1 = x3 + 2.
+        ...     x3 = x4*2.'''
+        >>> f = build_constraint(constraints, nvars=4, targets=['x4','x3'])
+        >>> f([1.0, 0.0, 0.0, 1.0])
+        [1.0, 0.0, -1.0, -0.5]
 """
     """
@@ -593 +605 @@
     try:
         return _build_linear(constraints, variables=variables, \
-                             nvars=nvars, order=order, **kwds)
+                             nvars=nvars, targets=targets, **kwds)
     except:
         return _build_nonlinear(constraints, variables=variables, \
-                                nvars=nvars, order=order, **kwds)
-
-
-def _build_nonlinear(constraints, variables='x', nvars=None, order=None,**kwds):
+                                nvars=nvars, targets=targets, **kwds)
+
+
+def _build_nonlinear(constraints,variables='x',nvars=None,targets=None,**kwds):
     """Build a constraints function given a string of nonlinear constraints.
 Returns a constraints function. 
@@ -628 +640 @@
         don't have the same base, and can include variables that are not
         found in the constraints equation string.
-    order -- tuple containing the order in which the variables should
-        be solved for. The first 'neqns' variables will be independent, and
-        the rest will be dependent.
-
-    NOTE: For example, if order=(3, 1, 2) and there are two
-        constraints equations, x3 and x1 will be constrained in terms of x2.
-        By default, increasing order (i.e. 1, 2, ...) is used. order
-        must enumerate all variables, hence len(order) == nvars.
+    targets -- list providing the order for which the variables will be solved.
+        If there are "N" constraint equations, the first "N" variables given
+        will be selected as the dependent variables. By default, increasing
+        order is used.
+
+    For example:
+        >>> constraints = '''
+        ...     spread([x1,x2]) - 1.0 = mean([x1,x2])   
+        ...     mean([x1,x2,x3]) = x3'''
+        >>> f = _build_nonlinear(constraints, targets=['x2'])
+        >>> f([1.0, 2.0, 3.0])
+        [1.0, -0.33333333333333204, 3.0]
 """
     """
@@ -663 +679 @@
 #   if kwds.has_key('lower_bounds'): lower_bounds = kwds['lower_bounds']
     #------------------------------------------------------------------
+    if targets in [None, False]:
+        targets = []
+    elif isinstance(targets, str):
+        targets = targets.split(',')
+    else:
+        targets = list(targets) # not the best for ndarray, but should work
 
     if list_or_tuple_or_ndarray(variables):
@@ -693 +715 @@
     neqns = len(actual_eqns)
 
-    # Getting all permutations will take a really really long time
-    # for something like nvars >= 10.
-    perms = list(permutations(range(ndim)))
-    if order: # Try the suggested order first.
-        order = tuple(asarray(order) - 1)
-        perms.remove(order)
-        perms.insert(0, order)
+    xperms = [varname+str(i+1) for i in range(ndim)]
+    if targets:
+        [targets.remove(i) for i in targets if i not in xperms]
+        [targets.append(i) for i in xperms if i not in targets]
+    targets = tuple(targets)
+
+    xperms = list(permutations(xperms)) #XXX: takes a while if nvars is ~10
+    if targets: # Try the suggested order first.
+        xperms.remove(targets)
+        xperms.insert(0, targets)
 
     complete_list = []
@@ -706 +731 @@
     # Some of the permutations will give the same answer;
     # look into reducing the number of repeats?
-    for p in perms:
-        thisorder = p
+    for perm in xperms:
         # Sort the list actual_eqns so any equation containing x1 is first, etc.
         sorted_eqns = []
         actual_eqns_copy = orig_eqns[:]
         usedvars = []
-        for i in thisorder:#range(ndim):
-            variable = varname + str(i+1)
+        for variable in perm: # range(ndim):
             for eqn in actual_eqns_copy:
                 if eqn.find(variable) != -1: