Metadata-Version: 2.1
Name: arls
Version: 1.0.2
Summary: Robust solver plus constraints for ill-conditioned linear systems of any shape
Home-page: http://www.rejtrix.net/
Author: Rondall E Jones
Author-email: rejones7@msn.com
License: UNKNOWN
Project-URL: Bug Tracker, https://github.com/pypa/sampleproject/issues
Description: ARLS: Automatically Regularized Linear System Solver
        
        Arls is intended for use in solving linear systems, Ax=b, which other solvers 
        may not be able to handle. Ill-conditioning is the usual reason for people to seek
        alternative solvers such as arls(). In addition, arls() has a rich set of 
        constraints which can be useful in solving both difficult and easy systems.
        
        All these solvers apply to any shape of the matrix, A. That is, the 
        system can have more rows than columns (over-determined), or the same number
        of rows and columns (square), or fewer rows than columns (under-determined). And the matix
        A can be full rank, or have near zero singular values, or exactly zero singular 
        values of any number.
        
        Please see the in-code comments for details of calls and returns, including example applications for each routine.
        
        Our primary solver is:
            x = arls1(A, b)[0]
        
        If you need to solve many systems with the same matrix, A, but different b vectors, use:
            x = arlsusv(A, b, U, S, Vt)[0]
        See details in the code comments for how to get U, S, Vt.
        
        If you need the solution to be constrained to be non-negative, use:
            x = arlsnn(A, b)
            
        If you need to add constraint equations which must be satisfied exactly (such as
        "the sum of the solution elements must be 100.0") then put those equation in a 
        separate system, Ex == f and call:
            x = arlseq(A, b, E, f)
        
        If you need to add inequality constraints, such as "x1 + x2 >= 1.0" then 
        put those equations in a separate system, Gx >= h and call:
            x = arlsgt(A, b, G, h)
            
        If you need both equality and inequality constraints, use
            x =arlsall(A, b, E, f, G, h) 
        
        You can also constrain the shape of the solution with
            x = arlshape(A, b, nonneg, slope, curve)
        You can constrain the solution to be 
            (1) nonnegative; and/or 
            (2) monotonically non-decreasing (i.e., rising) 
                or monotonically non-increasing (i.e., falling); and/or 
            (3) concave upward (like y = x*x) or concave downward.
        Examples: 
            x = arlshape(A, b, 1, 1, 0) will force x to be nonnegative and rising.
            x = arlshape(A, b, 0, -1, 1) will force x to be falling and concave up.
        See details in the code comments.
            
        
        
        
        
Platform: UNKNOWN
Classifier: Programming Language :: Python :: 3
Classifier: License :: OSI Approved :: MIT License
Classifier: Operating System :: OS Independent
Requires-Python: >=3.6
Description-Content-Type: text/plain
