Python solver error

• Forums

• Homework Help

• Engineering and Comp Sci Homework Help

Suggested for: Python equation solver, I’m getting a floating point error

• Forums

• Homework Help

• Engineering and Comp Sci Homework Help

GitHub Stars

1

Forks

0

Contributors

1

The PyPI package error-solver receives a total of
37 downloads a week. As such, we scored
error-solver popularity level to be Limited.

Based on project statistics from the GitHub repository for the
PyPI package error-solver, we found that it has been
starred 1 times.

The download numbers shown are the average weekly downloads from the
last 6 weeks.

Release Date

Jun 4, 2019

Direct Vulnerabilities

• 0

  C

• 0

  H

• 0

  M

• 0

  L

Indirect Vulnerabilities

• 0

  C

• 0

  H

• 0

  M

• 0

  L

We found a way for you to contribute to the project! Looks like
error-solver is missing a security policy.

You can
connect your project’s repository to Snyk
to stay up to date on security alerts and receive automatic fix pull
requests.

Keep your project free of vulnerabilities with Snyk

Open Issues

0

Open PR

0

Last Release

4 years ago

Last Commit

4 years ago

Further analysis of the maintenance status of error-solver based on
released PyPI versions cadence, the repository activity,
and other data points determined that its maintenance is
Inactive.

An important project maintenance signal to consider for error-solver is
that it
hasn’t seen any new versions released to PyPI in the
past 12 months, and could be considered as a discontinued project, or that which
receives low attention from its maintainers.

In the past month we didn’t find any pull request activity or change in
issues status has been detected for the GitHub repository.

Python Versions Compatibility

>=3.5

Age

4 years

Latest Release

4 years ago

Dependencies

2 Direct / 2 Total

Versions

4

Maintainers

1

Wheels

OS Independent

def test_solver():
    """Verify linear/quadratic solution."""
    # Set input data for the test
    I = 1.2; V = 3; m = 2; b = 0.9; k = 4
    s = lambda u: k*u
    T = 2
    dt = 0.2
    N = int(round(T/dt))
    time_points = np.linspace(0, T, N+1)

    # Test linear damping
    t = sp.Symbol('t')
    q = 2  # arbitrary constant
    u_exact = I + V*t + q*t**2   # sympy expression
    F_term = lhs_eq(t, m, b, s, u_exact, 'linear')
    print 'Fitted source term, linear case:', F_term
    F = sp.lambdify([t], F_term)
    u, t_ = solver(I, V, m, b, s, F, time_points, 'linear')
    u_e = sp.lambdify([t], u_exact, modules='numpy')
    error = abs(u_e(t_) - u).max()
    tol = 1E-13
    assert error < tol

    # Test quadratic damping: u_exact must be linear
    u_exact = I + V*t
    F_term = lhs_eq(t, m, b, s, u_exact, 'quadratic')
    print 'Fitted source term, quadratic case:', F_term
    F = sp.lambdify([t], F_term)
    u, t_ = solver(I, V, m, b, s, F, time_points, 'quadratic')
    u_e = sp.lambdify([t], u_exact, modules='numpy')
    error = abs(u_e(t_) - u).max()
    assert error < tol

 def setUp(self):
     self.testcube = solver()
     self.solved = cube()
     self.strings = ["FRLUULRFFBLF","FBFRRBLF","UULLFBLUURRDDBDRDLLFBBB",
                     "DBLURFBLURUDDDBFRLLRUFFB","BRBULFFUDDUBRBURLDUBLDRU",
                     "BFRDUFRLURFBDURBFLRUULRDBFLRUFBRLDUFRDDRFBLDUFBDRLUBF",
                     "UBRDULRUDRURBFURDBFRDLUBFRLUDBFRDUBFRLUDBFRURDFBURLBF"]

def test_all_functions():
    """Verify a linear/quadratic solution."""
    I = 1.2; V = 3; m = 2; b = 0.9
    s = lambda u: 4*u
    t = sp.Symbol('t')
    T = 2
    dt = 0.2
    N = int(round(T/dt))
    time_points = np.linspace(0, T, N+1)

    def solver_linear_damping_wrapper(
        I, V, m, b, s, F, t, damping='linear'):
        """Wrapper such that solver_linear_damping can be called as solver."""
        if callable(F):
            F = F(t)
        return solver_linear_damping(I, V, m, b, s, F, t), t

    functions = [solver, solver_linear_damping_wrapper]
    try:
        from solver_cy import solver as solver_cy
        functions.append(solver_cy)
    except ImportError:
        print 'Cython module is not compiled'
        pass

    for function in functions:
        print 'testing', function.__name__
        # Test linear damping
        q = 2  # arbitrary constant
        u_exact = I + V*t + q*t**2
        u_e = sp.lambdify(t, u_exact, modules='numpy')
        F = sp.lambdify(t, lhs_eq(t, m, b, s, u_exact, 'linear'))
        u, t_ = solver(I, V, m, b, s, F, time_points, 'linear')
        error = abs(u_e(t_) - u).max()
        nt.assert_almost_equal(error, 0, places=13)

        # Test quadratic damping
        if function != solver_linear_damping_wrapper:

            # In the quadratic damping case, u_exact must be linear
            # in order exactly recover this solution
            u_exact = I + V*t
            u_e = sp.lambdify(t, u_exact, modules='numpy')
            F = sp.lambdify(t, lhs_eq(t, m, b, s, u_exact, 'quadratic'))
            u, t_ = solver(I, V, m, b, s, F, time_points, 'quadratic')
            error = abs(u_e(t_) - u).max()
            nt.assert_almost_equal(error, 0, places=13)

def test(size):
  a = generate_a(size)
  x = generate_x(size)
  b = a.dot(x)
  xx = solver.solver(a,b)
  print(x)
  print("result:",xx)
  print(linalg.norm(x-xx))

def box_actions(results, times, N_matrix, ifprint):
    """
        Finds actions, angles and frequencies for box orbit.
        Takes a series of phase-space points from an orbit integration at times t and returns
        L = (act,ang,n_vec,toy_aa, pars) -- explained in find_actions() below.
    """
    if ifprint:
        print ("n=====nUsing triaxial harmonic toy potential")

    t = time.time()
    # Find best toy parameters
    omega = toy.findbestparams_ho(results)
    if ifprint:
        print ("Best omega " + str(omega) + " found in " + str(time.time() - t) + " seconds")

    # Now find toy actions and angles
    AA = np.array([toy.angact_ho(i, omega) for i in results])
    AA = AA[~np.isnan(AA).any(1)]
    if len(AA) == 0:
        return

    t = time.time()
    act = solver.solver(AA, N_matrix)
    if act == None:
        return

    if ifprint:
        print (
            "Action solution found for N_max = "
            + str(N_matrix)
            + ", size "
            + str(len(act[0]))
            + " symmetric matrix in "
            + str(time.time() - t)
            + " seconds"
        )

    np.savetxt("GF.Sn_box", np.vstack((act[1].T, act[0][3:])).T)

    ang = solver.angle_solver(AA, times, N_matrix, np.ones(3))
    if ifprint:
        print (
            "Angle solution found for N_max = "
            + str(N_matrix)
            + ", size "
            + str(len(ang))
            + " symmetric matrix in "
            + str(time.time() - t)
            + " seconds"
        )

    # Just some checks
    if len(ang) > len(AA):
        print ("More unknowns than equations")

    return act[0], ang, act[1], AA, omega

    def test_solving_steps(self):
       cubes = []
       for s in self.strings:
            c = solver()
            c.do_string(s)
            cubes.append(c)
       for c in cubes:
            c.solmoves = []
            c._upper_edges_FRBL()
            c._upper_edges_D()
            self.check_top_edges(c)

            c._upper_corners()
            self.check_top_corners(c)

            c.solve_middle()
            self.check_middle(c)

            c.solve_down()
            temp = solver()
            self.assertTrue(c == temp)

    def __init__(self, master):

        frame = Frame(master)
        frame.pack()

        self.rcube = solver()
        self.scramble_moves = []

        bframe = Frame(frame) #frame for cube manipulation

        #rotation buttons
        self.r = Button(bframe, text="Right", command=lambda: self.do_rotation('R'))
        self.r.grid(row=1)
        self.l = Button(bframe, text="Left", command=lambda: self.do_rotation('L'))
        self.l.grid(row=1,column=1)
        self.f = Button(bframe, text="Front", command=lambda: self.do_rotation('F'))
        self.f.grid(row=2)
        self.b = Button(bframe, text="Back", command=lambda: self.do_rotation('B'))
        self.b.grid(row=2,column=1)
        self.u = Button(bframe, text="Upper", command=lambda: self.do_rotation('U'))
        self.u.grid(row=3)
        self.d = Button(bframe, text="Down", command=lambda: self.do_rotation('D'))
        self.d.grid(row=3,column=1)

        self.newcube = Button(bframe, text="Create New Cube", command=self.create_cube)
        self.newcube.grid(row=0,column=0)

        self.scramble = Button(bframe, text="Scramble Cube",command=self.scramble_cube)
        self.scramble.grid(row=0,column=1)

        bframe.pack(side=RIGHT)

        downframe = Frame(frame)

        self.quit = Button(downframe, text="QUIT", fg="red", command=frame.quit)
        self.quit.pack(side=RIGHT)

        solveframe = Frame(downframe)

        self.solve = Button(solveframe, text="Solve Cube",command=self.solve_cube)
        self.solve.pack(side=LEFT)

        self.solinfo = Button(solveframe, text="Solution Info",command=self.sol_info)
        self.solinfo.pack(side=RIGHT)

        solveframe.pack(side=LEFT)
        downframe.pack(side=BOTTOM,pady=15,padx=15)

        self.cube_disp(frame)

def loop_actions(results, times, N_matrix, ifprint):
    """
        Finds actions, angles and frequencies for loop orbit.
        Takes a series of phase-space points from an orbit integration at times t and returns
        L = (act,ang,n_vec,toy_aa, pars) -- explained in find_actions() below.
        results must be oriented such that circulation is about the z-axis
    """
    if(ifprint):
        print("n=====nUsing isochrone toy potential")
    
    t = time.time()
    # First find the best set of toy parameters
    params = toy.findbestparams_iso(results)
    if(params[0]!=params[0]):
        params = np.array([10.,10.])
    if(ifprint):
        print("Best params "+str(params)+" found in "+str(time.time()-t)+" seconds")

    # Now find the toy angles and actions in this potential
    AA = np.array([toy.angact_iso(i,params) for i in results])
    AA = AA[~np.isnan(AA).any(1)]
    if(len(AA)==0):
        return 

    t = time.time()
    act = solver.solver(AA, N_matrix,symNx = 1)
    if act==None:
        return

    if(ifprint):
        print("Action solution found for N_max = "+str(N_matrix)+", size "+str(len(act[0]))+" symmetric matrix in "+str(time.time()-t)+" seconds")

    # Store Sn
    np.savetxt("GF.Sn_loop",np.vstack((act[1].T,act[0][3:])).T)

    # Find angles
    sign = np.array([1.,np.sign(results[0][0]*results[0][4]-results[0][1]*results[0][3]),1.])
    ang = solver.angle_solver(AA,times,N_matrix,sign,symNx = 1)
    if(ifprint):
        print("Angle solution found for N_max = "+str(N_matrix)+", size "+str(len(ang))+" symmetric matrix in "+str(time.time()-t)+" seconds")
    
    # Just some checks
    if(len(ang)>len(AA)):
        print("More unknowns than equations")

    return act[0], ang, act[1], AA, params

def test_compare_action_prepare():

    from ..actionangle import _action_prepare, _angle_prepare
    import solver
    logger.setLevel(logging.ERROR)
    AA = np.random.uniform(0., 100., size=(1000,6))
    t = np.linspace(0., 100., 1000)

    act_san,n_vectors = solver.solver(AA, N_max=6, symNx=2)
    A2,b2,n = _action_prepare(AA, N_max=6, dx=2, dy=2, dz=2)
    act_apw = np.array(solve(A2,b2))

    ang_san = solver.angle_solver(AA, t, N_max=6, symNx=2, sign=1)
    A2,b2,n = _angle_prepare(AA, t, N_max=6, dx=2, dy=2, dz=2)
    ang_apw = np.array(solve(A2,b2))

    assert np.allclose(act_apw, act_san)
    assert np.allclose(ang_apw, ang_san)

def getpost():
    """
    Stdin comes from the web page and is a set of letters.

    Call solver and send the solution (an html table) to stdout.
    """
    logging.basicConfig(filename='results.log',level=logging.DEBUG)
    cgitb.enable()
    form = cgi.FieldStorage()
    instr = form["data"].value.replace(' ','0')
    pieces = list(instr)
    logging.info(pieces)
    answer = solver(pieces)
    print "Content-type: text/html"
    print
    logging.info('response: ')
    logging.info(answer)
    print answer

def generate_bumpy_road(nbumps=12, L=200, resolution=500):
    """Generate one road profile by using a vibration ODE."""
    n = nbumps*resolution      # no of compute intervals along the road
    x = np.linspace(0, L, n+1) # points along the road
    dx = x[1] - x[0]           # step along the road
    white_noise = np.random.randn(n+1)/np.sqrt(dx)
    # Compute h(x)
    k = 1.
    m = 4.
    if dx > 2/np.sqrt(k/m):
        print 'Unstable scheme'
    def s(u):
        return k*u

    h, x = solver(I=0, V=0, m=m, b=3, s=s, F=white_noise,
                  t=x, damping='linear')
    h = h/h.max()*0.2
    return h, x

def doit(name, n,r, g,W, x,z):
    print
    print
    print "// ------- Generated from kkt_test.py ---"
    print "template <typename Scalar> int kkt_test_%s() {" % name
    print
    print "typedef Eigen::Matrix<Scalar, Eigen::Dynamic, Eigen::Dynamic> Matrix;"
    print "typedef Eigen::Matrix<Scalar, Eigen::Dynamic, 1> Vector;"
    print
    print "// Problem"
    print "int n = %d;" % n
    print "int r = %d;" % r
    print "Matrix g(n,n);"

    print "cvxopt::ScalingMatrix<Scalar> w;"
    print "w.d.resize(2*r*n);"
    print "Vector x(n*(r+1)), y, z(2*n*r);"

    print_cxx("x", x)
    print_cxx("z", z)

    print_cxx("g", g)
    print_cxx("w.d", W['d'])

    print
    print "// Solve"
    print "KQP_KKTPreSolver<Scalar> kkt_presolver(g, Vector::Ones(r));"
    print "boost::shared_ptr<cvxopt::KKTSolver<Scalar> > kktSolver(kkt_presolver.get(w));"
    print "kktSolver->solve(x,y,z);"
    print
    
    F = solver(n,r,g)
    sF = F(W)
    sF(x, None, z)

    print
    print "// Solution"
    
    print "Eigen::VectorXd s_x(n*(r+1)), s_z(2*n*r);"
    print_cxx("s_x", x)
    print_cxx("s_z", z)

    print """

 def main(self):
     solver= sol.solver();
     i=0;
     answer=""
     while i!=-1:
         print("Please chose one of the modes");
         print("1.SA-KQ");
         print("2.SA-GC");
         print("3.MC-KQ");
         print("4.MC-GC");
         print("5.Exit");
         answer=input(">>");
         try:
             index=int(answer);
         except ValueError:
             continue;
         if(index==1):
             print("1")
             print("Puzzle size ");
             answer=input(">>");
             nr=gr.conv_str2int(answer)
             puzzle=K.K_Puzzle(nr)
             print("How many neighbours? ");
             answer=input(">>");
             nr=gr.conv_str2int(answer)
             solver.algorithm_SA(puzzle,nr)
         elif(index==2):
             print("2")
         elif(index==3):
             print("3")
             print("Puzzle size ");
             answer=input(">>");
             nr=gr.conv_str2int(answer)
             puzzle=K.K_Puzzle(nr)
             print("How many neighbours? ");
             answer=input(">>");
             nr=gr.conv_str2int(answer)
             solver.algorithm_MC(puzzle,nr)
         elif(index==4):
             print("4")
         elif(index==5):
             print("5")
             i=-1

def main():
    ai = matlabarray(zeros (10,10,dtype=int),dtype=int)
    af = copy(ai)

    ai[1,1]=2
    ai[2,2]=3
    ai[3,3]=4
    ai[4,4]=5
    ai[5,5]=1

    af[9,9]=1
    af[8,8]=2
    af[7,7]=3
    af[6,6]=4
    af[10,10]=5

    t0 = time.clock()
    mv = a.solver(ai,af,0)
    t1 = time.clock()
    print t1-t0
    print mv.shape

def getpost():
    """
    Stdin comes from the web page and is a set of sudoku numbers.

    Call solver and send the solution as a set of cell values to stdout.
    """
    logging.basicConfig(filename='results.log',level=logging.DEBUG)
    cgitb.enable()
    form = cgi.FieldStorage()
    instr = form["data"].value.replace(' ','0')
    pieces = list(instr);
    tplate = []
    indx = 0
    logging.info('input: ')
    logging.info(instr)
    for i in range(0,9):
        tplate.append([])
        for j in range(0,9):
           tplate[i].append(pieces[indx])
           indx += 1
    info_res, result = solver(tplate)
    logging.info('info_res:')
    logging.info(info_res)
    if info_res == 'failure':
        logging.info('failure')
        print "Content-type: text/html"
        print
        print instr.replace('0', ' ')
        return
    outstr = []
    for i in range(0,9):
        for j in range(0,9):
            outstr.append(result[i][j])
    print "Content-type: text/html"
    print
    response = ''.join(outstr).replace('0', ' ')
    logging.info('response: ')
    logging.info(response)
    print response

v = 2.0                         # velocity (constant)

# Vertical displacement calculation
m = 2                           # mass of the system
b = 0.2                         # friction parameter
k = 1.5                         # spring parameter
T = road_xmax/v                 # end time
t = np.linspace(0, T, n+1)      # numerical time mesh
s = lambda u: k*u               # restoring force of spring
F = lambda t: -m*d2h(v*t)       # excitation force

import sys, os
sys.path.insert(0, os.path.join(os.pardir, 'src-bumpy'))
import solver

u, t = solver.solver(I=0, V=0, m=m, b=b, s=s, F=F, t=t,
                     damping='linear')

u_amplitude = (u.max() - u.min())/2
u_scaled = R*u/u_amplitude
u_solution = Curve(v*t, 5*H + u_scaled).set_linecolor('blue').set_linewidth(1)

arc_length = 0  # arc_length along road

def draw_vehicle(x, y, x0, y0, u):
    mass_width = 3*R
    mass_height = 1.5*R
    spring_length = 3*R
    spring_start = (x, y+2*R)

    tire_center = point(x, y+R)
    tire = Composition({

 def test_solver_on_small_data(self):
     data = '../data/words_small.txt'
     [largest_word, second_largest_word, count] = solver(data)
     self.assertEquals(largest_word, (11, ['catsdogcats']))
     self.assertEquals(second_largest_word, (10, ['dogcatsdog']))
     self.assertEquals(count, 3)

from matplotlib.pyplot import *
plot(t, u)
savefig('tmp.pdf')   # save plot to PDF file
savefig('tmp.png')   # save plot to PNG file
show()
# End solver_linear_damping

import numpy as np
from numpy import sin, pi  # for nice math
from solver import solver

def F(t):
    # Sinusoidal bumpy road
    return A*sin(pi*t)

def s(u):
    return k*(0.2*u + 1.5*u**3)

A = 0.25
k = 2
t = np.linspace(0, 100, 10001)
u, t = solver(I=0.1, V=0, m=2, b=0.5, s=s, F=F, t=t,
              damping='quadratic')

# Show u(t) as a curve plot
import matplotlib.pyplot as plt
plt.plot(t, u)
plt.savefig('tmp.png')
plt.savefig('tmp.pdf')
plt.show()

from cube import cube
from solver import solver

cb = solver()
done = False
while not done:
    ms = raw_input("Scramble String: ")
    ms = ms.upper()
    done = True
    for c in ms:
        done = done and ((c in cb.sides) or (c in ["2", "3"]) or (c == "'"))
    if not done:
        print "You used an invalid character"

cb.do_string(ms)
cb.solve()
disp = cube()
disp.do_string(ms)

print "Initial cube state:"
disp.print_cube()
for step in cb.solmoves:
    raw_input("next move is: " + step)
    disp.do_string(step)
    disp.print_cube()

def pretty_print(board):
    for i in range(len(board)):
        print board[i]


edge = 4

lst_board = 'D C L P  E I A E  R N T R  S E G S'.lower().split()


board = []
for i in range(0,16,4):
    board.append(lst_board[i:i+4])
pretty_print(board)
s = solver.solver(edge)
words =  sorted(s.solve(board))
print words

score = 0
for word in words:
    if len(word) == 3 or len(word) == 4:
        score += 1
    if len(word) == 5:
        score += 2
    if len(word) == 6:
        score += 3
    if len(word) > 6:
        score += 5
print score
    

b = 0.8  # friction parameter
k = 2  # spring parameter
V = 1.5
T = road_xmax / v  # end time
t = np.linspace(0, T, 101)  # numerical time mesh
s = lambda u: k * u  # restoring force of spring
F = lambda t: -m * d2h(v * t)  # excitation force

import sys, os

sys.path.insert(0, os.path.join(os.pardir, "src-bumpy"))
import solver

print road_xmax, T, v, v * T

u, t = solver.solver(I=0, V=V, m=m, b=b, s=s, F=F, t=t, damping="linear")

"""
# if you want to see plot of solver function, turn me on
import matplotlib.pyplot as plt
plt.plot(t, u)
plt.show()
"""
u_solution = Curve(v * t, 5 * H + 0.5 * H * u)

over = Rectangle(lower_left_corner=(-1.5 * R, 2 * H), width=3 * R, height=0.75 * H)

tire = Composition(
    {
        "wheel": Circle(center=(0, 0), radius=R),
        "cross": Composition({"cross1": Line((0, -1), (0, R)), "cross2": Line((-R, 0), (R, 0))}),

def main():
  # sentences = ['distance is speed times time', 'energy is force times distance',
  #              'energy is power times time', 'power is speed times force']
  sentences = ['distance is speed times time', 'speed times time is distance',
               'force is mass times acceleration',
               'speed is acceleration times time', 'power is speed times force',
               'energy is force times distance', 'energy is power times time',
               'speed is distance divided by time',
               'acceleration is speed divided by time',
               'speed times force is power',
               'speed is power divided by force']
  # sentences = [
  #   'distance is speed times time',
  #   'speed times time is distance',
  #   'speed is distance divided time',
  #   'distance is speed2 times time',
  #              'speed2 times time is distance',
  #              'speed2 is distance divided time',
  #              ]
  tuples = generateTuples(sentences)
  # [
  # [
  #     ('f', frozenset(['m', 'a']))
  #   ],
  #   [
  #     ('p', frozenset(['s', 'f']))
  #   ]
  # ]
  (solutions, globalStats) = solver.solver(tuples, [solver.featureConsistentTemplates, solver.validModels, solver.featurePercentagesTemplates, solver.featureMajorityTemplates])

  # solMap = {}
  # for s in solutions.keys():
  #   varSet = set({s[0][0]}).union(s[0][1])
  #   k = (varSet,s[1][0].word,s[1][1].word)
  #   if not solMap.has_key(k):
  #     solMap[k] = solutions[s]
  #   elif solutions[s]>solMap[k]:
  #     solMap[k] = solutions[s]

  pprint.pprint(solutions)
  pprint.pprint(globalStats)

  f1TimesCount = 0
  f1DividedCount = 0
  f2TimesCount = 0
  f2DividedCount = 0
  f3TimesCount = 0
  f3DividedCount = 0

  for (k, c) in solutions.iteritems():
    if k[1][1].word == "times" and k[1][0].templateNumber == 0: f1TimesCount += c
    if k[1][1].word == "divided" and k[1][0].templateNumber == 0: f1DividedCount += c
    if k[1][1].word == "times" and k[1][0].templateNumber == 1: f2TimesCount += c
    if k[1][1].word == "divided" and k[1][0].templateNumber == 1: f2DividedCount += c
    if k[1][1].word == "times" and k[1][0].templateNumber == 2: f3TimesCount += c
    if k[1][1].word == "divided" and k[1][0].templateNumber == 2: f3DividedCount += c

  print f1TimesCount
  print f1DividedCount
  print f2TimesCount
  print f2DividedCount
  print f3TimesCount
  print f3DividedCount

    print
    print "=== G"
    print G
    print
    print "=== h"
    print h.T
    print

    
print "=== Problem size: n=%d and r=%d ===nn" % (n, r)
print "* np = %d" % np
print "* lambda = %g" % Lambda

print "nn   [[[Solving with optimised]]]"
T1 = time()
sol = solvers.coneqp(P, q, G, h, kktsolver=solver(n,r,g))
print "Time taken = %s" % (time() - T1)
print sol['status']
if (n * r < 10): print "Solution = %s" % sol['x'].T

printing.options['width'] = n

nzeros=0
xi = sol['x'][n*r:n*(r+1)]
maxxi=max(xi)
print sum(xi[0:n])
for i in xrange(n):
    if xi[i]/maxxi < 1e-4: nzeros += 1

print "xi = %s" % sorted(xi.T/maxxi)
print "Sparsity = %d on %d" % (nzeros, n)

 def create_cube(self):
     del self.rcube
     self.rcube = solver()
     self.output_cube()
     self.scramble_moves = []

tests = 0

all_lines = []
full_dict = []
cases = []

with open(in_file) as f:
	all_lines = f.readlines()

params = all_lines[0]
params = params.split(" ");
wordsize = int(params[0])
dictSize = int(params[1])
tests = int(params[2])

full_dict = all_lines[1:1+dictSize]
cases = all_lines[1+dictSize:]
	
word_graph = alien_dict(full_dict, wordsize)

for i in range(len(cases)):
	cases[i] = ip.parse_raw(cases[i])

result = dict()

for i in range(len(cases)):
	result[i+1] = sv.solver(word_graph, cases[i]).solve()

for key, val in result.items():
	print('Case {}: {}'.format(key, val))