Beispiel #1
0
-3*x0 + x1 - 6.0 <= 0.0
x0 + 2*x1 - 4.0 <= 0.0
"""
bounds = [(None, None),(-3.0, None)]

# with penalty='penalty' applied, solution is:
xs = [10.0, -3.0]
ys = -22.0
# alternately, if solving for the maximum, the solution is:
_xs = [-1.14285714,  2.57142857]
_ys = 11.428571428571429

from mystic.symbolic import generate_conditions, generate_penalty
pf = generate_penalty(generate_conditions(equations))
from mystic.symbolic import generate_constraint, generate_solvers, simplify
cf = generate_constraint(generate_solvers(simplify(equations)))

# inverted objective, used in solving for the maximum
_objective = lambda x: -objective(x)


if __name__ == '__main__':

  from mystic.solvers import diffev2, fmin_powell
  from mystic.math import almostEqual

  result = diffev2(objective, x0=bounds, bounds=bounds, constraint=cf, penalty=pf, npop=40, disp=False, full_output=True)
  assert almostEqual(result[0], xs, rel=1e-2)
  assert almostEqual(result[1], ys, rel=1e-2)

  result = fmin_powell(objective, x0=[0.0,0.0], bounds=bounds, constraint=cf, penalty=pf, disp=False, full_output=True)
Beispiel #2
0
"""

import numpy as np
import mystic.symbolic as ms
import mystic.solvers as my
import mystic.math as mm

# generate constraints and penalty for a nonlinear system of equations 
ieqn = '''
   -2*x0 + 2*x1 <= -2
    2*x0 - 4*x1 <= 0
'''
eqn = '''
     x0**3 - x1 == 0
'''
cons = ms.generate_constraint(ms.generate_solvers(ms.simplify(eqn,target='x1')))
pens = ms.generate_penalty(ms.generate_conditions(ieqn), k=1e3)
bounds = [(0., None), (1., None)]

# get the objective
def objective(x, sign=1):
  x = np.asarray(x)
  return sign * (2*x[0]*x[1] + 2*x[0] - x[0]**2 - 2*x[1]**2)

x0 = np.random.rand(2)

# compare against the exact minimum
xs = np.array([2., 1.])
ys = objective(xs, -1)

Beispiel #3
0
    Subject to: x[0] + 1*x[1] <= 7
               -x[0] + 2*x[1] <= 4

    where:  0 <= x[0] <= inf
            0 <= x[1] <= 4
"""
import numpy as np
import mystic.symbolic as ms
import mystic.solvers as my
import mystic.math as mm

# generate constraints and penalty for a linear system of equations 
A = np.array([[1, 1],[-1, 2]])
b = np.array([7,4])
eqns = ms.linear_symbolic(G=A, h=b)
cons = ms.generate_constraint(ms.generate_solvers(ms.simplify(eqns)))
pens = ms.generate_penalty(ms.generate_conditions(eqns), k=1e3)
bounds = [(0., None), (0., 4.)]

# get the objective
def objective(x):
  x = np.asarray(x)
  return x[0]**2 + 4*x[1]**2 - 32*x[1] + 64

x0 = np.random.rand(2)

# compare against the exact minimum
xs = np.array([2., 3.])
ys = objective(xs)

Beispiel #4
0
ys = 24.3062091

from mystic.symbolic import generate_constraint, generate_solvers, simplify
from mystic.symbolic import generate_penalty, generate_conditions

equations = """
4.0*x0 + 5.0*x1 - 3.0*x6 + 9.0*x7 - 105.0 <= 0.0
10.0*x0 - 8.0*x1 - 17.0*x6 + 2.0*x7 <= 0.0
-8.0*x0 + 2.0*x1 + 5.0*x8 - 2.0*x9 - 12.0 <= 0.0
3.0*(x0-2)**2 + 4.0*(x1-3)**2 + 2.0*x2**2 - 7.0*x3 - 120.0 <= 0.0
5.0*x0**2 + 8.0*x1 + (x2-6)**2 - 2.0*x3 - 40.0 <= 0.0
0.5*(x0-8)**2 + 2.0*(x1-4)**2 + 3.0*x4**2 - x5 - 30.0 <= 0.0
x0**2 + 2.0*(x1-2)**2 - 2.0*x0*x1 + 14.0*x4 - 6.0*x5 <= 0.0
-3.0*x0 + 6.0*x1 + 12.0*(x8-8)**2 - 7.0*x9 <= 0.0
"""
cf = generate_constraint(generate_solvers(simplify(equations, target=['x5','x3'])))
pf = generate_penalty(generate_conditions(equations))



if __name__ == '__main__':
    x = [0]*len(xs)

    from mystic.solvers import fmin_powell
    from mystic.math import almostEqual
    from mystic.monitors import VerboseMonitor
    mon = VerboseMonitor(10)

    result = fmin_powell(objective, x0=x, bounds=bounds, penalty=pf, maxiter=1000, maxfun=100000, ftol=1e-12, xtol=1e-12, gtol=10, disp=False, full_output=True)

    assert almostEqual(result[0], xs, tol=1e-2)
Beispiel #5
0
bounds = [(-10., 10.)] * 7
# with penalty='penalty' applied, solution is:
xs = [2.330499, 1.951372, -0.4775414, 4.365726, -0.6244870, 1.038131, 1.594227]
ys = 680.6300573

from mystic.symbolic import generate_constraint, generate_solvers, simplify
from mystic.symbolic import generate_penalty, generate_conditions

equations = """
2.0*x0**2 + 3.0*x1**4 + x2 + 4.0*x3**2 + 5.0*x4 - 127.0 <= 0.0
7.0*x0 + 3.0*x1 + 10.0*x2**2 + x3 - x4 - 282.0 <= 0.0
23.0*x0 + x1**2 + 6.0*x5**2 - 8.0*x6 - 196.0 <= 0.0
4.0*x0**2 + x1**2 - 3.0*x0*x1 + 2.0*x2**2 + 5.0*x5 - 11.0*x6 <= 0.0
"""
cf = generate_constraint(generate_solvers(simplify(equations)))
pf = generate_penalty(generate_conditions(equations), k=1e12)

if __name__ == '__main__':

    from mystic.solvers import diffev2
    from mystic.math import almostEqual

    result = diffev2(objective,
                     x0=bounds,
                     bounds=bounds,
                     constraints=cf,
                     penalty=pf,
                     npop=40,
                     gtol=200,
                     disp=False,
Beispiel #6
0
import mystic.symbolic as ms
from mystic.constraints import and_ as _and, or_ as _or
from mystic.coupler import and_, or_


if __name__ == '__main__':
    eps = 1e-16

    equations = """
    A*B + C > 1
    B < 0
    """
    print(equations)

    var = list('ABC')
    eqns = ms.simplify(equations, variables=var, all=True)
    if isinstance(eqns, str):
      _join = join_ = None
      print(eqns)
    else:
      _join,join_ = _or,or_
      for eqn in eqns:
        print(eqn + '\n----------------------')

    constrain = ms.generate_constraint(ms.generate_solvers(eqns, var, locals=dict(e_=eps)), join=_join)
    solution = constrain([1,-2,1])

    print('solved: %s' % dict(zip(var, solution)))

    penalty = ms.generate_penalty(ms.generate_conditions(eqns, var, locals=dict(e_=eps)), join=join_)
    print('penalty: %s' % penalty(solution))
Beispiel #7
0
from mystic.symbolic import generate_constraint, generate_solvers, simplify
from mystic.symbolic import generate_penalty, generate_conditions

equations = """
4.0*x0 + 5.0*x1 - 3.0*x6 + 9.0*x7 - 105.0 <= 0.0
10.0*x0 - 8.0*x1 - 17.0*x6 + 2.0*x7 <= 0.0
-8.0*x0 + 2.0*x1 + 5.0*x8 - 2.0*x9 - 12.0 <= 0.0
3.0*(x0-2)**2 + 4.0*(x1-3)**2 + 2.0*x2**2 - 7.0*x3 - 120.0 <= 0.0
5.0*x0**2 + 8.0*x1 + (x2-6)**2 - 2.0*x3 - 40.0 <= 0.0
0.5*(x0-8)**2 + 2.0*(x1-4)**2 + 3.0*x4**2 - x5 - 30.0 <= 0.0
x0**2 + 2.0*(x1-2)**2 - 2.0*x0*x1 + 14.0*x4 - 6.0*x5 <= 0.0
-3.0*x0 + 6.0*x1 + 12.0*(x8-8)**2 - 7.0*x9 <= 0.0
"""
cf = generate_constraint(
    generate_solvers(simplify(equations, target=['x5', 'x3'])))
pf = generate_penalty(generate_conditions(equations))

if __name__ == '__main__':
    x = [0] * len(xs)

    from mystic.solvers import fmin_powell
    from mystic.math import almostEqual
    from mystic.monitors import VerboseMonitor
    mon = VerboseMonitor(10)

    result = fmin_powell(objective,
                         x0=x,
                         bounds=bounds,
                         penalty=pf,
                         maxiter=1000,
Beispiel #8
0
    Subject to: x[0] + 1*x[1] <= 7
               -x[0] + 2*x[1] <= 4

    where:  0 <= x[0] <= inf
            0 <= x[1] <= 4
"""
import numpy as np
import mystic.symbolic as ms
import mystic.solvers as my
import mystic.math as mm

# generate constraints and penalty for a linear system of equations
A = np.array([[1, 1], [-1, 2]])
b = np.array([7, 4])
eqns = ms.linear_symbolic(G=A, h=b)
cons = ms.generate_constraint(ms.generate_solvers(ms.simplify(eqns)))
pens = ms.generate_penalty(ms.generate_conditions(eqns), k=1e3)
bounds = [(0., None), (0., 4.)]


# get the objective
def objective(x):
    x = np.asarray(x)
    return x[0]**2 + 4 * x[1]**2 - 32 * x[1] + 64


x0 = np.random.rand(2)

# compare against the exact minimum
xs = np.array([2., 3.])
ys = objective(xs)
Beispiel #9
0
ys = 24.3062091

from mystic.symbolic import generate_constraint, generate_solvers, simplify
from mystic.symbolic import generate_penalty, generate_conditions

equations = """
4.0*x0 + 5.0*x1 - 3.0*x6 + 9.0*x7 - 105.0 <= 0.0
10.0*x0 - 8.0*x1 - 17.0*x6 + 2.0*x7 <= 0.0
-8.0*x0 + 2.0*x1 + 5.0*x8 - 2.0*x9 - 12.0 <= 0.0
3.0*(x0-2)**2 + 4.0*(x1-3)**2 + 2.0*x2**2 - 7.0*x3 - 120.0 <= 0.0
5.0*x0**2 + 8.0*x1 + (x2-6)**2 - 2.0*x3 - 40.0 <= 0.0
0.5*(x0-8)**2 + 2.0*(x1-4)**2 + 3.0*x4**2 - x5 - 30.0 <= 0.0
x0**2 + 2.0*(x1-2)**2 - 2.0*x0*x1 + 14.0*x4 - 6.0*x5 <= 0.0
-3.0*x0 + 6.0*x1 + 12.0*(x8-8)**2 - 7.0*x9 <= 0.0
"""
cf = generate_constraint(generate_solvers(simplify(equations, target=['x5','x3'])))
pf = generate_penalty(generate_conditions(equations))



if __name__ == '__main__':
    x = [0]*len(xs)

    from mystic.solvers import fmin_powell
    from mystic.math import almostEqual
    from mystic.monitors import VerboseMonitor
    mon = VerboseMonitor(10)

    result = fmin_powell(objective, x0=x, bounds=bounds, penalty=pf, maxiter=1000, maxfun=100000, ftol=1e-12, xtol=1e-12, gtol=10, disp=False, full_output=True)

    assert almostEqual(result[0], xs, tol=1e-2)
Beispiel #10
0
def cf(len=3):
    return generate_constraint(generate_solvers(simplify(equations(len))))
Beispiel #11
0
    return a * x3**3 + b * x2**2 + c * x1 + d * x0


# generate some sparse data
xtrain = np.random.uniform(0, 100, size=(10, 4))
target = model(xtrain.T).T
xtest = np.random.uniform(0, 100, size=(10, 4))
test = model(xtest.T).T

# define some model constraints
equations = """
3*b + c > -0.75
4.5*b - d > 11.0
"""
var = list('abcd')
equations = simplify(equations, variables=var)
cf = generate_constraint(generate_solvers(equations, variables=var))

if __name__ == '__main__':
    # build a kernel-transformed regressor
    ta = pre.FunctionTransformer(func=vectorize(cf, axis=1))
    tp = pre.PolynomialFeatures(degree=3)
    e = lin.LinearRegression()

    # train and score, then test and score
    xtrain_ = tp.fit_transform(ta.fit_transform(xtrain))
    assert 1.0 == e.fit(xtrain_, target).score(xtrain_, target)
    xtest_ = tp.fit_transform(ta.fit_transform(xtest))
    assert 1 - e.score(xtest_, test) <= 1e-2

# EOF
eqn = 'A = (B - 1/C)/(1 - (B*C))'
assert set(_solve_zeros(eqn, var)) == set(['C = 0', 'B = 1/C'])
eqn = 'A = (B - 1/C)/(1 - sin(B*C))'
assert set(_solve_zeros(eqn, var)) == set(['C = 0', '(1 - sin(B*C)) = 0'])
eqn = 'A = (B - 1/C)/(1 - (B*C)**2)'
assert set(_solve_zeros(eqn, var)) == set(['C = 0', 'B = 1/C'])
eqn = 'A = (B - 1/C)/(4 - (B*C)**2)'
assert set(_solve_zeros(eqn, var)) == set(['C = 0', 'B = 2/C'])
eqn = 'A = (B - 1/C)/(B - 1)**2'
assert set(_solve_zeros(eqn, var)) == set(['C = 0', 'B = 1'])
eqn = 'A = B + 1'
assert _solve_zeros(eqn, var) == []

eqn = 'A**2 + B*(2 - C) < C*A'
var = list('ABC')
res = simplify(eqn, variables=var, target=list('CAB'), all=True)
#print('\n#####\n'.join(res))
bylen = lambda x: len(x)
res = ['\n'.join(sorted(eqns.split('\n'), key=bylen)) for eqns in res]
assert equals(eqn, res[0].split('\n')[-1], dict(A=-0.9, B=1., C=1.))
assert equals(eqn, res[0].split('\n')[-1], dict(A=-0.9, B=1., C=-1.))
assert equals(eqn, res[0].split('\n')[-1], dict(A=1.1, B=-1., C=1.))
assert equals(eqn, res[0].split('\n')[-1], dict(A=1.1, B=-1., C=-1.))
assert equals(eqn, res[1].split('\n')[-1], dict(A=-1.1, B=1., C=1.))
assert equals(eqn, res[1].split('\n')[-1], dict(A=-1.1, B=1., C=-1.))
assert equals(eqn, res[1].split('\n')[-1], dict(A=0.9, B=-1., C=-1.))
assert equals(eqn, res[1].split('\n')[-1], dict(A=0.9, B=-1., C=1.))

res = simplify(eqn, variables=var, target=list('BCA'), all=True)
#print('\n#####\n'.join(res))
bylen = lambda x: len(x)
eqn = 'A = (B - 1/C)/(1 - (B*C))'
assert set(_solve_zeros(eqn, var)) == set(['C = 0', 'B = 1/C'])
eqn = 'A = (B - 1/C)/(1 - sin(B*C))'
assert set(_solve_zeros(eqn, var)) == set(['C = 0', '(1 - sin(B*C)) = 0'])
eqn = 'A = (B - 1/C)/(1 - (B*C)**2)'
assert set(_solve_zeros(eqn, var)) == set(['C = 0', 'B = 1/C'])
eqn = 'A = (B - 1/C)/(4 - (B*C)**2)'
assert set(_solve_zeros(eqn, var)) == set(['C = 0', 'B = 2/C'])
eqn = 'A = (B - 1/C)/(B - 1)**2'
assert set(_solve_zeros(eqn, var)) == set(['C = 0', 'B = 1'])
eqn = 'A = B + 1'
assert _solve_zeros(eqn, var) == []

eqn = 'A**2 + B*(2 - C) < C*A'
var = list('ABC')
res = simplify(eqn, variables=var, target=list('CAB'), all=True)
#print('\n#####\n'.join(res))
bylen = lambda x: len(x)
res = ['\n'.join(sorted(eqns.split('\n'), key=bylen)) for eqns in res]
assert equals(eqn, res[0].split('\n')[-1], dict(A=-0.9,B=1.,C=1.))
assert equals(eqn, res[0].split('\n')[-1], dict(A=-0.9,B=1.,C=-1.))
assert equals(eqn, res[0].split('\n')[-1], dict(A=1.1,B=-1.,C=1.))
assert equals(eqn, res[0].split('\n')[-1], dict(A=1.1,B=-1.,C=-1.))
assert equals(eqn, res[1].split('\n')[-1], dict(A=-1.1,B=1.,C=1.))
assert equals(eqn, res[1].split('\n')[-1], dict(A=-1.1,B=1.,C=-1.))
assert equals(eqn, res[1].split('\n')[-1], dict(A=0.9,B=-1.,C=-1.))
assert equals(eqn, res[1].split('\n')[-1], dict(A=0.9,B=-1.,C=1.))

res = simplify(eqn, variables=var, target=list('BCA'), all=True)
#print('\n#####\n'.join(res))
bylen = lambda x: len(x)
Beispiel #14
0
import numpy as np
import mystic.symbolic as ms
import mystic.solvers as my
import mystic.math as mm

# generate constraints and penalty for a nonlinear system of equations
ieqn = '''
   -2*x0 + 2*x1 <= -2
    2*x0 - 4*x1 <= 0
'''
eqn = '''
     x0**3 - x1 == 0
'''
cons = ms.generate_constraint(
    ms.generate_solvers(ms.simplify(eqn, target='x1')))
pens = ms.generate_penalty(ms.generate_conditions(ieqn), k=1e3)
bounds = [(0., None), (1., None)]


# get the objective
def objective(x, sign=1):
    x = np.asarray(x)
    return sign * (2 * x[0] * x[1] + 2 * x[0] - x[0]**2 - 2 * x[1]**2)


x0 = np.random.rand(2)

# compare against the exact minimum
xs = np.array([2., 1.])
ys = objective(xs, -1)