Changeset 686


Ignore:
Timestamp:
06/11/13 17:59:35 (3 years ago)
Author:
mmckerns
Message:

fix: symbolic now recognizes x0 as parameter and first default

Location:
mystic
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • mystic/_math/measures.py

    r646 r686  
    338338    inequality = ""; equality = ""; equality2 = "" 
    339339    for i in range(ndim): 
    340         inequality += "x%s >= 0.0\n" % (i+1) # positive 
    341         equality += "x%s + " % (i+1)         # normalized 
    342         equality2 += "%s * x%s + " % (float(samples[i]),(i+1)) # mean 
     340        inequality += "x%s >= 0.0\n" % (i) # positive 
     341        equality += "x%s + " % (i)         # normalized 
     342        equality2 += "%s * x%s + " % (float(samples[i]),(i)) # mean 
    343343 
    344344    equality += "0.0 = %s\n" % float(norm) 
    … …  
    383383    equality = ""; equality2 = ""; equality3 = "" 
    384384    for i in range(ndim): 
    385         inequality += "x%s >= 0.0\n" % (i+1) # positive 
    386         equality += "x%s + " % (i+1)         # normalized 
    387         equality2 += "%s * x%s + " % (float(samples[i]),(i+1)) # mean 
    388         equality3 += "x%s*(%s-%s)**2 + " % ((i+1),float(samples[i]),m) # var 
     385        inequality += "x%s >= 0.0\n" % (i) # positive 
     386        equality += "x%s + " % (i)         # normalized 
     387        equality2 += "%s * x%s + " % (float(samples[i]),(i)) # mean 
     388        equality3 += "x%s*(%s-%s)**2 + " % ((i),float(samples[i]),m) # var 
    389389 
    390390    equality += "0.0 = %s\n" % float(norm) 

  • mystic/mystic/_symbolic.py

    r645 r686  
    22# >>> from sympy import Eq, Symbol 
    33# >>> from sympy import solve as symsol 
     4# >>> x0 = Symbol('x0') 
    45# >>> x1 = Symbol('x1') 
    56# >>> x2 = Symbol('x2') 
    6 # >>> x3 = Symbol('x3') 
    7 # >>> eq1 = Eq(x2, x1 - 2.) 
    8 # >>> eq2 = Eq(x2, x3*2.) 
    9 # >>> soln = symsol([eq2, eq1], [x1, x2, x3]) 
     7# >>> eq1 = Eq(x1, x0 - 2.) 
     8# >>> eq2 = Eq(x1, x2*2.) 
     9# >>> soln = symsol([eq2, eq1], [x0, x1, x2]) 
    1010 
    1111from mystic.tools import permutations 
    … …  
    2727    For example: 
    2828        >>> constraints = ''' 
    29         ...     x1 = x5**2 
    30         ...     x3 = x4 + x5''' 
     29        ...     x0 = x4**2 
     30        ...     x2 = x3 + x4''' 
    3131        >>> _classify_variables(constraints, nvars=5) 
    32         {'dependent':['x1','x3'], 'independent':['x4','x5'], 'unconstrained':['x2']} 
    33         >>> constraints = ''' 
    34         ...     x1 = x5**2 
    35         ...     x5 - x4 = 0. 
    36         ...     x5 - x1 = x3''' 
     32        {'dependent':['x0','x2'], 'independent':['x3','x4'], 'unconstrained':['x1']} 
     33        >>> constraints = ''' 
     34        ...     x0 = x4**2 
     35        ...     x4 - x3 = 0. 
     36        ...     x4 - x0 = x2''' 
    3737        >>> _classify_variables(constraints, nvars=5) 
    38         {'dependent': ['x1','x3','x5'], 'independent': ['x4'], 'unconstrained': ['x2']} 
     38        {'dependent': ['x0','x2','x4'], 'independent': ['x3'], 'unconstrained': ['x1']} 
    3939 
    4040Additional Inputs: 
    4141    nvars -- number of variables. Includes variables not explicitly 
    42         given by the constraint equations (e.g. 'x2' in the example above). 
     42        given by the constraint equations (e.g. 'x1' in the example above). 
    4343    variables -- desired variable name. Default is 'x'. A list of variable 
    4444        name strings is also accepted for when desired variable names 
    … …  
    5252    #XXX: use solve? or first if not in form xi = ... ? 
    5353    if list_or_tuple_or_ndarray(variables): 
    54         if nvars: variables = variables[:nvars] 
     54        if nvars != None: variables = variables[:nvars] 
    5555        constraints = replace_variables(constraints, variables) 
    5656        varname = '$' 
    … …  
    5959        varname = variables # varname used below instead of variables 
    6060        myvar = get_variables(constraints, variables) 
    61         if myvar: ndim = max([int(v.strip(varname)) for v in myvar]) 
     61        if myvar: ndim = max([int(v.strip(varname)) for v in myvar]) + 1 
    6262        else: ndim = 0 
    63     if nvars: ndim = nvars 
     63    if nvars != None: ndim = nvars 
    6464 
    6565    eqns = constraints.splitlines() 
    66     indices = range(1, ndim+1) 
     66    indices = range(ndim) 
    6767    dep = [] 
    6868    indep = [] 
    6969    for eqn in eqns: # find which variables are used 
    7070        if eqn: 
    71             for var in range(1, ndim+1): 
     71            for var in range(ndim): 
    7272                if indices.count(var) != 0: 
    7373                    if eqn.find(varname + str(var)) != -1: 
    … …  
    9797            dep.append(_dep[0]) 
    9898            indep.remove(_dep[0]) 
    99     #FIXME: 'equivalent' equations not ignored (e.g. x3=x3; or x3=1, 2*x3=2) 
     99    #FIXME: 'equivalent' equations not ignored (e.g. x2=x2; or x2=1, 2*x2=2) 
    100100    """These are good: 
    101101    >>> constraints = ''' 
    102     ...     x1 = x5**2 
    103     ...     x3 - x5 - x4 = 0.''' 
     102    ...     x0 = x4**2 
     103    ...     x2 - x4 - x3 = 0.''' 
    104104    >>> _classify_variables(constraints, nvars=5) 
    105     {'dependent': ['x1','x3'], 'independent': ['x4','x5'], 'unconstrained': ['x2']} 
     105    {'dependent': ['x0','x2'], 'independent': ['x3','x4'], 'unconstrained': ['x1']} 
    106106    >>> constraints = ''' 
    107     ...     x1 + x3 = 0. 
    108     ...     x1 + 2*x3 = 0.''' 
     107    ...     x0 + x2 = 0. 
     108    ...     x0 + 2*x2 = 0.''' 
    109109    >>> _classify_variables(constraints, nvars=5) 
    110     {'dependent': ['x1','x3'], 'independent': [], 'unconstrained': ['x2','x4','x5']} 
     110    {'dependent': ['x0','x2'], 'independent': [], 'unconstrained': ['x1','x3','x4']} 
    111111 
    112112    This is a bug: 
    113113    >>> constraints = ''' 
    114     ...     x1 + x3 = 0. 
    115     ...     2*x1 + 2*x3 = 0.''' 
     114    ...     x0 + x2 = 0. 
     115    ...     2*x0 + 2*x2 = 0.''' 
    116116    >>> _classify_variables(constraints, nvars=5) 
    117     {'dependent': ['x1','x3'], 'independent': [], 'unconstrained': ['x2','x4','x5']} 
     117    {'dependent': ['x0','x2'], 'independent': [], 'unconstrained': ['x1','x3','x4']} 
    118118    """ #XXX: should simplify first? 
    119119    dep.sort() 
    … …  
    121121    # return the actual variable names (not the indicies) 
    122122    if varname == variables: # then was single variable 
    123         variables = [varname+str(i) for i in range(1,ndim+1)] 
    124     dep = [variables[i-1] for i in dep] 
    125     indep = [variables[i-1] for i in indep] 
    126     indices = [variables[i-1] for i in indices] 
     123        variables = [varname+str(i) for i in range(ndim)] 
     124    dep = [variables[i] for i in dep] 
     125    indep = [variables[i] for i in indep] 
     126    indices = [variables[i] for i in indices] 
    127127    d = {'dependent':dep, 'independent':indep, 'unconstrained':indices} 
    128128    return d 
    … …  
    143143    For example: 
    144144        >>> constraints = ''' 
    145         ...     x1 = x5**2 
    146         ...     x5 - x4 = 0. 
    147         ...     x5 - x1 = x3''' 
     145        ...     x0 = x4**2 
     146        ...     x4 - x3 = 0. 
     147        ...     x4 - x0 = x2''' 
    148148        >>> code, lhs, rhs, vars, neqn = _prepare_sympy(constraints, nvars=5) 
    149149        >>> print code 
     150        x0=Symbol('x0') 
    150151        x1=Symbol('x1') 
    151152        x2=Symbol('x2') 
    152153        x3=Symbol('x3') 
    153154        x4=Symbol('x4') 
    154         x5=Symbol('x5') 
    155155        rand = Symbol('rand') 
    156156        >>> print lhs, rhs 
    157         ['x1 ', 'x5 - x4 ', 'x5 - x1 '] [' x5**2', ' 0.', ' x3'] 
     157        ['x0 ', 'x4 - x3 ', 'x4 - x0 '] [' x4**2', ' 0.', ' x2'] 
    158158        print "%s in %s eqns" % (vars, neqn)         
    159         x1,x2,x3,x4,x5, in 3 eqns 
     159        x0,x1,x2,x3,x4, in 3 eqns 
    160160 
    161161Additional Inputs: 
    162162    nvars -- number of variables. Includes variables not explicitly 
    163         given by the constraint equations (e.g. 'x2' in the example above). 
     163        given by the constraint equations (e.g. 'x1' in the example above). 
    164164    variables -- desired variable name. Default is 'x'. A list of variable 
    165165        name strings is also accepted for when desired variable names 
    … …  
    171171 
    172172    from mystic.symbolic import replace_variables, get_variables 
    173     #XXX: if constraints contain x1,x2,x4 for 'x', should x3 be in code,xlist? 
     173    #XXX: if constraints contain x0,x1,x3 for 'x', should x2 be in code,xlist? 
    174174    if list_or_tuple_or_ndarray(variables): 
    175         if nvars: variables = variables[:nvars] 
     175        if nvars != None: variables = variables[:nvars] 
    176176        constraints = replace_variables(constraints, variables, markers='_') 
    177177        varname = '_' 
    … …  
    180180        varname = variables # varname used below instead of variables 
    181181        myvar = get_variables(constraints, variables) 
    182         if myvar: ndim = max([int(v.strip(varname)) for v in myvar]) 
     182        if myvar: ndim = max([int(v.strip(varname)) for v in myvar]) + 1 
    183183        else: ndim = 0 
    184     if nvars: ndim = nvars 
     184    if nvars != None: ndim = nvars 
    185185 
    186186    # split constraints_str into lists of left hand sides and right hand sides 
    … …  
    207207    # First create list of x variables 
    208208    xlist = "" 
    209     for i in range(1, ndim + 1): 
     209    for i in range(ndim): 
    210210        xn = varname + str(i) 
    211211        xlist += xn + "," 
    … …  
    213213    # Start constructing the code string 
    214214    code = "" 
    215     for i in range(1, ndim + 1): 
     215    for i in range(ndim): 
    216216        xn = varname + str(i) 
    217217        code += xn + '=' + "Symbol('" + xn + "')\n" 
    … …  
    231231 
    232232    For example: 
    233         >>> equation = "x2 - 3. = x1*x3" 
     233        >>> equation = "x1 - 3. = x0*x2" 
    234234        >>> print _solve_single(equation) 
    235         x1 = -(3.0 - x2)/x3 
     235        x0 = -(3.0 - x1)/x2 
    236236 
    237237Additional Inputs: 
    … …  
    244244 
    245245    For example: 
    246         >>> equation = "x2 - 3. = x1*x3" 
    247         >>> print _solve_single(equation, target='x2') 
    248         x2 = 3.0 + x1*x3 
     246        >>> equation = "x1 - 3. = x0*x2" 
     247        >>> print _solve_single(equation, target='x1') 
     248        x1 = 3.0 + x0*x2 
    249249 
    250250Further Inputs: 
    … …  
    276276    from mystic.symbolic import replace_variables, get_variables 
    277277    if list_or_tuple_or_ndarray(variables): 
    278         if nvars: variables = variables[:nvars] 
     278        if nvars != None: variables = variables[:nvars] 
    279279        constraints = replace_variables(constraint, variables, markers='_') 
    280280        varname = '_' 
    … …  
    287287        varname = variables # varname used below instead of variables 
    288288        myvar = get_variables(constraint, variables) 
    289         if myvar: ndim = max([int(v.strip(varname)) for v in myvar]) 
     289        if myvar: ndim = max([int(v.strip(varname)) for v in myvar]) + 1 
    290290        else: ndim = 0 
    291     if nvars: ndim = nvars 
     291    if nvars != None: ndim = nvars 
    292292 
    293293    # create function to replace "_" with original variables 
    … …  
    295295        if list_or_tuple_or_ndarray(variables): 
    296296            vars = get_variables(mystring,'_') 
    297             indices = [int(v.strip('_'))-1 for v in vars] 
     297            indices = [int(v.strip('_')) for v in vars] 
    298298            for i in range(len(vars)): 
    299299                mystring = mystring.replace(vars[i],variables[indices[i]]) 
    … …  
    343343 
    344344    ######################################################################## 
    345     # solve each xi: symsol(single_equation, [x1,x2,...,xi,...,xn]) 
    346     # returns: {x1: f(xn,...), x2: f(xn,...), ..., xn: f(...,x1)} 
     345    # solve each xi: symsol(single_equation, [x0,x1,...,xi,...,xn]) 
     346    # returns: {x0: f(xn,...), x1: f(xn,...), ..., xn: f(...,x0)} 
    347347    if permute or not target: #XXX: the goal is solving *only one* equation 
    348348        code += '_xlist = %s\n' % ','.join(targeted) 
    … …  
    396396    For example: 
    397397        >>> constraints = ''' 
    398         ...     x1 - x3 = 2. 
    399         ...     x3 = x4*2.''' 
     398        ...     x0 - x2 = 2. 
     399        ...     x2 = x3*2.''' 
    400400        >>> print _solve_linear(constraints) 
    401         x3 = 2.0*x4 
    402         x1 = 2.0 + 2.0*x4 
     401        x2 = 2.0*x3 
     402        x0 = 2.0 + 2.0*x3 
    403403 
    404404Additional Inputs: 
    … …  
    414414    For example: 
    415415        >>> constraints = ''' 
    416         ...     x1 - x3 = 2. 
    417         ...     x3 = x4*2.''' 
    418         >>> print _solve_linear(constraints, target=['x4','x3']) 
    419         x4 = -1.0 + 0.5*x1 
    420         x3 = -2.0 + x1 
     416        ...     x0 - x2 = 2. 
     417        ...     x2 = x3*2.''' 
     418        >>> print _solve_linear(constraints, target=['x3','x2']) 
     419        x3 = -1.0 + 0.5*x0 
     420        x2 = -2.0 + x0 
    421421 
    422422Further Inputs: 
    … …  
    442442    from mystic.symbolic import replace_variables, get_variables 
    443443    if list_or_tuple_or_ndarray(variables): 
    444         if nvars: variables = variables[:nvars] 
     444        if nvars != None: variables = variables[:nvars] 
    445445        _constraints = replace_variables(constraints, variables, '_') 
    446446        varname = '_' 
    … …  
    453453        varname = variables # varname used below instead of variables 
    454454        myvar = get_variables(constraints, variables) 
    455         if myvar: ndim = max([int(v.strip(varname)) for v in myvar]) 
     455        if myvar: ndim = max([int(v.strip(varname)) for v in myvar]) + 1 
    456456        else: ndim = 0 
    457     if nvars: ndim = nvars 
     457    if nvars != None: ndim = nvars 
    458458 
    459459    # create function to replace "_" with original variables 
    … …  
    461461        if list_or_tuple_or_ndarray(variables): 
    462462            vars = get_variables(mystring,'_') 
    463             indices = [int(v.strip('_'))-1 for v in vars] 
     463            indices = [int(v.strip('_')) for v in vars] 
    464464            for i in range(len(vars)): 
    465465                mystring = mystring.replace(vars[i],variables[indices[i]]) 
    … …  
    524524        _code = code 
    525525        xlist = ','.join(perm).rstrip(',') #XXX: if not all, use target ? 
    526         # solve dependent xi: symsol([linear_system], [x1,x2,...,xi,...,xn]) 
    527         # returns: {x1: f(xn,...), x2: f(xn,...), ...} 
     526        # solve dependent xi: symsol([linear_system], [x0,x1,...,xi,...,xn]) 
     527        # returns: {x0: f(xn,...), x1: f(xn,...), ...} 
    528528        _code += 'soln = symsol([' + eqlist + '], [' + xlist + '])' 
    529529        if verbose: print _code 
    … …  
    587587    For example: 
    588588        >>> constraints = ''' 
    589         ...     x1 - x3 = 2. 
    590         ...     x3 = x4*2.''' 
     589        ...     x0 - x2 = 2. 
     590        ...     x2 = x3*2.''' 
    591591        >>> print solve(constraints) 
    592         x3 = 2.0*x4 
    593         x1 = 2.0 + 2.0*x4 
    594         >>> constraints = ''' 
    595         ...     spread([x1,x2]) - 1.0 = mean([x1,x2])    
    596         ...     mean([x1,x2,x3]) = x3''' 
     592        x2 = 2.0*x3 
     593        x0 = 2.0 + 2.0*x3 
     594        >>> constraints = ''' 
     595        ...     spread([x0,x1]) - 1.0 = mean([x0,x1])    
     596        ...     mean([x0,x1,x2]) = x2''' 
    597597        >>> print solve(constraints) 
    598         x1 = -0.5 + 0.5*x3 
    599         x2 = 0.5 + 1.5*x3 
     598        x0 = -0.5 + 0.5*x2 
     599        x1 = 0.5 + 1.5*x2 
    600600 
    601601Additional Inputs: 
    … …  
    611611    For example: 
    612612        >>> constraints = ''' 
    613         ...     x1 - x3 = 2. 
    614         ...     x3 = x4*2.''' 
    615         >>> print solve(constraints, target=['x4','x3']) 
    616         x4 = -1.0 + 0.5*x1 
    617         x3 = -2.0 + x1 
     613        ...     x0 - x2 = 2. 
     614        ...     x2 = x3*2.''' 
     615        >>> print solve(constraints, target=['x3','x2']) 
     616        x3 = -1.0 + 0.5*x0 
     617        x2 = -2.0 + x0 
    618618 
    619619Further Inputs: 
    … …  
    651651 
    652652    For example: 
    653         >>> constraints = '''x2 = x4*3. + x1*x3''' 
     653        >>> constraints = '''x1 = x3*3. + x0*x2''' 
    654654        >>> print _solve_nonlinear(constraints) 
    655         x1 = (x2 - 3.0*x4)/x3 
    656         >>> constraints = ''' 
    657         ...     spread([x1,x2]) - 1.0 = mean([x1,x2])    
    658         ...     mean([x1,x2,x3]) = x3''' 
     655        x0 = (x1 - 3.0*x3)/x2 
     656        >>> constraints = ''' 
     657        ...     spread([x0,x1]) - 1.0 = mean([x0,x1])    
     658        ...     mean([x0,x1,x2]) = x2''' 
    659659        >>> print _solve_nonlinear(constraints) 
    660         x1 = -0.5 + 0.5*x3 
    661         x2 = 0.5 + 1.5*x3 
     660        x0 = -0.5 + 0.5*x2 
     661        x1 = 0.5 + 1.5*x2 
    662662 
    663663Additional Inputs: 
    … …  
    673673    For example: 
    674674        >>> constraints = ''' 
    675         ...     spread([x1,x2]) - 1.0 = mean([x1,x2])    
    676         ...     mean([x1,x2,x3]) = x3''' 
    677         >>> print _solve_nonlinear(constraints, target=['x2']) 
    678         x2 = -0.833333333333333 + 0.166666666666667*x3 
    679         x1 = -0.5 + 0.5*x3 
     675        ...     spread([x0,x1]) - 1.0 = mean([x0,x1])    
     676        ...     mean([x0,x1,x2]) = x2''' 
     677        >>> print _solve_nonlinear(constraints, target=['x1']) 
     678        x1 = -0.833333333333333 + 0.166666666666667*x2 
     679        x0 = -0.5 + 0.5*x2 
    680680 
    681681Further Inputs: 
    … …  
    701701    from mystic.symbolic import replace_variables, get_variables 
    702702    if list_or_tuple_or_ndarray(variables): 
    703         if nvars: variables = variables[:nvars] 
     703        if nvars != None: variables = variables[:nvars] 
    704704        constraints = replace_variables(constraints, variables, '_') 
    705705        varname = '_' 
    … …  
    708708        varname = variables # varname used below instead of variables 
    709709        myvar = get_variables(constraints, variables) 
    710         if myvar: ndim = max([int(v.strip(varname)) for v in myvar]) 
     710        if myvar: ndim = max([int(v.strip(varname)) for v in myvar]) + 1 
    711711        else: ndim = 0 
    712     if nvars: ndim = nvars 
     712    if nvars != None: ndim = nvars 
    713713 
    714714    # create function to replace "_" with original variables 
    … …  
    716716        if list_or_tuple_or_ndarray(variables): 
    717717            vars = get_variables(mystring,'_') 
    718             indices = [int(v.strip('_'))-1 for v in vars] 
     718            indices = [int(v.strip('_')) for v in vars] 
    719719            for i in range(len(vars)): 
    720720                mystring = mystring.replace(vars[i],variables[indices[i]]) 
    … …  
    734734    neqns = len(actual_eqns) 
    735735 
    736     xperms = [varname+str(i+1) for i in range(ndim)] 
     736    xperms = [varname+str(i) for i in range(ndim)] 
    737737    if target: 
    738738        [target.remove(i) for i in target if i not in xperms] 
    … …  
    754754    # look into reducing the number of repeats? 
    755755    for perm in xperms: 
    756         # Sort the list actual_eqns so any equation containing x1 is first, etc. 
     756        # Sort the list actual_eqns so any equation containing x0 is first, etc. 
    757757        sorted_eqns = [] 
    758758        actual_eqns_copy = orig_eqns[:] 
    … …  
    774774        tempusedvar.sort() 
    775775        nmissing = ndim - len(tempusedvar) 
    776         for m in range(1, nmissing+1): 
     776        for m in range(nmissing): 
    777777            usedvars.append(varname + str(len(tempusedvar) + m)) 
    778778 
    … …  
    819819    if verbose: 
    820820        print _classify_variables(simplified, variables, ndim) 
    821     if permute: #FIXME: target='x4,x2' may order correct, while 'x2,x4' doesn't 
     821    if permute: #FIXME: target='x3,x1' may order correct, while 'x1,x3' doesn't 
    822822        filter = []; results = [] 
    823823        for i in complete_list: 

  • mystic/mystic/symbolic.py

    r645 r686  
    3636    >>> h = [5.] 
    3737    >>> print linear_symbolic(A,b,G,h) 
    38     1.0*x1 + 0.0*x2 + 0.0*x3 <= 5.0 
    39     3.0*x1 + 4.0*x2 + 5.0*x3 = 0.0 
    40     1.0*x1 + 6.0*x2 + -9.0*x3 = 0.0 
     38    1.0*x0 + 0.0*x1 + 0.0*x2 <= 5.0 
     39    3.0*x0 + 4.0*x1 + 5.0*x2 = 0.0 
     40    1.0*x0 + 6.0*x1 + -9.0*x2 = 0.0 
    4141""" 
    4242    eqstring = "" 
    … …  
    6262            Asum = "" 
    6363            for j in range(ndim): 
    64                 Asum += str(A[i][j]) + '*x' + str(j+1) + ' + ' 
     64                Asum += str(A[i][j]) + '*x' + str(j) + ' + ' 
    6565            eqstring += Asum.rstrip(' + ') + ' = ' + str(b[i]) + '\n' 
    6666 
    … …  
    8787            Gsum = "" 
    8888            for j in range(ndim): 
    89                 Gsum += str(G[i][j]) + '*x' + str(j+1) + ' + ' 
     89                Gsum += str(G[i][j]) + '*x' + str(j) + ' + ' 
    9090            ineqstring += Gsum.rstrip(' + ') + ' <= ' + str(h[i]) + '\n' 
    9191    totalconstraints = ineqstring + eqstring 
    … …  
    105105        be replaced in the order that they are provided, where if the 
    106106        default marker "$i" is used, the first variable will be replaced 
    107         with "$1", the second with "$2", and so on. 
     107        with "$0", the second with "$1", and so on. 
    108108 
    109109    For example: 
    … …  
    111111        >>> constraints = '''spam + eggs - 42''' 
    112112        >>> print replace_variables(constraints, variables, 'x') 
    113         'x1 + x2 - 42' 
     113        'x0 + x1 - 42' 
    114114 
    115115Additional Inputs: 
    … …  
    131131        equations = replace_variables(constraints,variables,'_') 
    132132        vars = get_variables(equations,'_') 
    133         indices = [int(v.strip('_'))-1 for v in vars] 
     133        indices = [int(v.strip('_')) for v in vars] 
    134134        for i in range(len(vars)): 
    135135            equations = equations.replace(vars[i],markers[indices[i]]) 
    … …  
    162162    ''' #FIXME: don't parse if __name__ in __builtins__, globals, or locals? 
    163163    for i in indices: #FIXME: or better, use 're' pattern matching 
    164         constraints = constraints.replace(variables[i], marker + str(i+1)) 
     164        constraints = constraints.replace(variables[i], marker + str(i)) 
    165165    return constraints.replace(marker, markers) 
    166166 
    … …  
    199199        equations = replace_variables(constraints,variables,'_') 
    200200        vars = get_variables(equations,'_') 
    201         indices = [int(v.strip('_'))-1 for v in vars] 
     201        indices = [int(v.strip('_')) for v in vars] 
    202202        varnamelist = [] 
    203203        from numpy import sort 
    … …  
    230230    For example: 
    231231        >>> constraints = ''' 
    232         ...     x3 = x1/2. 
    233         ...     x1 >= 0.''' 
     232        ...     x2 = x0/2. 
     233        ...     x0 >= 0.''' 
    234234        >>> penalty_parser(constraints, nvars=3) 
    235235        (('-(x[0] - (0.))',), ('x[2] - (x[0]/2.)',)) 
    … …  
    246246   #ndim = len(get_variables(src(func), variables)) 
    247247    if list_or_tuple_or_ndarray(variables): 
    248         if nvars: variables = variables[:nvars] 
     248        if nvars != None: variables = variables[:nvars] 
    249249        constraints = replace_variables(constraints, variables) 
    250250        varname = '$' 
    … …  
    253253        varname = variables # varname used below instead of variables 
    254254        myvar = get_variables(constraints, variables) 
    255         if myvar: ndim = max([int(v.strip(varname)) for v in myvar]) 
     255        if myvar: ndim = max([int(v.strip(varname)) for v in myvar]) + 1 
    256256        else: ndim = 0 
    257     if nvars: ndim = nvars 
     257    if nvars != None: ndim = nvars 
    258258 
    259259    # Parse the constraints string 
    … …  
    265265            fixed = line 
    266266            # Iterate in reverse in case ndim > 9. 
    267             indices = list(range(1, ndim+1)) 
     267            indices = list(range(ndim)) 
    268268            indices.reverse() 
    269269            for i in indices: 
    270                 fixed = fixed.replace(varname + str(i), 'x[' + str(i-1) + ']')  
     270                fixed = fixed.replace(varname + str(i), 'x[' + str(i) + ']')  
    271271            constraint = fixed.strip() 
    272272 
    … …  
    317317    For example: 
    318318        >>> constraints = ''' 
    319         ...     x3 = x1/2. 
    320         ...     x1 >= 0.''' 
     319        ...     x2 = x0/2. 
     320        ...     x0 >= 0.''' 
    321321        >>> constraints_parser(constraints, nvars=3) 
    322322        ('x[2] = x[0]/2.', 'x[0] = max(0., x[0])') 
    … …  
    333333   #ndim = len(get_variables(src(func), variables)) 
    334334    if list_or_tuple_or_ndarray(variables): 
    335         if nvars: variables = variables[:nvars] 
     335        if nvars != None: variables = variables[:nvars] 
    336336        constraints = replace_variables(constraints, variables) 
    337337        varname = '$' 
    … …  
    340340        varname = variables # varname used below instead of variables 
    341341        myvar = get_variables(constraints, variables) 
    342         if myvar: ndim = max([int(v.strip(varname)) for v in myvar]) 
     342        if myvar: ndim = max([int(v.strip(varname)) for v in myvar]) + 1 
    343343        else: ndim = 0 
    344     if nvars: ndim = nvars 
     344    if nvars != None: ndim = nvars 
    345345 
    346346    # Parse the constraints string 
    … …  
    351351            fixed = line 
    352352            # Iterate in reverse in case ndim > 9. 
    353             indices = list(range(1, ndim+1)) 
     353            indices = list(range(ndim)) 
    354354            indices.reverse() 
    355355            for i in indices: 
    356                 fixed = fixed.replace(varname + str(i), 'x[' + str(i-1) + ']')  
     356                fixed = fixed.replace(varname + str(i), 'x[' + str(i) + ']')  
    357357            constraint = fixed.strip() 
    358358 
    … …  
    418418    For example: 
    419419        >>> constraints = ''' 
    420         ...     x1**2 = 2.5*x4 - 5.0 
    421         ...     exp(x3/x1) >= 7.0''' 
     420        ...     x0**2 = 2.5*x3 - 5.0 
     421        ...     exp(x2/x0) >= 7.0''' 
    422422        >>> ineqf,eqf = generate_conditions(constraints, nvars=4) 
    423423        >>> print ineqf[0].__doc__ 
    … …  
    490490    For example: 
    491491        >>> constraints = ''' 
    492         ...     x3 = x1/2. 
    493         ...     x1 >= 0.''' 
     492        ...     x2 = x0/2. 
     493        ...     x0 >= 0.''' 
    494494        >>> solv = generate_solvers(constraints, nvars=3) 
    495495        >>> print solv[0].__doc__ 
    … …  
    564564    For example: 
    565565        >>> constraints = ''' 
    566         ...     x3 = x1/2. 
    567         ...     x1 >= 0.''' 
     566        ...     x2 = x0/2. 
     567        ...     x0 >= 0.''' 
    568568        >>> ineqf,eqf = generate_conditions(constraints, nvars=3) 
    569569        >>> penalty = generate_penalty((ineqf,eqf)) 
    … …  
    627627    For example: 
    628628        >>> constraints = ''' 
    629         ...     x1 = cos(x2) + 2. 
    630         ...     x2 = x3*2.''' 
     629        ...     x0 = cos(x1) + 2. 
     630        ...     x1 = x2*2.''' 
    631631        >>> solv = generate_solvers(constraints) 
    632632        >>> constraint = generate_constraint(solv) 
    … …  
    640640    For example: 
    641641        >>> constraints = ''' 
    642         ...     x3 = x1/2. 
    643         ...     x1 >= 0.''' 
     642        ...     x2 = x0/2. 
     643        ...     x0 >= 0.''' 
    644644        >>> solv = generate_solvers(constraints, nvars=3) 
    645645        >>> print solv[0].__doc__ 

  • mystic/tests/test_symbolic.py

    r645 r686  
    66 
    77  constraints = """ 
    8   x1**2 = 2.5*x4 - a 
    9   exp(x3/x1) >= b""" 
     8  x0**2 = 2.5*x3 - a 
     9  exp(x2/x0) >= b""" 
    1010 
    1111  ineq,eq = generate_conditions(constraints, nvars=4, locals={'a':5.0, 'b':7.0}) 
    … …  
    2424 
    2525  constraints = """ 
    26   mean([x1, x2, x3]) = 5.0 
    27   x1 = x2 + x3""" 
     26  mean([x0, x1, x2]) = 5.0 
     27  x0 = x1 + x2""" 
    2828 
    2929  ineq,eq = generate_conditions(constraints) 
    … …  
    4141 
    4242  constraints = """ 
    43   mean([x1, x2, x3]) = 5.0 
    44   spread([x1, x2, x3]) = 10.0""" 
     43  mean([x0, x1, x2]) = 5.0 
     44  spread([x0, x1, x2]) = 10.0""" 
    4545 
    4646  from mystic.math.measures import mean, spread 
    … …  
    5555 
    5656  constraints = """ 
    57   spread([x1,x2]) - 1.0 = mean([x1,x2])    
    58   mean([x1,x2,x3]) = x3""" 
     57  spread([x0,x1]) - 1.0 = mean([x0,x1])    
     58  mean([x0,x1,x2]) = x2""" 
    5959 
    6060  from mystic.math.measures import mean, spread 

  • mystic/tests/test_symbolic_basic.py

    r645 r686  
    7373    # Test a nonlinear constraints example. 
    7474    string = """ 
    75     x2*x3 = 1. 
    76     x3 = x1 - 3. 
     75    x1*x2 = 1. 
     76    x2 = x0 - 3. 
    7777    """ 
    7878    print "building constraints function for:%s" % string.rstrip() 
    … …  
    136136 
    137137def test_feasible_pt(): 
    138     constraints = """x1 + x2 + x7 - 2*x4 > 3""" 
     138    constraints = """x0 + x1 + x6 - 2*x3 > 3""" 
    139139    soln = solve(constraints, guess=[1.]*8) #FIXME: either constraints.solve 
    140140    print 'actual solution:', soln, "\n"    #       or symbolic.solve ... ? 
Note: See TracChangeset for help on using the changeset viewer.