[
{
"path": ".coin-or/projDesc.xml",
"content": "\n\n\n\n \n CyLP\n CyLP\n\n \n CyLP is a Python interface to COIN-OR's Linear and mixed-integer program solvers (CLP, CBC, and CGL).\n CyLP's unique feature is that one can use it to alter the solution process of the solvers from within Python.\n For example, one may define cut generators, branch-and-bound strategies, and primal/dual Simplex pivot rules completely in Python.\n \n \n A Python interface to Cbc, Clp, and Cgl.\n \n\n Mehdi Towhidi, mehdi dot towhidi at kronos dot com \n\n https://github.com/coin-or/CyLP \n\n Common Public License 1.0\n https://opensource.org/licenses/cpl1.0.php\n\n \n \n Cbc\n \n \n Clp\n \n \n Cgl\n \n \n\n \n \n Numpy\n http://www.numpy.org\n Required\n \n \n Scipy\n http://www.scipy.org\n Required\n \n \n\n Python\n\n \n Abandoned\n 5\n \n\n \n \n\n \n \n Interfaces\n \n \n Optimization deterministic linear continuous\n \n \n Optimization deterministic linear discrete\n \n \n \n \n\n \n http://mpy.github.io/CyLPdoc\n https://github.com/coin-or/CyLP/releases\n https://pypi.org/project/cylp/\n \n \n\n\n"
},
{
"path": ".github/workflows/ci-cvxpy.yml",
"content": "name: Integration testing with CVXPY\n\non:\n pull_request:\n types: [reopened, opened, synchronize]\n push:\n workflow_dispatch:\n\nconcurrency:\n # Cancel previous runs of this workflow for the same branch\n group: ${{ github.workflow }}-${{ github.ref }}\n cancel-in-progress: true\n\njobs:\n test:\n strategy:\n fail-fast: false\n matrix:\n os: [macos-latest] # Add ubuntu-latest when cvxpy pytest issue is solved\n numpy: [numpy] # We used to also test version 1.26.0, but now cvxpy requires numpy 2 \n\n runs-on: ${{ matrix.os }}\n\n steps:\n \n - uses: actions/setup-python@v5\n with:\n python-version: '3.12'\n\n - name: Install CBC\n run: |\n brew install coin-or-tools/coinor/cbc\n echo \"PKG_CONFIG_PATH=$(brew --prefix)/opt/cbc/lib/pkgconfig:$(brew --prefix)/opt/clp/lib/pkgconfig:$(brew --prefix)/opt/cgl/lib/pkgconfig:$(brew --prefix)/opt/osi/lib/pkgconfig:$(brew --prefix)/opt/coinutils/lib/pkgconfig:$PKG_CONFIG_PATH\" >> $GITHUB_ENV\n\n - name: Job context\n run: |\n echo \"::group::macos context\"\n system_profiler SPSoftwareDataType\n echo \"::endgroup::\"\n\n python -V\n\n echo \"::group::brew cbc info\"\n brew info coin-or-tools/coinor/cbc\n echo \"::endgroup::\"\n \n - uses: actions/checkout@v2\n with:\n path: cylp\n\n - name: Install CyLP\n run: |\n python3 -m pip install --break-system-packages ./cylp\n\n - name: Check out CVXPY\n uses: actions/checkout@v2\n with:\n repository: cvxpy/cvxpy\n path: cvxpy\n\n - name: Install CVXPY\n run: |\n python3 -m pip install --break-system-packages ./cvxpy\n\n - name: Test CVXPY\n run: |\n python3 -m pip install --break-system-packages pytest hypothesis ${{ matrix.numpy }}\n python -m pytest --pyargs cvxpy.tests\n"
},
{
"path": ".github/workflows/cibuildwheel.yml",
"content": "name: Build and upload to PyPI\n# taken from https://github.com/pypa/cibuildwheel/blob/main/examples/github-deploy.yml\n\n# Build on every branch push, tag push, and pull request change:\n# on: [push, pull_request]\n# Alternatively, to publish when a (published) GitHub Release is created, use the following:\non:\n #push:\n pull_request:\n release:\n types:\n - published\n\nconcurrency:\n # Cancel previous runs of this workflow for the same branch\n group: ${{ github.workflow }}-${{ github.ref }}\n cancel-in-progress: true\n\njobs:\n build_wheels:\n name: Build wheels on ${{ matrix.os }}, arch ${{ matrix.arch }}\n runs-on: ${{ matrix.os }}\n strategy:\n fail-fast: false\n matrix:\n include:\n - os: ubuntu-latest\n arch: x86_64\n - os: ubuntu-latest\n arch: i686\n - os: ubuntu-24.04-arm\n arch: aarch64\n - os: macos-15-intel\n arch: x86_64\n - os: macos-latest\n arch: arm64\n env:\n CIBW_ARCHS: ${{ matrix.arch }}\n\n steps:\n - uses: actions/checkout@v4\n - name: Build wheels\n uses: pypa/cibuildwheel@v3.2.1\n\n - uses: actions/upload-artifact@v4\n with:\n name: cibuildwheel-${{ matrix.os }}-${{ matrix.arch }}\n path: ./wheelhouse/*.whl\n\n build_sdist:\n name: Build source distribution\n runs-on: ubuntu-latest\n steps:\n - uses: actions/checkout@v4\n\n - name: Build sdist\n run: pipx run build --sdist\n\n - uses: actions/upload-artifact@v4\n with:\n name: cibuildwheel-sdist\n path: dist/*.tar.gz\n\n upload_pypi:\n needs: [build_wheels, build_sdist]\n runs-on: ubuntu-latest\n environment:\n name: pypi\n url: https://pypi.org/p/cylp\n permissions:\n id-token: write\n\n # upload to PyPI on every tag starting with 'v'\n # if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags/v')\n # alternatively, to publish when a GitHub Release is created, use the following rule:\n if: github.event_name == 'release' && github.event.action == 'published'\n steps:\n - uses: actions/download-artifact@v4\n with:\n pattern: \"cibuildwheel-*\"\n path: dist\n merge-multiple: true\n\n - uses: pypa/gh-action-pypi-publish@release/v1\n\n\n upload_release_assets:\n needs: [build_wheels, build_sdist]\n runs-on: ubuntu-latest\n if: ${{ github.event_name == 'release'}}\n steps:\n - name: Upload artifacts to release\n uses: alexellis/upload-assets@0.4.0\n env:\n GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}\n with:\n asset_paths: '[\"./wheelhouse/*.whl\"]'\n"
},
{
"path": ".github/workflows/release.yml",
"content": "---\nname: Create Release\n\non:\n push:\n tags:\n - 'v*'\n\njobs:\n create_release:\n runs-on: ubuntu-latest\n steps:\n - uses: actions/create-release@v1\n env:\n GITHUB_TOKEN: ${{ secrets.TKRALPHS_RELEASE }}\n with:\n tag_name: ${{ github.ref }}\n release_name: Release ${{ github.ref }}\n draft: false\n prerelease: false\n"
},
{
"path": ".gitignore",
"content": "*.swp\n*~\n.DS_Store\n*.o\n*.so\n*.pyc\n*.pyd\nbuild/\nMANIFEST\nCyLP.egg*\ncylp.egg-info\nsetup.cfg\ndist/\nwheelhouse/\n"
},
{
"path": "AUTHORS",
"content": "Mehdi Towhidi (mehdi.towhidi@gerad.ca)\nDominique Orban (dominique.orban@gerad.ca)\n"
},
{
"path": "LICENSE",
"content": "Eclipse Public License - v 2.0\r\n\r\nTHE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE PUBLIC\r\nLICENSE (“AGREEMENT”). ANY USE, REPRODUCTION OR DISTRIBUTION OF THE PROGRAM\r\nCONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.\r\n\r\n1. DEFINITIONS\r\n “Contribution” means:\r\n\r\n a) in the case of the initial Contributor, the initial content Distributed\r\n under this Agreement, and\r\n b) in the case of each subsequent Contributor:\r\n i) changes to the Program, and\r\n ii) additions to the Program;\r\n where such changes and/or additions to the Program originate from and\r\n are Distributed by that particular Contributor. A Contribution\r\n “originates” from a Contributor if it was added to the Program by such\r\n Contributor itself or anyone acting on such Contributor's behalf.\r\n Contributions do not include changes or additions to the Program that\r\n are not Modified Works. “Contributor” means any person or entity that\r\n Distributes the Program.\r\n\r\n “Licensed Patents” mean patent claims licensable by a Contributor which are\r\n necessarily infringed by the use or sale of its Contribution alone or when\r\n combined with the Program.\r\n\r\n “Program” means the Contributions Distributed in accordance with this\r\n Agreement.\r\n\r\n “Recipient” means anyone who receives the Program under this Agreement or\r\n any Secondary License (as applicable), including Contributors.\r\n\r\n “Derivative Works” shall mean any work, whether in Source Code or other\r\n form, that is based on (or derived from) the Program and for which the\r\n editorial revisions, annotations, elaborations, or other modifications\r\n represent, as a whole, an original work of authorship.\r\n\r\n “Modified Works” shall mean any work in Source Code or other form that\r\n results from an addition to, deletion from, or modification of the contents\r\n of the Program, including, for purposes of clarity any new file in Source\r\n Code form that contains any contents of the Program. Modified Works shall\r\n not include works that contain only declarations, interfaces, types,\r\n classes, structures, or files of the Program solely in each case in order\r\n to link to, bind by name, or subclass the Program or Modified Works\r\n thereof.\r\n\r\n “Distribute” means the acts of a) distributing or b) making available in\r\n any manner that enables the transfer of a copy.\r\n\r\n “Source Code” means the form of a Program preferred for making\r\n modifications, including but not limited to software source code,\r\n documentation source, and configuration files.\r\n\r\n “Secondary License” means either the GNU General Public License, Version\r\n 2.0, or any later versions of that license, including any exceptions or\r\n additional permissions as identified by the initial Contributor.\r\n\r\n2. GRANT OF RIGHTS\r\n\r\n a) Subject to the terms of this Agreement, each Contributor hereby grants\r\n Recipient a non-exclusive, worldwide, royalty-free copyright license to\r\n reproduce, prepare Derivative Works of, publicly display, publicly perform,\r\n Distribute and sublicense the Contribution of such Contributor, if any, and\r\n such Derivative Works.\r\n \r\n b) Subject to the terms of this Agreement, each Contributor hereby grants\r\n Recipient a non-exclusive, worldwide, royalty-free patent license under\r\n Licensed Patents to make, use, sell, offer to sell, import and otherwise\r\n transfer the Contribution of such Contributor, if any, in Source Code or\r\n other form. This patent license shall apply to the combination of the\r\n Contribution and the Program if, at the time the Contribution is added by\r\n the Contributor, such addition of the Contribution causes such combination\r\n to be covered by the Licensed Patents. The patent license shall not apply\r\n to any other combinations which include the Contribution. No hardware per\r\n se is licensed hereunder.\r\n\r\n c) Recipient understands that although each Contributor grants the licenses\r\n to its Contributions set forth herein, no assurances are provided by any\r\n Contributor that the Program does not infringe the patent or other\r\n intellectual property rights of any other entity. Each Contributor\r\n disclaims any liability to Recipient for claims brought by any other entity\r\n based on infringement of intellectual property rights or otherwise. As a\r\n condition to exercising the rights and licenses granted hereunder, each\r\n Recipient hereby assumes sole responsibility to secure any other\r\n intellectual property rights needed, if any. For example, if a third party\r\n patent license is required to allow Recipient to Distribute the Program, it\r\n is Recipient's responsibility to acquire that license before distributing\r\n the Program.\r\n\r\n d) Each Contributor represents that to its knowledge it has sufficient\r\n copyright rights in its Contribution, if any, to grant the copyright\r\n license set forth in this Agreement.\r\n\r\n e) Notwithstanding the terms of any Secondary License, no Contributor makes\r\n additional grants to any Recipient (other than those set forth in this\r\n Agreement) as a result of such Recipient's receipt of the Program under the\r\n terms of a Secondary License (if permitted under the terms of Section 3).\r\n\r\n3. REQUIREMENTS\r\n\r\n3.1 If a Contributor Distributes the Program in any form, then:\r\n\r\n a) the Program must also be made available as Source Code, in accordance\r\n with section 3.2, and the Contributor must accompany the Program with a\r\n statement that the Source Code for the Program is available under this\r\n Agreement, and informs Recipients how to obtain it in a reasonable manner\r\n on or through a medium customarily used for software exchange; and\r\n\r\n b) the Contributor may Distribute the Program under a license different\r\n than this Agreement, provided that such license:\r\n\r\n i) effectively disclaims on behalf of all other Contributors all\r\n warranties and conditions, express and implied, including warranties or\r\n conditions of title and non-infringement, and implied warranties or\r\n conditions of merchantability and fitness for a particular purpose;\r\n\r\n ii) effectively excludes on behalf of all other Contributors all\r\n liability for damages, including direct, indirect, special, incidental\r\n and consequential damages, such as lost profits;\r\n\r\n iii) does not attempt to limit or alter the recipients' rights in the\r\n Source Code under section 3.2; and\r\n\r\n iv) requires any subsequent distribution of the Program by any party to\r\n be under a license that satisfies the requirements of this section 3.\r\n\r\n3.2 When the Program is Distributed as Source Code:\r\n\r\n a) it must be made available under this Agreement, or if the Program (i)\r\n is combined with other material in a separate file or files made available\r\n under a Secondary License, and (ii) the initial Contributor attached to\r\n the Source Code the notice described in Exhibit A of this Agreement, then\r\n the Program may be made available under the terms of such Secondary\r\n Licenses, and\r\n\r\n b) a copy of this Agreement must be included with each copy of the\r\n Program.\r\n\r\n3.3 Contributors may not remove or alter any copyright, patent, trademark,\r\nattribution notices, disclaimers of warranty, or limitations of liability\r\n(‘notices’) contained within the Program from any copy of the Program which\r\nthey Distribute, provided that Contributors may add their own appropriate\r\nnotices.\r\n\r\n4. COMMERCIAL DISTRIBUTION\r\n\r\nCommercial distributors of software may accept certain responsibilities with\r\nrespect to end users, business partners and the like. While this license is\r\nintended to facilitate the commercial use of the Program, the Contributor who\r\nincludes the Program in a commercial product offering should do so in a manner\r\nwhich does not create potential liability for other Contributors. Therefore,\r\nif a Contributor includes the Program in a commercial product offering, such\r\nContributor (“Commercial Contributor”) hereby agrees to defend and indemnify\r\nevery other Contributor (“Indemnified Contributor”) against any losses,\r\ndamages and costs (collectively “Losses”) arising from claims, lawsuits and\r\nother legal actions brought by a third party against the Indemnified\r\nContributor to the extent caused by the acts or omissions of such Commercial\r\nContributor in connection with its distribution of the Program in a commercial\r\nproduct offering. The obligations in this section do not apply to any claims\r\nor Losses relating to any actual or alleged intellectual property\r\ninfringement. In order to qualify, an Indemnified Contributor must: a)\r\npromptly notify the Commercial Contributor in writing of such claim, and b)\r\nallow the Commercial Contributor to control, and cooperate with the Commercial\r\nContributor in, the defense and any related settlement negotiations. The\r\nIndemnified Contributor may participate in any such claim at its own expense.\r\n\r\nFor example, a Contributor might include the Program in a commercial product\r\noffering, Product X. That Contributor is then a Commercial Contributor. If\r\nthat Commercial Contributor then makes performance claims, or offers\r\nwarranties related to Product X, those performance claims and warranties are\r\nsuch Commercial Contributor's responsibility alone. Under this section, the\r\nCommercial Contributor would have to defend claims against the other\r\nContributors related to those performance claims and warranties, and if a\r\ncourt requires any other Contributor to pay any damages as a result, the\r\nCommercial Contributor must pay those damages.\r\n\r\n5. NO WARRANTY\r\n\r\nEXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED\r\nBY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN “AS IS” BASIS, WITHOUT\r\nWARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED INCLUDING,\r\nWITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF TITLE, NON-INFRINGEMENT,\r\nMERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE. Each Recipient is solely\r\nresponsible for determining the appropriateness of using and distributing the\r\nProgram and assumes all risks associated with its exercise of rights under\r\nthis Agreement, including but not limited to the risks and costs of program\r\nerrors, compliance with applicable laws, damage to or loss of data, programs\r\nor equipment, and unavailability or interruption of operations.\r\n\r\n6. DISCLAIMER OF LIABILITY\r\n\r\nEXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT PERMITTED\r\nBY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS SHALL HAVE ANY\r\nLIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR\r\nCONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST PROFITS), HOWEVER\r\nCAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r\nOR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r\nOR DISTRIBUTION OF THE PROGRAM OR THE EXERCISE OF ANY RIGHTS GRANTED\r\nHEREUNDER, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.\r\n\r\n7. GENERAL\r\n\r\nIf any provision of this Agreement is invalid or unenforceable under\r\napplicable law, it shall not affect the validity or enforceability of the\r\nremainder of the terms of this Agreement, and without further action by the\r\nparties hereto, such provision shall be reformed to the minimum extent\r\nnecessary to make such provision valid and enforceable.\r\n\r\nIf Recipient institutes patent litigation against any entity (including a\r\ncross-claim or counterclaim in a lawsuit) alleging that the Program itself\r\n(excluding combinations of the Program with other software or hardware)\r\ninfringes such Recipient's patent(s), then such Recipient's rights granted\r\nunder Section 2(b) shall terminate as of the date such litigation is filed.\r\n\r\nAll Recipient's rights under this Agreement shall terminate if it fails to\r\ncomply with any of the material terms or conditions of this Agreement and does\r\nnot cure such failure in a reasonable period of time after becoming aware of\r\nsuch noncompliance. If all Recipient's rights under this Agreement terminate,\r\nRecipient agrees to cease use and distribution of the Program as soon as\r\nreasonably practicable. However, Recipient's obligations under this Agreement\r\nand any licenses granted by Recipient relating to the Program shall continue\r\nand survive.\r\n\r\nEveryone is permitted to copy and distribute copies of this Agreement, but in\r\norder to avoid inconsistency the Agreement is copyrighted and may only be\r\nmodified in the following manner. The Agreement Steward reserves the right to\r\npublish new versions (including revisions) of this Agreement from time to\r\ntime. No one other than the Agreement Steward has the right to modify this\r\nAgreement. The Eclipse Foundation is the initial Agreement Steward. The\r\nEclipse Foundation may assign the responsibility to serve as the Agreement\r\nSteward to a suitable separate entity. Each new version of the Agreement will\r\nbe given a distinguishing version number. The Program (including\r\nContributions) may always be Distributed subject to the version of the\r\nAgreement under which it was received. In addition, after a new version of the\r\nAgreement is published, Contributor may elect to Distribute the Program\r\n(including its Contributions) under the new version.\r\n\r\nExcept as expressly stated in Sections 2(a) and 2(b) above, Recipient receives\r\nno rights or licenses to the intellectual property of any Contributor under\r\nthis Agreement, whether expressly, by implication, estoppel or otherwise. All\r\nrights in the Program not expressly granted under this Agreement are reserved.\r\nNothing in this Agreement is intended to be enforceable by any entity that is\r\nnot a Contributor or Recipient. No third-party beneficiary rights are created\r\nunder this Agreement.\r\n\r\n"
},
{
"path": "MANIFEST.in",
"content": "include README.rst\ninclude AUTHORS\ninclude LICENSE\ninclude cylp/VERSION\nrecursive-include cylp/cpp *.hpp *.h *.cpp\n"
},
{
"path": "README.rst",
"content": "CyLP\n====\n\nCyLP is a Python interface to COIN-OR’s Linear and mixed-integer program solvers\n(CLP, CBC, and CGL). CyLP’s unique feature is that you can use it to alter the\nsolution process of the solvers from within Python. For example, you may\ndefine cut generators, branch-and-bound strategies, and primal/dual Simplex\npivot rules completely in Python.\n\nYou may read your LP from an mps file or use the CyLP’s easy modeling\nfacility. Please find examples in the `documentation\n`_.\n\nDocker\n======\n\nIf you're comfortable with Docker, you can get started right away with the container \navailable on Dockerhub that comes with CyLP pre-installed. \n\nhttps://hub.docker.com/repository/docker/coinor/cylp\n\nOtherwise, read on. \n\nPrerequisites and installation\n==============================\n\nOn Windows: Installation as a binary wheel\n------------------------------------------\n\nOn Windows, a binary wheel is available and it is not necessary to install Cbc.\nJust do::\n\n $ python -m pip install cylp\n\nOn Linux/macOS: Installation as a binary wheel\n---------------------------------------------------------\n\nBinary wheels are available for Linux and some versions of OS X \nfor some versions of Python. To see if there is a wheel available\nfor your platform, you can browse \n\nhttps://pypi.org/project/cylp/#files\n\nor just try::\n\n $ python -m pip install cylp\n\nIn case this fails, it is most likely that there is no wheel for your platform.\nIn particular, there are no wheels for MacOS running on Apple Silicon. \nIf you are on Linux, this can probably be addressed by switching to \na supported Python version with, e.g., conda::\n\n $ conda create -n cylp python=3.9\n $ conda activate cylp\n \nIf all else fails, it is easy to install from source, but Cbc must be \ninstalled first, as detailed below. The easiest route for this is to use\nconda.\n\nOn Linux/macOS with conda: Installation from source\n---------------------------------------------------\n\nTo install from source, you will need to install binaries for Cbc or also build Cbc from source. \nThe version should be 2.10 (recommended) or earlier \n(current master branch of Cbc will not work with this version of CyLP).\n\nThe following commands will create and activate a new conda environment with all\nthese prerequisites installed::\n\n $ conda create -n cylp coin-or-cbc cython numpy pkg-config scipy -c conda-forge\n $ conda activate cylp\n\nNow you can install CyLP from PyPI::\n\n $ pip install --no-build-isolation cylp\n\n(The option `--no-build-isolation` ensures that `cylp` uses the Python packages\ninstalled by conda in the build phase.)\n\nAlternatively, if you have cloned CyLP from GitHub::\n\n $ pip install --no-build-isolation .\n\nOn Linux/macOS with pip: Installation from source\n-------------------------------------------------\n\nYou will need to install binaries for Cbc. The version should be 2.10 (recommended) or earlier \n(current master branch of Cbc will not work with this version of CyLP).\nYou can install Cbc by either by installing with your system's package manager, by downloading pre-built binaries,\nor by building yourself from source using `coinbrew `_.\n\n1. To install Cbc in Linux, the easiest way is to use a package manager. Install\n `coinor-libcbc-dev` on Ubuntu/Debian or `coin-or-Cbc-devel` on Fedora, or the\n `corresponding package on your distribution\n `_.\n\n#. On macOS, it is easiest to install Cbc with homebrew:\n \n ``$ brew install cbc pkg-config``\n\nYou should no longer need to build Cbc from source on any platform unless for some reason, none of the\nabove recipes applies to you. If you do need to build from source, please go to the `Cbc `_\nproject page and follow the instructions there. After building and installing, make sure to \neither set the `COIN_INSTALL_DIR` variable to point to the installation or set `PKG_CONFIG_PATH` to point to\nthe directory where the `.pc` files are installed. You may also need to set either `LD_LIBRARY_PATH` (Linux)\nor `DYLD_LIBRARY_PATH` (macOS).\n\nNext, build and install CyLP::\n\n $ python -m pip install cylp\n\nThis will build CyLP install the runtime dependencies (`install-requires`),\nNumPy and `SciPy ` and build and install CyLP.\n\nTesting your installation\n=========================\n\nOptional step:\n If you want to run the doctests (i.e. ``make doctest`` in the ``doc`` directory)\n you should also define::\n\n $ export CYLP_SOURCE_DIR=/Path/to/cylp\n\nNow you can use CyLP in your python code. For example::\n\n >>> from cylp.cy import CyClpSimplex\n >>> s = CyClpSimplex()\n >>> s.readMps('../input/netlib/adlittle.mps')\n 0\n >>> s.initialSolve()\n 'optimal'\n >>> round(s.objectiveValue, 3)\n 225494.963\n\nOr simply go to CyLP and run::\n\n $ python -m unittest discover\n\nto run all CyLP unit tests (this is currently broken).\n\nModeling Example\n================\n\nHere is an example of how to model with CyLP's modeling facility::\n\n import numpy as np\n from cylp.cy import CyClpSimplex\n from cylp.py.modeling.CyLPModel import CyLPArray\n\n s = CyClpSimplex()\n\n # Add variables\n x = s.addVariable('x', 3)\n y = s.addVariable('y', 2)\n\n # Create coefficients and bounds\n A = np.matrix([[1., 2., 0],[1., 0, 1.]])\n B = np.matrix([[1., 0, 0], [0, 0, 1.]])\n D = np.matrix([[1., 2.],[0, 1]])\n a = CyLPArray([5, 2.5])\n b = CyLPArray([4.2, 3])\n x_u= CyLPArray([2., 3.5])\n\n # Add constraints\n s += A * x <= a\n s += 2 <= B * x + D * y <= b\n s += y >= 0\n s += 1.1 <= x[1:3] <= x_u\n\n # Set the objective function\n c = CyLPArray([1., -2., 3.])\n s.objective = c * x + 2 * y.sum()\n\n # Solve using primal Simplex\n s.primal()\n print(s.primalVariableSolution['x'])\n\nThis is the expected output::\n\n Clp0006I 0 Obj 1.1 Primal inf 2.8999998 (2) Dual inf 5.01e+10 (5) w.o. free dual inf (4)\n Clp0006I 5 Obj 1.3\n Clp0000I Optimal - objective value 1.3\n [ 0.2 2. 1.1]\n\nDocumentation\n=============\n\nYou may access CyLP's documentation:\n\n1. *Online* : Please visit http://coin-or.github.io/CyLP/\n\n2. *Offline* : To install CyLP's documentation in your repository, you need\n Sphinx (https://www.sphinx-doc.org/). You can generate the documentation by\n going to cylp/doc and run ``make html`` or ``make latex`` and access the\n documentation under cylp/doc/build. You can also run ``make doctest`` to\n perform all the doctest.\n \nWho uses CyLP\n=============\n\nThe following software packages make use of CyLP:\n\n#. `CVXPY `_, a Python-embedded modeling language for\n convex optimization problems, uses CyLP for interfacing to CBC, which is one\n of the `supported mixed-integer solvers\n `_.\n\nCyLP has been used in a wide range of practical and research fields. Some of the users include:\n\n#. `PyArt `_, The Python ARM Radar Toolkit,\n used by Atmospheric Radiation Measurement (U.S. Department of energy).\n#. Meteorological Institute University of Bonn.\n#. Sherbrooke university hospital (Centre hospitalier universitaire de Sherbrooke): CyLP is used for nurse scheduling.\n#. Maisonneuve-Rosemont hospital (L'hôpital HMR): CyLP is used for physician scheduling with preferences.\n#. Lehigh University: CyLP is used to teach mixed-integer cuts.\n#. IBM T. J. Watson research center\n#. Saarland University, Germany\n\n\n"
},
{
"path": "cylp/VERSION",
"content": "0.93.0\n"
},
{
"path": "cylp/__init__.py",
"content": "import os\nfrom os.path import realpath, join\ncurrentDir = os.path.dirname(realpath(__file__))\nwith open(join(currentDir, 'VERSION')) as f:\n __version__ = f.read().strip()\n"
},
{
"path": "cylp/cpp/.gitignore",
"content": "back/\n"
},
{
"path": "cylp/cpp/CbcCompareUser.cpp",
"content": "// Copyright (C) 2004, International Business Machines\n// Corporation and others. All Rights Reserved.\n#if defined(_MSC_VER)\n// Turn off compiler warning about long names\n# pragma warning(disable:4786)\n#endif\n#include \n#include \n#include \n//#define CBC_DEBUG\n\n#include \"CbcMessage.hpp\"\n#include \"CbcModel.hpp\"\n#include \"CbcTree.hpp\"\n#include \"CbcCompareUser.hpp\"\n#include \"CoinError.hpp\"\n#include \"CoinHelperFunctions.hpp\"\n\n/** Default Constructor\n\n*/\nCbcCompareUser::CbcCompareUser(PyObject* obj, runTest_t runTest,\n runNewSolution_t runNewSolution,\n runEvery1000Nodes_t runEvery1000Nodes)\n : CbcCompareBase(),\n weight_(-1.0),\n saveWeight_(0.0),\n numberSolutions_(0),\n count_(0),\n treeSize_(0),\n obj(obj),\n runTest(runTest),\n runNewSolution(runNewSolution),\n runEvery1000Nodes(runEvery1000Nodes)\n{\n test_=this;\n}\n\n// Constructor with weight\n//CbcCompareUser::CbcCompareUser (double weight) \n// : CbcCompareBase(),\n// weight_(weight) ,\n// saveWeight_(0.0),\n// numberSolutions_(0),\n// count_(0),\n// treeSize_(0)\n//{\n// test_=this;\n//}\n\n\n// Copy constructor \nCbcCompareUser::CbcCompareUser ( const CbcCompareUser & rhs)\n :CbcCompareBase(rhs)\n\n{\n weight_=rhs.weight_;\n saveWeight_ = rhs.saveWeight_;\n numberSolutions_=rhs.numberSolutions_;\n count_ = rhs.count_;\n treeSize_ = rhs.treeSize_;\n runTest = rhs.runTest;\n runNewSolution = rhs.runNewSolution;\n runEvery1000Nodes = rhs.runEvery1000Nodes;\n obj = rhs.obj;\n}\n\n// Clone\nCbcCompareBase *\nCbcCompareUser::clone() const\n{\n return new CbcCompareUser(*this);\n}\n\n// Assignment operator \nCbcCompareUser & \nCbcCompareUser::operator=( const CbcCompareUser& rhs)\n{\n\n if (this!=&rhs) {\n CbcCompareBase::operator=(rhs);\n weight_=rhs.weight_;\n saveWeight_ = rhs.saveWeight_;\n numberSolutions_=rhs.numberSolutions_;\n count_ = rhs.count_;\n treeSize_ = rhs.treeSize_;\n\n runTest = rhs.runTest;\n runNewSolution = rhs.runNewSolution;\n runEvery1000Nodes = rhs.runEvery1000Nodes;\n obj = rhs.obj;\n }\n return *this;\n}\n\n// Destructor \nCbcCompareUser::~CbcCompareUser ()\n{\n}\n\n// Returns true if y better than x\nbool \nCbcCompareUser::test (CbcNode * x, CbcNode * y)\n{\n return this->runTest(this->obj, (ICbcNode*) x,(ICbcNode*) y);\n}\n// This allows method to change behavior as it is called\n// after each solution\nbool \nCbcCompareUser::newSolution(CbcModel * model,\n\t\t\t double objectiveAtContinuous,\n\t\t\t int numberInfeasibilitiesAtContinuous) \n{\n return this->runNewSolution(this->obj, (ICbcModel*)model, \n objectiveAtContinuous,\n numberInfeasibilitiesAtContinuous);\n}\n// This allows method to change behavior \nbool \nCbcCompareUser::every1000Nodes(CbcModel * model, int numberNodes)\n{\n return this->runEvery1000Nodes(this->obj, \n (ICbcModel*)model, \n numberNodes);\n}\n// Returns true if wants code to do scan with alternate criterion\nbool \nCbcCompareUser::fullScan() const\n{\n return false;\n}\n// This is alternate test function\nbool \nCbcCompareUser::alternateTest (CbcNode * x, CbcNode * y)\n{\n // not used\n abort();\n return false;\n}\n"
},
{
"path": "cylp/cpp/CbcCompareUser.hpp",
"content": "// Copyright (C) 2002, International Business Machines\n// Corporation and others. All Rights Reserved.\n#ifndef CbcCompareUser_H\n#define CbcCompareUser_H\n\n//#define NPY_NO_DEPRECATED_API\n\n#include \"CbcNode.hpp\"\n#include \"CbcCompareBase.hpp\"\n#include \"ICbcModel.hpp\"\n#include \"ICbcNode.hpp\"\n#include \"Python.h\"\n#include \n\n//class ICbcModel;\n\n\n\n/* This is an example of a more complex rule with data\n It is default after first solution\n If weight is 0.0 then it is computed to hit first solution\n less 2%\n*/\nclass CbcCompareUser : public CbcCompareBase {\npublic:\n // Default Constructor\n CbcCompareUser (PyObject* obj, runTest_t runTest,\n runNewSolution_t runNewSolution,\n runEvery1000Nodes_t runEvery1000Nodes) ;\n // Constructor with weight\n //CbcCompareUser (double weight);\n\n // Copy constructor\n CbcCompareUser ( const CbcCompareUser &rhs);\n\n // Assignment operator\n CbcCompareUser & operator=( const CbcCompareUser& rhs);\n\n /// Clone\n virtual CbcCompareBase * clone() const;\n\n ~CbcCompareUser() ;\n /* This returns true if weighted value of node y is less than\n weighted value of node x */\n // Returns true if y better than x\n virtual bool test (CbcNode * x, CbcNode * y) ;\n /// This is alternate test function\n virtual bool alternateTest (CbcNode * x, CbcNode * y);\n // This allows method to change behavior as it is called\n // after each solution\n virtual bool newSolution(CbcModel * model,\n\t\t\t double objectiveAtContinuous,\n\t\t\t int numberInfeasibilitiesAtContinuous) ;\n /// Returns true if wants code to do scan with alternate criterion\n virtual bool fullScan() const;\n // This allows method to change behavior\n // Return true if want tree re-sorted\n virtual bool every1000Nodes(CbcModel * model,int numberNodes);\n\n /* if weight == -1.0 then depth first (before solution)\n if -2.0 then do breadth first just for first 1000 nodes\n */\n inline double getWeight() const\n { return weight_;}\n inline void setWeight(double weight)\n { weight_ = weight;}\nprotected:\n // Weight for each infeasibility\n double weight_;\n // Weight for each infeasibility - computed from solution\n double saveWeight_;\n // Number of solutions\n int numberSolutions_;\n // count\n mutable int count_;\n // Tree size (at last check)\n int treeSize_;\n runTest_t runTest;\n runEvery1000Nodes_t runEvery1000Nodes;\n runNewSolution_t runNewSolution;\n PyObject* obj;\n};\n#endif\n"
},
{
"path": "cylp/cpp/CyClpSimplex_api.h",
"content": "#ifndef __PYX_HAVE_API__CyClpSimplex\n#define __PYX_HAVE_API__CyClpSimplex\n#include \"Python.h\"\n\nstatic void (*__pyx_f_12CyClpSimplex_CyPostPrimalRow)(IClpSimplex *) = 0;\n#define CyPostPrimalRow __pyx_f_12CyClpSimplex_CyPostPrimalRow\nstatic int (*__pyx_f_12CyClpSimplex_CyPivotIsAcceptable)(IClpSimplex *) = 0;\n#define CyPivotIsAcceptable __pyx_f_12CyClpSimplex_CyPivotIsAcceptable\n\n#ifndef __PYX_HAVE_RT_ImportModule\n#define __PYX_HAVE_RT_ImportModule\nstatic PyObject *__Pyx_ImportModule(const char *name) {\n PyObject *py_name = 0;\n PyObject *py_module = 0;\n\n py_name = PyUnicode_FromString(name);\n if (!py_name)\n goto bad;\n py_module = PyImport_Import(py_name);\n Py_DECREF(py_name);\n return py_module;\nbad:\n Py_XDECREF(py_name);\n return 0;\n}\n#endif\n\n#ifndef __PYX_HAVE_RT_ImportFunction\n#define __PYX_HAVE_RT_ImportFunction\nstatic int __Pyx_ImportFunction(PyObject *module, const char *funcname, void (**f)(void), const char *sig) {\n PyObject *d = 0;\n PyObject *cobj = 0;\n union {\n void (*fp)(void);\n void *p;\n } tmp;\n\n d = PyObject_GetAttrString(module, (char *)\"__pyx_capi__\");\n if (!d)\n goto bad;\n cobj = PyDict_GetItemString(d, funcname);\n if (!cobj) {\n PyErr_Format(PyExc_ImportError,\n \"%s does not export expected C function %s\",\n PyModule_GetName(module), funcname);\n goto bad;\n }\n if (!PyCapsule_IsValid(cobj, sig)) {\n PyErr_Format(PyExc_TypeError,\n \"C function %s.%s has wrong signature (expected %s, got %s)\",\n PyModule_GetName(module), funcname, sig, PyCapsule_GetName(cobj));\n goto bad;\n }\n tmp.p = PyCapsule_GetPointer(cobj, sig);\n *f = tmp.fp;\n if (!(*f))\n goto bad;\n Py_DECREF(d);\n return 0;\nbad:\n Py_XDECREF(d);\n return -1;\n}\n#endif\n\nstatic int import_CyClpSimplex(void) {\n PyObject *module = 0;\n module = __Pyx_ImportModule(\"CyClpSimplex\");\n if (!module) goto bad;\n if (__Pyx_ImportFunction(module, \"CyPostPrimalRow\", (void (**)(void))&__pyx_f_12CyClpSimplex_CyPostPrimalRow, \"void (IClpSimplex *)\") < 0) goto bad;\n if (__Pyx_ImportFunction(module, \"CyPivotIsAcceptable\", (void (**)(void))&__pyx_f_12CyClpSimplex_CyPivotIsAcceptable, \"int (IClpSimplex *)\") < 0) goto bad;\n Py_DECREF(module); module = 0;\n return 0;\n bad:\n Py_XDECREF(module);\n return -1;\n}\n\n#endif /* !__PYX_HAVE_API__CyClpSimplex */\n"
},
{
"path": "cylp/cpp/ICbc.cpp",
"content": "#include \"ICbc.hpp\"\n\nICbcModel* CbcSolveMIP(IClpSimplex* clpModel, PyObject* obj, \n runTest_t runTest, runNewSolution_t runNewSolution,\n runEvery1000Nodes_t runEvery1000Nodes){\n OsiClpSolverInterface solver1(clpModel);\n solver1.initialSolve();\n ICbcModel* model = new ICbcModel(solver1);\n CbcCompareUser compare(obj, \n runTest, \n runNewSolution, \n runEvery1000Nodes);\n model->setNodeComparison(compare);\n model->branchAndBound();\n return model;\n}\n\nICbcModel* CbcSolveMIP(IClpSimplex* clpModel){\n OsiClpSolverInterface solver1(clpModel);\n solver1.initialSolve();\n ICbcModel* model = new ICbcModel(solver1);\n model->branchAndBound();\n return model;\n}\n\n"
},
{
"path": "cylp/cpp/ICbc.hpp",
"content": "//#define NPY_NO_DEPRECATED_API\n\n#include \"CbcConfig.h\"\n\n// For Branch and bound\n#include \"OsiSolverInterface.hpp\"\n#include \"ICbcModel.hpp\"\n\n#include \"OsiClpSolverInterface.hpp\"\n#include \"ClpPresolve.hpp\"\n//#include \"CbcCompareUser.hpp\"\n#include \"CglProbing.hpp\"\n#include \"IClpSimplex.hpp\"\n#include \"CbcCompareUser.hpp\"\n\nICbcModel* CbcSolveMIP(IClpSimplex* model,\n PyObject* obj,\n runTest_t runTest,\n runNewSolution_t runNewSolution,\n runEvery1000Nodes_t runEvery1000Nodes);\n\nICbcModel* CbcSolveMIP(IClpSimplex* model);\n\n"
},
{
"path": "cylp/cpp/ICbcModel.cpp",
"content": "#include \"ICbcModel.hpp\"\n\n#include \"CbcCompareUser.hpp\"\n#include \"CbcSolver.hpp\"\n\nPyObject* ICbcModel::getPrimalVariableSolution(){\n\n _import_array();\n npy_intp dims = this->solver()->getNumCols();\n double* d = (double*)(this->solver()->getColSolution());\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_DOUBLE, d );\n\n return Arr;\n}\n\nICbcModel::ICbcModel(OsiClpSolverInterface& osiint):CbcModel(osiint){\n _import_array();\n}\n\nvoid ICbcModel::setNodeCompare(PyObject* obj,\n runTest_t runTest, runNewSolution_t runNewSolution,\n runEvery1000Nodes_t runEvery1000Nodes){\n CbcCompareUser compare(obj, runTest,\n runNewSolution,runEvery1000Nodes);\n setNodeComparison(compare);\n\n}\n\n\nint ICbcModel::cbcMain(){\n // initialize\n int returnCode = -1;\n\tint logLevel = this->logLevel();\n const char* argv[] = {\"ICbcModel\", \"-solve\",\"-quit\"};\n CbcMain0(*this);\n\tthis->setLogLevel(logLevel);\n return CbcMain1(3, argv, *this);\n //const char* argv = \"-solve -quit\";\n //CbcSolverUsefulData solverData;\n //CbcMain0(*this, solverData);\n\t//this->setLogLevel(logLevel);\n //return CbcMain1(3, argv, *this, NULL, solverData);\n}\n"
},
{
"path": "cylp/cpp/ICbcModel.hpp",
"content": "#ifndef ICbcModel_H\n#define ICbcModel_H\n\n//#define NPY_NO_DEPRECATED_API\n\n//#include \"ClpModel.hpp\"\n#include \"ClpPackedMatrix.hpp\"\n#include \"Python.h\"\n#include \n#include \"CoinFinite.hpp\"\n#include \"CoinPragma.hpp\"\n#include \"CbcModel.hpp\"\n#include \"Python.h\"\n#include \n#include \"OsiClpSolverInterface.hpp\"\n#include \"ICbcNode.hpp\"\n//#include \"CbcSolver.hpp\"\n//#include \"CbcCompareUser.hpp\"\n\nclass ICbcModel;\ntypedef int (*runTest_t)(void *instance, ICbcNode * x, ICbcNode * y);\ntypedef bool (*runNewSolution_t)(void *instance,ICbcModel * model,\n double objectiveAtContinuous,\n int numberInfeasibilitiesAtContinuous);\ntypedef int (*runEvery1000Nodes_t)(void *instance,\n ICbcModel * model,int numberNodes);\n\n\n\nclass ICbcModel : public CbcModel{\npublic:\n ICbcModel(OsiClpSolverInterface&);\n PyObject * getPrimalVariableSolution();\n\n void setNodeCompare(PyObject* obj,\n runTest_t runTest, runNewSolution_t runNewSolution,\n runEvery1000Nodes_t runEvery1000Nodes);\n int cbcMain();\n};\n\n\n#endif\n"
},
{
"path": "cylp/cpp/ICbcNode.cpp",
"content": "#include \"ICbcNode.hpp\"\n\nbool ICbcNode::breakTie(ICbcNode* y){\n ICbcNode* x = this;\n assert (x);\n assert (y);\n return (x->nodeNumber()>y->nodeNumber());\n}\n"
},
{
"path": "cylp/cpp/ICbcNode.hpp",
"content": "#ifndef ICbcNode_H\n#define ICbcNode_H\n\n//#define NPY_NO_DEPRECATED_API\n\n//#include \"ClpModel.hpp\"\n#include \"ClpPackedMatrix.hpp\"\n#include \"Python.h\"\n#include \n#include \"CoinFinite.hpp\"\n#include \"CoinPragma.hpp\"\n#include \"CbcNode.hpp\"\n#include \"Python.h\"\n#include \n//#include \"OsiClpSolverInterface.hpp\"\n\nclass ICbcNode : public CbcNode{\npublic:\n bool breakTie(ICbcNode* y);\n};\n\n\n#endif\n"
},
{
"path": "cylp/cpp/ICglCutGeneratorBase.cpp",
"content": "#include \"ICglCutGeneratorBase.h\"\n\nvoid\nCppCglCutGeneratorBase::generateCuts(const OsiSolverInterface & si, OsiCuts & cs,\n const CglTreeInfo info)\n{\n\t//std::cout << \"::Cy..Base::generateCuts()...\\n\";\n if (this->obj && this->runGenerateCuts) {\n \tthis->runGenerateCuts(this->obj, &si, &cs, info);\n return;\n\t}\n\tstd::cout << \"** generateCuts: invalid cy-state: obj [\" << this->obj << \"] fct: [\"\n\t << this->runGenerateCuts << \"]\\n\";\n}\n\nCglCutGenerator * CppCglCutGeneratorBase::clone() const {\n\t//std::cout << \"::Cy..Base::clone()...\\n\";\n\tif (this->obj && this->runCglClone) {\n\t\treturn this->runCglClone(this->obj);\n\t}\n\tstd::cerr << \"** clone: invalid cy-state: obj [\" << this->obj << \"] fct: [\"\n\t << this->runCglClone << \"]\\n\";\n\treturn NULL;\n}\n\n\nCppCglCutGeneratorBase::CppCglCutGeneratorBase(PyObject *obj, runGenerateCuts_t runGenerateCuts,\n\t\t\t\t\t\t\t\t\t\t\t\t\t runCglClone_t runCglClone) :\n obj(obj),\n\trunCglClone(runCglClone),\n runGenerateCuts(runGenerateCuts)\n{\n}\n\nCppCglCutGeneratorBase::~CppCglCutGeneratorBase()\n{\n}\n\n\nCppCglCutGeneratorBase::CppCglCutGeneratorBase(const CglCutGenerator & source):\n CglCutGenerator(source),\n obj(obj),\n runCglClone(runCglClone),\n runGenerateCuts(runGenerateCuts)\n{\n}\n\n\nCppCglCutGeneratorBase::CppCglCutGeneratorBase():\n CglCutGenerator(),\n obj(obj),\n runCglClone(runCglClone),\n runGenerateCuts(runGenerateCuts)\n{\n}\n\n"
},
{
"path": "cylp/cpp/ICglCutGeneratorBase.h",
"content": "#include \"Python.h\"\n#include \nusing namespace std;\n\n#include \"CglCutGenerator.hpp\"\n//#include \"CoinIndexedVector.hpp\"\n//#include \"IClpSimplex.hpp\"\n//#include \"ClpSimplex.hpp\"\n//#include \"ClpFactorization.hpp\"\n#include \"OsiSolverInterface.hpp\"\n\ntypedef CglCutGenerator* (*runCglClone_t)(void *instance);\n\ntypedef void (*runGenerateCuts_t)(void *instance,\n const OsiSolverInterface *si, OsiCuts *cs, const CglTreeInfo info);\n\n\nclass CppCglCutGeneratorBase : public CglCutGenerator\n{\npublic:\n \tPyObject *obj;\n\trunCglClone_t runCglClone;\n\trunGenerateCuts_t runGenerateCuts;\n\n\n\t//IClpSimplex model_;\n\n \tCppCglCutGeneratorBase(PyObject *obj, runGenerateCuts_t ,\n\t\t\t\t\t\t\t runCglClone_t );\n \tvirtual ~CppCglCutGeneratorBase();\n CppCglCutGeneratorBase(const CglCutGenerator & source);\n CppCglCutGeneratorBase();\n\n\tvirtual CglCutGenerator * clone() const;\n\n virtual void generateCuts(const OsiSolverInterface & si, OsiCuts & cs,\n const CglTreeInfo info = CglTreeInfo());\n\n\n};\n\n\n"
},
{
"path": "cylp/cpp/IClpDualRowPivotBase.cpp",
"content": "#include \"IClpDualRowPivotBase.h\"\n#include \"ICoinIndexedVector.hpp\"\n\nint\nCppClpDualRowPivotBase::pivotRow()\n{\n //std::cout << \"::Cy..Base::pivotRow()...\\n\";\n if (this->obj && this->runPivotRow) {\n return this->runPivotRow(this->obj);\n }\n std::cerr << \"** pivotRow: invalid cy-state: obj [\" << this->obj << \"] fct: [\"\n << this->runPivotRow << \"]\\n\";\n return -100;\n}\n\nClpDualRowPivot * CppClpDualRowPivotBase::clone(bool copyData) const {\n //std::cout << \"::Cy..Base::clone()...\\n\";\n if (this->obj && this->runDualPivotClone) {\n return this->runDualPivotClone(this->obj,copyData);\n }\n std::cerr << \"** clone: invalid cy-state: obj [\" << this->obj << \"] fct: [\"\n << this->runDualPivotClone << \"]\\n\";\n return NULL;\n}\n\ndouble CppClpDualRowPivotBase::updateWeights(CoinIndexedVector * input,\n CoinIndexedVector * spare,\n CoinIndexedVector * spare2,\n CoinIndexedVector * updatedColumn) {\n if (this->obj && this->runUpdateWeights) {\n return this->runUpdateWeights(this->obj, input, spare, spare2, updatedColumn);\n }\n std::cerr << \"** clone: invalid cy-state: obj [\" << this->obj << \"] fct: [\"\n << this->runUpdateWeights << \"]\\n\";\n return -1;\n}\n\nvoid CppClpDualRowPivotBase::updatePrimalSolution(\n CoinIndexedVector * primalUpdate,\n double primalRatio,\n double & objectiveChange){\n if (this->obj && this->runUpdatePrimalSolution) {\n return this->runUpdatePrimalSolution(this->obj, primalUpdate,\n primalRatio, &objectiveChange);\n }\n std::cerr << \"** clone: invalid cy-state: obj [\" << this->obj << \"] fct: [\"\n << this->runUpdatePrimalSolution << \"]\\n\";\n return;\n\n}\n\n\nCppClpDualRowPivotBase::CppClpDualRowPivotBase(PyObject *obj,\n runPivotRow_t runPivotRow,\n runDualPivotClone_t runDualPivotClone,\n runUpdateWeights_t runUpdateWeights,\n runUpdatePrimalSolution_t runUpdatePrimalSolution) :\n obj(obj),\n runPivotRow(runPivotRow),\n runDualPivotClone(runDualPivotClone),\n runUpdateWeights(runUpdateWeights),\n runUpdatePrimalSolution(runUpdatePrimalSolution)\n{\n}\n\nCppClpDualRowPivotBase::~CppClpDualRowPivotBase()\n{\n}\n\nvoid CppClpDualRowPivotBase::setModel(IClpSimplex* m)\n{\n ClpSimplex* s = static_cast(m);\n model_ = s;\n}\n\nIClpSimplex* CppClpDualRowPivotBase::model()\n{\n return static_cast (model_);\n}\n\n\n\n"
},
{
"path": "cylp/cpp/IClpDualRowPivotBase.h",
"content": "#include \"Python.h\"\n#include \nusing namespace std;\n\n#include \"ClpDualRowPivot.hpp\"\n#include \"CoinIndexedVector.hpp\"\n#include \"IClpSimplex.hpp\"\n//#include \"ClpSimplex.hpp\"\n#include \"ClpFactorization.hpp\"\n\ntypedef int (*runPivotRow_t)(void *instance);\n\ntypedef ClpDualRowPivot* (*runDualPivotClone_t)(void *instance, bool copyData);\n\ntypedef double (*runUpdateWeights_t)(void *instance,\n CoinIndexedVector * input,\n CoinIndexedVector * spare,\n CoinIndexedVector * spare2,\n CoinIndexedVector * updatedColumn);\n\ntypedef void (*runUpdatePrimalSolution_t)(void *instance,\n CoinIndexedVector * input,\n double theta,\n double * changeInObjective);\n\n\n\nclass CppClpDualRowPivotBase : public ClpDualRowPivot\n{\npublic:\n \tPyObject *obj;\n \trunPivotRow_t runPivotRow;\n\trunDualPivotClone_t runDualPivotClone;\n\trunUpdateWeights_t runUpdateWeights;\n runUpdatePrimalSolution_t runUpdatePrimalSolution;\n\n\t//IClpSimplex model_;\n\n \tCppClpDualRowPivotBase(PyObject *obj, runPivotRow_t ,\n\t\t\t\t\t\t\t runDualPivotClone_t , runUpdateWeights_t, runUpdatePrimalSolution_t );\n \tvirtual ~CppClpDualRowPivotBase();\n\n\tvirtual ClpDualRowPivot * clone(bool copyData = true) const;\n\t//virtual void saveWeights(IClpSimplex * model,int mode);\n \tvirtual double updateWeights(CoinIndexedVector * input,\n CoinIndexedVector * spare,\n CoinIndexedVector * spare2,\n CoinIndexedVector * updatedColumn);\n\n \tvirtual void updatePrimalSolution(CoinIndexedVector * input,\n double theta,\n double& changeInObjective);\n\n virtual int pivotRow();\n\n\tvoid setModel(IClpSimplex* m);\n\tIClpSimplex* model();\n};\n\n\n"
},
{
"path": "cylp/cpp/IClpPackedMatrix.cpp",
"content": "#include \"IClpPackedMatrix.hpp\"\n\nvoid \nIClpPackedMatrix::transposeTimesSubsetAll( IClpSimplex* model, int number,\n const long long int * which,\n const double * COIN_RESTRICT x, double * COIN_RESTRICT y,\n const double * COIN_RESTRICT rowScale, \n const double * COIN_RESTRICT columnScale,\n double * COIN_RESTRICT spare) const\n{\n // get matrix data pointers\n const int * row = matrix_->getIndices();\n const CoinBigIndex * columnStart = matrix_->getVectorStarts();\n const double * elementByColumn = matrix_->getElements();\n if (!spare||!rowScale) {\n if (rowScale) {\n for (int jColumn=0;jColumn model->getNumCols()){\n int jRow = iColumn - model->getNumCols();\n value = x[jRow]* -1 *rowScale[jRow];\n }\n else{\n for (j=start;j model->getNumCols()){\n int jRow = iColumn - model->getNumCols();\n value = x[jRow]* -1;\n }\n else{\n for (j=start;jgetNumRows();\n for (iRow=0;iRow\n#include \"CoinFinite.hpp\"\n#include \"CoinPragma.hpp\"\n#include \"IClpSimplex.hpp\"\n\nclass IClpPackedMatrix : public ClpPackedMatrix{\npublic:\n IClpPackedMatrix();\n \n void transposeTimesSubsetAll(IClpSimplex* model, int number,\n const long long int * which,\n const double * COIN_RESTRICT x, double * y,\n const double * rowScale, \n const double * columnScale,\n double * spare) const;\n\n};\n\n\n#endif\n"
},
{
"path": "cylp/cpp/IClpPrimalColumnPivot.cpp",
"content": "#include \"IClpPrimalColumnPivot.h\"\n\nint CppClpPrimalColumnPivotBase::pivotColumn(CoinIndexedVector * updates,\n\t\t\t CoinIndexedVector * spareRow1,\n\t\t\t CoinIndexedVector * spareRow2,\n\t\t\t CoinIndexedVector * spareColumn1,\n\t\t\t CoinIndexedVector * spareColumn2)\n{\nstd::cout << \"PivotColumn should be implemented in a derived class\\n\";\nreturn -100;\n}\n\n\nCppClpPrimalColumnPivotBase::CppClpPrimalColumnPivotBase(PyObject *obj, RunFct fct) :\n obj(obj),\n fct(fct)\n{\n}\n\nCppClpPrimalColumnPivotBase::~CppClpPrimalColumnPivotBase()\n{\n}\n\nvoid CppClpPrimalColumnPivotBase::saveWeights(ClpSimplex * model,int mode)\n{\nstd::cout << \"saveWeight should be implemented in a derived class\\n\";\n}\n\nCppClpPrimalColumnPivotBase* CppClpPrimalColumnPivotBase::clone(bool copyData) const\n{\nstd::cout << \"clone should be implemented in a derived class\\n\";\nreturn 0;\n}\n\n"
},
{
"path": "cylp/cpp/IClpPrimalColumnPivot.h",
"content": "#include \"ClpPrimalColumnPivot.hpp\"\n#include \"CoinIndexedVector.hpp\"\n#include \"Python.h\"\n\n#include \n\ntypedef void (*RunFct)(void *instance);\n\nclass CppClpPrimalColumnPivotBase : public ClpPrimalColumnPivot\n{\npublic:\n PyObject *obj;\n RunFct fct;\n\n CppClpPrimalColumnPivotBase(PyObject *obj, RunFct fct);\n virtual ~CppClpPrimalColumnPivotBase();\n\nvirtual int pivotColumn(CoinIndexedVector * updates,\n\t\t\t CoinIndexedVector * spareRow1,\n\t\t\t CoinIndexedVector * spareRow2,\n\t\t\t CoinIndexedVector * spareColumn1,\n\t\t\t CoinIndexedVector * spareColumn2);\n\nvirtual void saveWeights(ClpSimplex * model,int mode);\n\nvirtual CppClpPrimalColumnPivotBase* clone(bool copyData = true) const;\n\n};\n"
},
{
"path": "cylp/cpp/IClpPrimalColumnPivotBase.cpp",
"content": "#include \"IClpPrimalColumnPivotBase.h\"\n#include \"ICoinIndexedVector.hpp\"\n\nint\nCppClpPrimalColumnPivotBase::pivotColumn(CoinIndexedVector* updates, CoinIndexedVector* spareRow1,\n\t\t\t\t\t\t\t\t CoinIndexedVector* spareRow2, CoinIndexedVector* spareColumn1,\n\t\t\t\t\t\t\t\t CoinIndexedVector* spareColumn2 )\n{\n\t//std::cout << \"::Cy..Base::pivotColumn()...\\n\";\n\tif (this->obj && this->runPivotColumn) {\n\t\treturn this->runPivotColumn(this->obj, updates, spareRow1, spareRow2, spareColumn1, spareColumn2);\n\t}\n\tstd::cerr << \"** pivotColumn: invalid cy-state: obj [\" << this->obj << \"] fct: [\"\n\t<< this->runPivotColumn << \"]\\n\";\n\treturn -100;\n}\n\nClpPrimalColumnPivot * CppClpPrimalColumnPivotBase::clone(bool copyData) const {\n\t//std::cout << \"::Cy..Base::clone()...\\n\";\n\tif (this->obj && this->runClone) {\n\t\treturn this->runClone(this->obj,copyData);\n\t}\n\tstd::cerr << \"** clone: invalid cy-state: obj [\" << this->obj << \"] fct: [\"\n\t<< this->runClone << \"]\\n\";\n\treturn NULL;\n}\n\nvoid CppClpPrimalColumnPivotBase::saveWeights(ClpSimplex * model,int mode)\n{\n\tIClpSimplex* m = static_cast(model);\n\tif (this->obj && this->runSaveWeights) {\n\t\tthis->runSaveWeights(this->obj,m, mode);\n\treturn;\n\t}\n\tstd::cerr << \"** saveWeights: invalid cy-state: obj [\" << this->obj << \"] fct: [\"\n\t<< this->runSaveWeights << \"]\\n\";\n\treturn;\n}\n\nCppClpPrimalColumnPivotBase::CppClpPrimalColumnPivotBase(PyObject *obj, runPivotColumn_t runPivotColumn,\n\t\t\t\t\t\t\t\t\t\t\t\t\t runClone_t runClone, runSaveWeights_t runSaveWeights) :\n obj(obj),\n runPivotColumn(runPivotColumn),\n\trunClone(runClone),\n\trunSaveWeights(runSaveWeights)\n{\n}\n\nCppClpPrimalColumnPivotBase::~CppClpPrimalColumnPivotBase()\n{\n}\n\nvoid CppClpPrimalColumnPivotBase::setModel(IClpSimplex* m)\n{\n\tClpSimplex* s = static_cast(m);\n\tmodel_ = s;\n}\n\nIClpSimplex* CppClpPrimalColumnPivotBase::model()\n{\n\treturn static_cast (model_);\n}\n\n"
},
{
"path": "cylp/cpp/IClpPrimalColumnPivotBase.h",
"content": "#include \"Python.h\"\n#include \nusing namespace std;\n\n#include \"ClpPrimalColumnPivot.hpp\"\n#include \"CoinIndexedVector.hpp\"\n#include \"IClpSimplex.hpp\"\n//#include \"ClpSimplex.hpp\"\n#include \"ClpFactorization.hpp\"\n\ntypedef int (*runPivotColumn_t)(void *instance, CoinIndexedVector*,CoinIndexedVector*\n\t\t\t\t\t ,CoinIndexedVector*,CoinIndexedVector*,CoinIndexedVector*);\n\ntypedef ClpPrimalColumnPivot* (*runClone_t)(void *instance, bool copyData);\n\ntypedef void (*runSaveWeights_t)(void *instance, IClpSimplex * model,int mode);\n\n\n\nclass CppClpPrimalColumnPivotBase : public ClpPrimalColumnPivot\n{\npublic:\n \tPyObject *obj;\n \trunPivotColumn_t runPivotColumn;\n\trunClone_t runClone;\n\trunSaveWeights_t runSaveWeights;\n\n\t//IClpSimplex model_;\n\n \tCppClpPrimalColumnPivotBase(PyObject *obj, runPivotColumn_t ,\n\t\t\t\t\t\t\t runClone_t , runSaveWeights_t );\n \tvirtual ~CppClpPrimalColumnPivotBase();\n\n\tvirtual ClpPrimalColumnPivot * clone(bool copyData = true) const;\n\t//virtual void saveWeights(IClpSimplex * model,int mode);\n \tvirtual void saveWeights(ClpSimplex * model,int mode);\n \tvirtual int pivotColumn(CoinIndexedVector * updates,\n\t\t\t CoinIndexedVector * spareRow1,\n\t\t\t CoinIndexedVector * spareRow2,\n\t\t\t CoinIndexedVector * spareColumn1,\n\t\t\t\t\t\t CoinIndexedVector * spareColumn2);\n\tvoid setModel(IClpSimplex* m);\n\tIClpSimplex* model();\n\n};\n\n\n"
},
{
"path": "cylp/cpp/IClpSimplex.cpp",
"content": "#include \"IClpSimplex.hpp\"\n\n#include \"ClpSimplexDual.hpp\"\n//#include \"IClpSimplexPrimal.hpp\"\n#include \"IClpSimplexPrimal.hpp\"\n#include \"ClpSimplexPrimal.hpp\"\n#include \"IClpPackedMatrix.hpp\"\n#include \"OsiClpSolverInterface.hpp\"\n#include \n#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION\n#include \n\nint IClpSimplex::argWeightedMax(PyObject* arr, PyObject* arr_ind, PyObject* w, PyObject* w_ind){\n //_import_array();\n\n npy_intp w_ind_len = PyArray_DIM(reinterpret_cast(w_ind), 0);\n if (w_ind_len == 0)\n return -1; //return PyArray_ArgMax(reinterpret_cast(arr));\n\n int wIsNum = false;\n int wholeArray = false;\n\n double w_num_val;\n if (PyLong_Check(w)){\n wIsNum = true;\n w_num_val = PyLong_AsDouble(w);\n }else if (PyFloat_Check(w)){\n wIsNum = true;\n w_num_val = PyFloat_AsDouble(w);\n }else if (!PyArray_Check(w)){\n PyErr_SetString(PyExc_ValueError,\n \"weights should be a number or a numpy array.\");\n return -1;\n }\n\n\n if (PyLong_Check(arr_ind) || PyFloat_Check(arr_ind)){\n wholeArray = true;\n }else if (!PyArray_Check(arr_ind)){\n PyErr_SetString(PyExc_ValueError,\n \"arr_ind should be a number(meaning 1..len(arr) or a numpy array.\");\n return -1;\n }\n if (!PyArray_Check(arr) || !PyArray_Check(w_ind)){\n PyErr_SetString(PyExc_ValueError,\n \"arr and w_ind should be numpy arrays.\");\n return -1;\n }\n\n\n PyObject* arr_it = PyArray_IterNew(arr);\n\n npy_intp arr_len = PyArray_DIM(reinterpret_cast(arr), 0);\n\n if (arr_len == 0)\n return 0;\n\n\n double maxVal;// = *(double*)PyArray_ITER_DATA(arr_it);\n int maxInd;// = 0;\n double curVal;\n double curInd;\n //int w_ind_val;\n //double w_val;\n\n\n\n //consider 4 cases:\n //1- whole array, weight is a single number\n //2- whole array, weights array\n //3- arr_ind, weights number\n //4- arr_ind, weights array\n if (wholeArray){\n maxVal = *(double*)PyArray_ITER_DATA(arr_it);\n maxInd = 0;\n PyObject* w_ind_it= PyArray_IterNew(w_ind);\n int w_ind_val = *(int*)PyArray_ITER_DATA(w_ind_it);\n\n if (wIsNum){\n if (w_ind_val == 0){\n maxVal *= w_num_val;\n PyArray_ITER_NEXT(w_ind_it);\n w_ind_val = *(int*)PyArray_ITER_DATA(w_ind_it);\n }\n PyArray_ITER_NEXT(arr_it);\n\n for (int i = 1 ; i < arr_len ; i++){\n curVal = *(double*)PyArray_ITER_DATA(arr_it);\n if (w_ind_val == i){\n curVal *= w_num_val;\n PyArray_ITER_NEXT(w_ind_it);\n w_ind_val = *(int*)PyArray_ITER_DATA(w_ind_it);\n }\n if (curVal > maxVal){\n maxVal = curVal;\n maxInd = i;\n }\n\n PyArray_ITER_NEXT(arr_it);\n }\n }\n else{ //look in whole array, weights array\n npy_intp w_len = PyArray_DIM(reinterpret_cast(w), 0);\n npy_intp w_ind_len = PyArray_DIM(reinterpret_cast(w_ind), 0);\n if (w_ind_len != w_len){\n PyErr_SetString(PyExc_ValueError,\n \"If w is a numpy array, w_ind should be a numpy array of the same size.\");\n return -1;\n }\n\n PyObject* w_it= PyArray_IterNew(w);\n double w_val = *(double*)PyArray_ITER_DATA(w_it);\n if (w_ind_val == 0){\n maxVal *= w_val; //*(double *)PyArray_GETITEM(w, PyArray_GETPTR1(w, 0));\n PyArray_ITER_NEXT(w_ind_it);\n PyArray_ITER_NEXT(w_it);\n w_ind_val = *(int*)PyArray_ITER_DATA(w_ind_it);\n w_val = *(double*)PyArray_ITER_DATA(w_it);\n }\n\n PyArray_ITER_NEXT(arr_it);\n\n for (int i = 1 ; i < arr_len ; i++){\n curVal = *(double*)PyArray_ITER_DATA(arr_it);\n if (w_ind_val == i){\n curVal *= w_val;//*(double*)PyArray_GETITEM(w, PyArray_GETPTR1(w, i));\n PyArray_ITER_NEXT(w_ind_it);\n PyArray_ITER_NEXT(w_it);\n w_ind_val = *(int*)PyArray_ITER_DATA(w_ind_it);\n w_val = *(double*)PyArray_ITER_DATA(w_it);\n }\n if (curVal > maxVal){\n maxVal = curVal;\n maxInd = i;\n }\n\n PyArray_ITER_NEXT(arr_it);\n }\n\n }\n }\n else{ //only indices specified in arr_ind\n\n npy_intp arr_ind_len = PyArray_DIM(reinterpret_cast(arr_ind), 0);\n npy_intp arr_len = PyArray_DIM(reinterpret_cast(arr), 0);\n\n if (arr_ind_len != arr_len){\n PyErr_SetString(PyExc_ValueError,\n \"If a_ind is a numpy array, arr should be a numpy array of the same size.\");\n return -1;\n }\n\n PyObject* arr_ind_it = PyArray_IterNew(arr_ind);\n int arr_ind_val = *(int*)PyArray_ITER_DATA(arr_ind_it);\n PyObject* arr_it = PyArray_IterNew(arr);\n double arr_val = *(double*)PyArray_ITER_DATA(arr_it);\n\n\n maxVal = arr_val;\n maxInd = 0 ; //arr_ind_val;\n //std::cout << \"maxVal = \" << maxVal << \"\\n\";\n //std::cout << \"maxInd = \" << maxInd << \"\\n\";\n\n\n if (wIsNum){\n PyObject* w_ind_it = PyArray_IterNew(w_ind);\n int w_ind_val = *(int*)PyArray_ITER_DATA(w_ind_it);\n while (PyArray_ITER_NOTDONE(w_ind_it) && arr_ind_val > w_ind_val){\n PyArray_ITER_NEXT(w_ind_it);\n w_ind_val = *(int*)PyArray_ITER_DATA(w_ind_it);\n }\n if (arr_ind_val == w_ind_val){\n maxVal *= w_num_val;\n PyArray_ITER_NEXT(w_ind_it);\n w_ind_val = *(int*)PyArray_ITER_DATA(w_ind_it);\n }\n\n for (int i = 1 ; i < arr_ind_len ; i++){\n PyArray_ITER_NEXT(arr_ind_it);\n PyArray_ITER_NEXT(arr_it);\n\n arr_ind_val = *(int*)PyArray_ITER_DATA(arr_ind_it);\n arr_val = *(double*)PyArray_ITER_DATA(arr_it); //*(double*)PyArray_GETITEM(arr, PyArray_GETPTR1(arr, arr_ind_val));\n\n while (PyArray_ITER_NOTDONE(w_ind_it) && arr_ind_val > w_ind_val){\n PyArray_ITER_NEXT(w_ind_it);\n w_ind_val = *(int*)PyArray_ITER_DATA(w_ind_it);\n }\n\n if (arr_ind_val == w_ind_val)\n arr_val *= w_num_val;\n if (arr_val > maxVal){\n maxVal = arr_val;\n maxInd = i;\n }\n\n\n }\n }\n else{ //just elements specified in arr_ind, weight's an array\n\n npy_intp arr_ind_len = PyArray_DIM(reinterpret_cast(arr_ind), 0);\n npy_intp arr_len = PyArray_DIM(reinterpret_cast(arr), 0);\n\n if (arr_ind_len != arr_len){\n PyErr_SetString(PyExc_ValueError,\n \"If a_ind is a numpy array, arr should be a numpy array of the same size.\");\n return -1;\n }\n\n\n npy_intp w_len = PyArray_DIM(reinterpret_cast(w), 0);\n npy_intp w_ind_len = PyArray_DIM(reinterpret_cast(w_ind), 0);\n if (w_ind_len != w_len){\n PyErr_SetString(PyExc_ValueError,\n \"If w is a numpy array, w_ind should be a numpy array of the same size.\");\n return -1;\n }\n\n PyObject* w_ind_it = PyArray_IterNew(w_ind);\n int w_ind_val = *(int*)PyArray_ITER_DATA(w_ind_it);\n PyObject* w_it = PyArray_IterNew(w);\n double w_val = *(double*)PyArray_ITER_DATA(w_it);\n\n\n while (PyArray_ITER_NOTDONE(w_ind_it) && arr_ind_val > w_ind_val){\n PyArray_ITER_NEXT(w_ind_it);\n PyArray_ITER_NEXT(w_it);\n w_ind_val = *(int*)PyArray_ITER_DATA(w_ind_it);\n w_val = *(double*)PyArray_ITER_DATA(w_it);\n }\n\n if (arr_ind_val == w_ind_val){\n maxVal *= w_val;\n PyArray_ITER_NEXT(w_ind_it);\n PyArray_ITER_NEXT(w_it);\n w_ind_val = *(int*)PyArray_ITER_DATA(w_ind_it);\n w_val = *(double*)PyArray_ITER_DATA(w_it);\n\n }\n\n for (int i = 1 ; i < arr_ind_len ; i++){\n PyArray_ITER_NEXT(arr_ind_it);\n PyArray_ITER_NEXT(arr_it);\n\n arr_ind_val = *(int*)PyArray_ITER_DATA(arr_ind_it);\n arr_val = *(double*)PyArray_ITER_DATA(arr_it); //*(double*)PyArray_GETITEM(arr, PyArray_GETPTR1(arr, arr_ind_val));\n\n while (PyArray_ITER_NOTDONE(w_ind_it) && arr_ind_val > w_ind_val){\n PyArray_ITER_NEXT(w_ind_it);\n PyArray_ITER_NEXT(w_it);\n w_ind_val = *(int*)PyArray_ITER_DATA(w_ind_it);\n w_val = *(double*)PyArray_ITER_DATA(w_it);\n }\n\n if (arr_ind_val == w_ind_val){\n arr_val *= w_val;\n PyArray_ITER_NEXT(w_ind_it);\n PyArray_ITER_NEXT(w_it);\n w_ind_val = *(int*)PyArray_ITER_DATA(w_ind_it);\n w_val = *(double*)PyArray_ITER_DATA(w_it);\n\n }\n if (arr_val > maxVal){\n maxVal = arr_val;\n maxInd = i;\n }\n\n\n }\n }\n }\n return maxInd;\n}\n\n\nint IClpSimplex::argWeightedMax(PyObject* arr, PyObject* whr, double weight){\n //_import_array();\n if (!PyArray_Check(arr) || !PyArray_Check(whr)){\n PyErr_SetString(PyExc_ValueError,\n \"Arguments of argWeightedMax should be numpy arrays.\");\n return -1;\n }\n PyObject* arr_it = PyArray_IterNew(arr);\n PyObject* whr_it = PyArray_IterNew(whr);\n\n npy_intp arr_len = PyArray_DIM(reinterpret_cast(arr), 0);\n\n if (arr_len == 0)\n return 0;\n\n double maxVal = *(double*)PyArray_ITER_DATA(arr_it);\n int maxInd = 0;\n double curVal;\n double curInd;\n\n int curWhere = *(int*)PyArray_ITER_DATA(whr_it);\n if (curWhere == 0){\n maxVal *= weight;\n PyArray_ITER_NEXT(whr_it);\n curWhere = *(int*)PyArray_ITER_DATA(whr_it);\n }\n\n PyArray_ITER_NEXT(arr_it);\n\n for (int i = 1 ; i < arr_len ; i++){\n curVal = *(double*)PyArray_ITER_DATA(arr_it);\n if (curWhere == i){\n curVal *= weight;\n PyArray_ITER_NEXT(whr_it);\n curWhere = *(int*)PyArray_ITER_DATA(whr_it);\n }\n if (curVal > maxVal){\n maxVal = curVal;\n maxInd = i;\n }\n\n PyArray_ITER_NEXT(arr_it);\n }\n return maxInd;\n}\n\nbool IClpSimplex::varIsFree(int ind){\n return getStatus(ind) == ClpSimplex::isFree;\n}\n\nbool IClpSimplex::varBasic(int ind){\n return getStatus(ind) == ClpSimplex::basic;\n}\n\nbool IClpSimplex::varAtUpperBound(int ind){\n return getStatus(ind) == ClpSimplex::atUpperBound;\n}\n\nbool IClpSimplex::varAtLowerBound(int ind){\n return getStatus(ind) == ClpSimplex::atLowerBound;\n}\n\nbool IClpSimplex::varSuperBasic(int ind){\n return getStatus(ind) == ClpSimplex::superBasic;\n}\n\n\nbool IClpSimplex::varIsFixed(int ind){\n return getStatus(ind) == ClpSimplex::isFixed;\n}\nPyObject* IClpSimplex::getStatusArray(){\n\n npy_intp dims = getNumCols() + getNumRows();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_UINT8, this->status_ );\n\n return Arr;\n}\n\n\nPyObject* IClpSimplex::getReducedCosts(){\n\n npy_intp dims = getNumCols() + getNumRows();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_DOUBLE, this->djRegion() );\n\n return Arr;\n}\n\nvoid IClpSimplex::setReducedCosts(double* rc){\n int dim = getNumCols() + getNumRows();\n for (int i = 0; i < dim; i++) {\n dj_[i] = rc[i];\n }\n}\n\n\nPyObject* IClpSimplex::getComplementarityList(){\n\n npy_intp dims = getNumCols() + getNumRows();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_INT32, QP_ComplementarityList );\n\n return Arr;\n}\n\nPyObject* IClpSimplex::getPivotVariable(){\n\n npy_intp dims = getNumRows();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_INT32, this->pivotVariable() );\n\n return Arr;\n}\n\n\nPyObject* IClpSimplex::getPrimalRowSolution(){\n\n npy_intp dims = getNumRows();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_DOUBLE, this->primalRowSolution() );\n\n return Arr;\n}\n\nPyObject* IClpSimplex::getPrimalColumnSolution(){\n\n npy_intp dims = getNumCols();\n PyObject *Arr = PyArray_SimpleNewFromData(1, &dims, NPY_DOUBLE, this->primalColumnSolution() );\n\n return Arr;\n}\n\nPyObject* IClpSimplex::getPrimalColumnSolutionAll(){\n npy_intp dims = getNumCols() + getNumRows();\n PyObject *Arr = PyArray_SimpleNewFromData(1, &dims, NPY_DOUBLE, this->primalColumnSolution() );\n return Arr;\n}\n\nPyObject* IClpSimplex::getSolutionRegion(){\n npy_intp dims = getNumCols() + getNumRows();\n PyObject *Arr = PyArray_SimpleNewFromData(1, &dims, NPY_DOUBLE, this->solutionRegion() );\n return Arr;\n}\n\nPyObject* IClpSimplex::getCostRegion(){\n npy_intp dims = getNumCols() + getNumRows();\n PyObject *Arr = PyArray_SimpleNewFromData(1, &dims, NPY_DOUBLE, this->costRegion() );\n return Arr;\n}\n\nPyObject* IClpSimplex::getDualRowSolution(){\n\n npy_intp dims = getNumRows();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_DOUBLE, this->dualRowSolution() );\n\n return Arr;\n}\n\nPyObject* IClpSimplex::getDualColumnSolution(){\n\n npy_intp dims = getNumCols();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_DOUBLE, this->dualColumnSolution() );\n\n return Arr;\n}\n\nPyObject* IClpSimplex::getObjective(){\n\n npy_intp dims = getNumCols();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_DOUBLE, this->objective() );\n return Arr;\n}\n\nPyObject* IClpSimplex::getRowLower(){\n\n npy_intp dims = getNumRows();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_DOUBLE, this->rowLower() );\n return Arr;\n}\n\nPyObject* IClpSimplex::getRowUpper(){\n\n npy_intp dims = getNumRows();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_DOUBLE, this->rowUpper() );\n return Arr;\n}\n\nPyObject* IClpSimplex::getUpper(){\n\n npy_intp dims = getNumRows() + getNumCols();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_DOUBLE, this->upperRegion() );\n return Arr;\n}\n\nPyObject* IClpSimplex::getLower(){\n\n npy_intp dims = getNumRows() + getNumCols();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_DOUBLE, this->lowerRegion() );\n return Arr;\n}\n\nPyObject* IClpSimplex::getColLower(){\n\n npy_intp dims = getNumCols();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_DOUBLE, this->columnLower() );\n return Arr;\n}\n\nPyObject* IClpSimplex::getColUpper(){\n\n npy_intp dims = getNumCols();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_DOUBLE, this->columnUpper() );\n return Arr;\n}\n\nPyObject* IClpSimplex::getColumnScale(){\n\n npy_intp dims = getNumCols();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_DOUBLE, columnScale_);\n return Arr;\n}\n\nPyObject* IClpSimplex::getRowScale(){\n\n npy_intp dims = getNumRows();\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_DOUBLE, rowScale_ );\n return Arr;\n}\n\n\n\nPyObject* IClpSimplex::getIntegerInformation(){\n npy_intp dims = getNumCols();\n PyObject* Arr;\n if (this->integerInformation())\n Arr = PyArray_SimpleNewFromData(1, &dims, NPY_INT8, this->integerInformation());\n else\n Arr = PyArray_ZEROS(1, &dims, NPY_INT8, 0);\n return Arr;\n}\n\nstd::vector IClpSimplex::getVariableNames(){\n if (lengthNames_)\n return columnNames_;\n return std::vector ();\n}\n\nvoid IClpSimplex::setVariableName(int varInd, char* name){\n if (varInd >= getNumCols())\n return;\n if (lengthNames_ == 0){\n unsigned int maxLength=0;\n int iRow;\n\n rowNames_ = std::vector ();\n columnNames_ = std::vector ();\n rowNames_.reserve(numberRows_);\n for (iRow=0;iRow maxLength)\n maxLength = rowName.length();\n rowNames_.push_back(rowName);\n }\n\n columnNames_.reserve(numberColumns_);\n int iColumn;\n for (iColumn=0;iColumn maxLength)\n maxLength = colName.length();\n columnNames_.push_back(colName);\n }\n//\n// int iColumn;\n// columnNames_.reserve(numberColumns_);\n// for (iColumn=0;iColumn (strlen(name)));\n// columnNames_.push_back(name);\n// }\n lengthNames_=static_cast (maxLength);\n// columnNames_.resize(getNumCols());\n\n //std::cout << columnNamesAsChar()[10] << \"<$$$$$$$$$$$$$\\n\";\n }\n std::string st(name);\n columnNames_[varInd] = st;\n}\n\nvoid IClpSimplex::setConstraintName(int constInd, char* name){\n if (constInd >= getNumRows())\n return;\n if (lengthNames_ == 0){\n unsigned int maxLength=0;\n int iRow;\n\n rowNames_ = std::vector ();\n columnNames_ = std::vector ();\n rowNames_.reserve(numberRows_);\n for (iRow=0;iRow maxLength)\n maxLength = rowName.length();\n rowNames_.push_back(rowName);\n }\n\n columnNames_.reserve(numberColumns_);\n int iColumn;\n for (iColumn=0;iColumn maxLength)\n maxLength = colName.length();\n columnNames_.push_back(colName);\n }\n lengthNames_=static_cast (maxLength);\n }\n std::string st(name);\n rowNames_[constInd] = st;\n}\n\nvoid IClpSimplex::createTempArray(){\n tempIntArray = new int[getNumCols() + getNumRows()];\n tempArrayExists = true;\n}\n\nIClpSimplex::IClpSimplex(PyObject *obj_arg, runIsPivotAcceptable_t runIsPivotAcceptable_arg,\n varSelCriteria_t runVarSelCriteria ):ClpSimplex()\n {\n\n _import_array();\n tempArrayExists = false;\n obj = obj_arg;\n runIsPivotAcceptable = runIsPivotAcceptable_arg;\n varSelCriteria = runVarSelCriteria;\n customPrimal = 0;\n createStatus();\n pinfo = ClpPresolve();\n\n tempRow = NULL;\n tempRow_vector = NULL;\n QP_BanList = NULL;\n QP_ComplementarityList = NULL;\n}\n\n\n\n\nvoid IClpSimplex::useCustomPrimal(int u)\n{\n customPrimal = u;\n}\n\nint IClpSimplex::getUseCustomPrimal()\n{\n return customPrimal;\n}\n\nvoid IClpSimplex::setComplementarityList(int * cl)\n{\n QP_ComplementarityList = cl;\n}\n\nint* IClpSimplex::ComplementarityList()\n{\n return QP_ComplementarityList;\n}\n\nvoid IClpSimplex::setBasisStatus(const int* cstat, const int* rstat){\n OsiClpSolverInterface osi(this, false);\n osi.setBasisStatus(cstat, rstat);\n return;\n}\n\nvoid IClpSimplex::setMaxNumIteration(int m){\n setIntParam(ClpMaxNumIteration, m);\n}\n\nvoid IClpSimplex::getBasisStatus(int* cstat, int* rstat){\n OsiClpSolverInterface osi(this, false);\n osi.getBasisStatus(cstat, rstat);\n return;\n}\n\nIClpSimplex::IClpSimplex (ClpSimplex * wholeModel,\n int numberColumns, const int * whichColumns):\n ClpSimplex(wholeModel, numberColumns, whichColumns)\n{\n _import_array();\n tempArrayExists = false;\n tempRow_vector = NULL;\n tempRow = NULL;\n\n QP_ComplementarityList = NULL;\n QP_BanList = NULL;//new int[nvars];\n pinfo = ClpPresolve();\n}\n\n\nIClpSimplex::~IClpSimplex(){\n if (QP_ComplementarityList)\n delete QP_ComplementarityList;\n\n if (QP_BanList)\n delete QP_BanList;\n\n if (tempRow)\n delete tempRow;\n\n if (tempRow_vector)\n delete tempRow_vector;\n\n}\n\n\nvoid IClpSimplex::dualExpanded(ClpSimplex * model,CoinIndexedVector * array,\n double * other,int mode){\n\n this->clpMatrix()->dualExpanded(model,array,other,mode);\n}\n\nint IClpSimplex::isPivotAcceptable()\n{\n if (this->obj && this->runIsPivotAcceptable) {\n return this->runIsPivotAcceptable(this->obj);\n }\n std::cerr << \"** pivotRow: invalid cy-state: obj [\" << this->obj << \"] fct: [\"\n << this->runIsPivotAcceptable << \"]\\n\";\n return -1;\n}\n\nvoid IClpSimplex::setCriteria(varSelCriteria_t vsc){\n varSelCriteria = vsc;\n}\n\nint IClpSimplex::checkVar(int varInd){\n if (this->obj && this->varSelCriteria) {\n return this->varSelCriteria(this->obj, varInd);\n }\n std::cerr << \"** pivotRow: invalid cy-state: obj [\" << this->obj << \"] fct: [\"\n << this->varSelCriteria << \"]\\n\";\n return -1;\n\n}\n\n\nICbcModel* IClpSimplex::getICbcModel(){\n // ?\n matrix_->setDimensions(numberRows_, numberColumns_);\n\n OsiClpSolverInterface solver1(this);\n ICbcModel* model = new ICbcModel(solver1);\n return model;\n}\n\nvoid IClpSimplex::writeLp(const char *filename,\n const char *extension,\n double epsilon,\n int numberAcross,\n int decimals,\n double objSense,\n bool useRowNames)\n {\n matrix_->setDimensions(numberRows_, numberColumns_);\n\n OsiClpSolverInterface solver1(this);\n solver1.writeLp(filename, extension, epsilon, numberAcross, decimals, objSense, useRowNames);\n return ;\n\n }\n\n\n\n//Get a column of the tableau\n void\nIClpSimplex::getBInvACol(int col, double* vec)\n{\n if (!rowArray_[0]) {\n printf(\"ClpSimplexPrimal or ClpSimplexDual should have been called with correct startFinishOption\\n\");\n abort();\n }\n CoinIndexedVector * rowArray0 = rowArray(0);\n CoinIndexedVector * rowArray1 = rowArray(1);\n rowArray0->clear();\n rowArray1->clear();\n // get column of matrix\n#ifndef NDEBUG\n int n = numberColumns_+numberRows_;\n if (col<0||col>=n) {\n //indexError(col,\"getBInvACol\");\n }\n#endif\n if (!rowScale_) {\n if (colinsert(col-numberColumns_,1.0);\n }\n } else {\n if (colgetNumElements();\n int * index = rowArray1->getIndices();\n double * array = rowArray1->denseVector();\n for (int i=0;iinsert(col-numberColumns_,rowScale_[col-numberColumns_]);\n }\n }\n factorization_->updateColumn(rowArray0,rowArray1,false);\n // But swap if pivot variable was slack as clp stores slack as -1.0\n double * array = rowArray1->denseVector();\n if (!rowScale_) {\n for (int i=0;iclear();\n}\n\n\n//Fetches the ncol th column into colArray\nvoid IClpSimplex::getACol(int ncol, CoinIndexedVector * colArray){\n\n\n //CoinIndexedVector * colArray = temp_rowArray[1];\n\n colArray->clear();\n\n // get column of matrix\n#ifndef NDEBUG\n //int n = numberColumns_+numberRows_;\n //if (ncol<0||ncol>=n) {\n //\tindexError(ncol,\"getBInvACol\");\n //}\n#endif\n\n if (!rowScale()) {\n if (ncolinsert(ncol- numberColumns(),1.0);\n }\n } else {\n if (ncolgetNumElements();\n int * index = colArray->getIndices();\n double * array = colArray->denseVector();\n for (int i=0;iinsert(ncol- numberColumns(),rowScale()[ncol-numberColumns()]);\n }\n }\n\n}\n\n\nvoid IClpSimplex::getRightHandSide(double* righthandside)\n{\n int nr=numberRows();\n\n extractSenseRhsRange(righthandside);\n\n int* basis_index = pivotVariable();\n\n\n //FIXME: change these lines to be like getColSoution and getRowActivity in OsiClp\n const double *solution = solutionRegion(1);\n const double *row_act = solutionRegion(0);\n\n //FIXME: This must be fixed. The first line causes seg fault\n //So I'm allocating and deleting in this function\n //double *slack_val = tempRow;\n double *slack_val = new double[nr];\n\n for(int i=0; i -inf) {\n if (upper < inf) {\n right = upper;\n //if (upper==lower) {\n //sense = 'E';\n //} else {\n //sense = 'R';\n //range = upper - lower;\n //}\n } else {\n //sense = 'G';\n right = lower;\n }\n } else {\n if (upper < inf) {\n //sense = 'L';\n right = upper;\n } else {\n //sense = 'N';\n right = 0.0;\n }\n }\n}\n\n\nvoid IClpSimplex::vectorTimesB_1(CoinIndexedVector* vec){\n factorization_->updateColumnTranspose(tempRow_vector, vec);\n}\n\n\n\nvoid IClpSimplex::transposeTimesSubset(int number, int* which, double* pi, double* y){\n reinterpret_cast(matrix_)->transposeTimesSubset(number,\n which, pi, y, rowScale(), columnScale(), NULL);\n}\n\n\nvoid IClpSimplex::transposeTimes(const ClpSimplex * model, double scalar,\n const CoinIndexedVector * x,\n CoinIndexedVector * y,\n CoinIndexedVector * z){\n reinterpret_cast(matrix_)->transposeTimes(\n model, scalar, x, y, z);\n}\n\n\nvoid IClpSimplex::transposeTimesSubsetAll(int number, long long int* which, double* pi, double* y){\n reinterpret_cast(matrix_)->transposeTimesSubsetAll(this, number,\n which, pi, y, rowScale(), columnScale(), NULL);\n}\n\n// Copy constructor.\nIClpSimplex::IClpSimplex(const ClpSimplex &rhs,PyObject *obj,\n runIsPivotAcceptable_t runIsPivotAcceptable,\n varSelCriteria_t varSelCriteria,\n int useCustomPrimal, int scalingMode ) :\n ClpSimplex(rhs,scalingMode),\n obj(obj),\n runIsPivotAcceptable(runIsPivotAcceptable),\n varSelCriteria(varSelCriteria),\n customPrimal(useCustomPrimal),\n tempArrayExists(false),\n tempRow(NULL),\n tempRow_vector(NULL),\n QP_BanList(NULL),\n QP_ComplementarityList(NULL)\n{\n}\n\n\n\n\nIClpSimplex* IClpSimplex::preSolve(IClpSimplex* si,\n double feasibilityTolerance,\n bool keepIntegers,\n int numberPasses,\n bool dropNames,\n bool doRowObjective)\n{\n //ClpPresolve pinfo;\n ClpSimplex* s = pinfo.presolvedModel(*si,feasibilityTolerance,\n keepIntegers, numberPasses, dropNames, doRowObjective);\n if (s)\n {\n IClpSimplex* ret = new IClpSimplex(*s, si->obj, si->runIsPivotAcceptable, si->varSelCriteria, si->customPrimal);\n //ret->pinfo = pinfo;\n //pinfo.postsolve();\n return ret;\n }\n\n return NULL;\n}\n\nvoid IClpSimplex::postSolve(bool updateStatus){\n pinfo.postsolve(updateStatus);\n}\n\n\nint IClpSimplex::dualWithPresolve(IClpSimplex* si,\n double feasibilityTolerance,\n bool keepIntegers,\n int numberPasses,\n bool dropNames,\n bool doRowObjective)\n{\n ClpPresolve pinfoTemp;\n ClpSimplex* s = pinfoTemp.presolvedModel(*si,feasibilityTolerance,\n keepIntegers, numberPasses, dropNames, doRowObjective);\n if (s)\n {\n int ret = s->dual();\n pinfoTemp.postsolve();\n delete s;\n checkSolution();\n dual();\n return ret;\n }\n return -2000;\n}\n\n\nint IClpSimplex::primalWithPresolve(IClpSimplex* si,\n double feasibilityTolerance,\n bool keepIntegers,\n int numberPasses,\n bool dropNames,\n bool doRowObjective)\n{\n ClpPresolve pinfoTemp;\n ClpSimplex* s = pinfoTemp.presolvedModel(*si,feasibilityTolerance,\n keepIntegers, numberPasses, dropNames, doRowObjective);\n if (s)\n {\n int ret = s->primal();\n pinfoTemp.postsolve();\n delete s;\n checkSolution();\n primal();\n return ret;\n }\n return -2000;\n}\n\nint IClpSimplex::initialSolve(int preSolveType){\n ClpSolve options;\n options.setPresolveType(static_cast(preSolveType));\n return ClpSimplex::initialSolve(options);\n}\n\n\nint IClpSimplex::primal (int ifValuesPass , int startFinishOptions)\n{\n // @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n if (tempRow == NULL)\n tempRow = new double[numberRows()];\n if (tempRow_vector == NULL)\n tempRow_vector = new CoinIndexedVector();\n if (QP_BanList == NULL)\n QP_BanList = new int[numberColumns() + numberRows()];\n //FIXME: This is a crazy 1000 here.\n //But whatever you do to fix this try it on adlittle, degen2\n tempRow_vector->reserve(numberRows() + numberColumns() + numberExtraRows() + 1000);\n //tempRow_vector->reserve(numberRows() + +numberColumns() + numberExtraRows());\n\n\n //double savedPivotTolerance = factorization_->pivotTolerance();\n#ifndef SLIM_CLP\n // See if nonlinear\n if (objective_->type()>1&&objective_->activated())\n return reducedGradient();\n#endif\n CoinAssert ((ifValuesPass>=0&&ifValuesPass<3)||\n (ifValuesPass>=12&&ifValuesPass<100)||\n (ifValuesPass>=112&&ifValuesPass<200));\n if (ifValuesPass>=12) {\n int numberProblems = (ifValuesPass-10)%100;\n ifValuesPass = (ifValuesPass<100) ? 1 : 2;\n // Go parallel to do solve\n // Only if all slack basis\n int i;\n for ( i=0;igetIndices();\n const CoinBigIndex * columnStart = matrix_->getVectorStarts();\n const int * columnLength = matrix_->getVectorLengths();\n const double * element = matrix_->getElements();\n for (int iColumn=0;iColumn(numberRows_))<1.0) {\n // Could do better if can decompose\n // correction to get feasible\n double scaleFactor = 1.0/numberProblems;\n double * correction = new double [numberRows_];\n for (int iRow=0;iRowrowUpper_[iRow])\n value = rowUpper_[iRow]-value;\n else if (value-1.0e30)\n rowLower_[iRow]=value;\n }\n model[i] = new ClpSimplex(this,numberRows_,whichRows,\n endColumn-startColumn,whichColumns);\n //#define FEB_TRY\n#ifdef FEB_TRY\n model[i]->setPerturbation(perturbation_);\n#endif\n startColumn=endColumn;\n }\n memcpy(rowLower_,saveLower,numberRows_*sizeof(double));\n memcpy(rowUpper_,saveUpper,numberRows_*sizeof(double));\n delete [] saveLower;\n delete [] saveUpper;\n delete [] correction;\n // solve (in parallel)\n for (int i=0;iprimal(1/*ifValuesPass*/);\n }\n startColumn=0;\n int numberBasic=0;\n // use whichRows as counter\n for (int iRow=0;iRowrowLower_[iRow])\n startValue++;\n if (rowUpper_[iRow]>1.0e30)\n startValue++;\n if (rowLower_[iRow]<-1.0e30)\n startValue++;\n whichRows[iRow]=1000*startValue;\n }\n for (int i=0;igetColumnStatus(iColumn-startColumn);\n setColumnStatus(iColumn,status);\n if (status==basic)\n numberBasic++;\n }\n for (int iRow=0;iRowgetRowStatus(iRow)==basic)\n whichRows[iRow]++;\n }\n delete model[i];\n startColumn=endColumn;\n }\n delete [] model;\n for (int iRow=0;iRownumberRows_) {\n double * away = new double [numberBasic];\n numberBasic=0;\n for (int iColumn=0;iColumn (this)->primal(ifValuesPass,startFinishOptions);\n }\n else {\n //std::cout << \"IClpSimplex L280: casting to IClpSimplexPrimal\\n\";\n returnCode = reinterpret_cast (this)->primal(ifValuesPass,startFinishOptions);\n }\n //int lastAlgorithm=1;\n\n if (problemStatus_==10) {\n //lastAlgorithm=-1;\n //printf(\"Cleaning up with dual\\n\");\n int savePerturbation = perturbation_;\n perturbation_=100;\n bool denseFactorization = initialDenseFactorization();\n // It will be safe to allow dense\n setInitialDenseFactorization(true);\n // check which algorithms allowed\n int dummy;\n baseIteration_=numberIterations_;\n if ((matrix_->generalExpanded(this,4,dummy)&2)!=0&&(specialOptions_&8192)==0) {\n double saveBound = dualBound_;\n // upperOut_ has largest away from bound\n dualBound_=std::min(std::max(2.0*upperOut_,1.0e8),dualBound_);\n returnCode = reinterpret_cast (this)->dual(0,startFinishOptions);\n dualBound_=saveBound;\n } else {\n if (!customPrimal){\n std::cout << \"IClpSimplex: continue with ClpSimplexPrimal \\n\";\n returnCode = reinterpret_cast (this)->primal(0,startFinishOptions);\n }else {\n std::cout << \"IClpSimplex: casting to IClpSimplexPrimal\\n\";\n returnCode = reinterpret_cast (this)->primal(0,startFinishOptions);\n }\n }\n\n baseIteration_=0;\n setInitialDenseFactorization(denseFactorization);\n perturbation_=savePerturbation;\n if (problemStatus_==10)\n problemStatus_=0;\n }\n //factorization_->pivotTolerance(savedPivotTolerance);\n onStopped(); // set secondary status if stopped\n //if (problemStatus_==1&&lastAlgorithm==1)\n //returnCode=10; // so will do primal after postsolve\n\n //delete tempRow;\n //delete tempRow_vector;\n //delete QP_BanList;\n\n\n return returnCode;\n}\n\n\ndouble cdot(CoinIndexedVector* pv1, CoinIndexedVector* pv2){\n double sum = 0;\n int\tsize = pv1->getNumElements();\n int* indices = pv1->getIndices();\n\n for (int i = 0; i < size; i++)\n sum += (*pv1)[indices[i]] * (*pv2)[indices[i]];\n return sum;\n\n}\n\nPyObject* IClpSimplex::filterVars(PyObject* inds){\n if (!PyArray_Check(inds)){\n PyErr_SetString(PyExc_ValueError,\n \"filterVars: inds should be a numpy array.\");\n return NULL;\n }\n\n npy_intp inds_len = PyArray_DIM(reinterpret_cast(inds), 0);\n if (inds_len == 0){\n npy_intp dims = 0;\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_INT, tempIntArray );\n return Arr;\n }\n if (tempArrayExists == false)\n createTempArray();\n\n int ind_count = 0;\n\n PyObject* inds_it= PyArray_IterNew(inds);\n int i;\n double bestRc = 0;\n double* rc = djRegion();\n while (PyArray_ITER_NOTDONE(inds_it)){\n i = *(int*)PyArray_ITER_DATA(inds_it);\n if (fabs(rc[i]) < bestRc){\n PyArray_ITER_NEXT(inds_it);\n continue;\n }\n if (checkVar(i)){\n tempIntArray[ind_count++] = i;\n bestRc = fabs(rc[i]);\n }\n PyArray_ITER_NEXT(inds_it);\n }\n\n npy_intp dims = ind_count;\n PyObject *Arr = PyArray_SimpleNewFromData( 1, &dims, NPY_INT, tempIntArray );\n return Arr;\n\n}\n\n"
},
{
"path": "cylp/cpp/IClpSimplex.hpp",
"content": "#ifndef IClpSimplex_H\n#define IClpSimplex_H\n\n//#define NPY_NO_DEPRECATED_API\n//#define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION\n\n//#include \"ClpModel.hpp\"\n#include \"ClpSimplex.hpp\"\n#include \"ClpPresolve.hpp\"\n#include \"ClpLinearObjective.hpp\"\n#include \"CoinIndexedVector.hpp\"\n#include \"ClpFactorization.hpp\"\n#include \"Python.h\"\n#include \n#include \"ICbcModel.hpp\"\n#include \"ClpParameters.hpp\"\n\n#include \"ICoinPackedMatrix.hpp\"\n\n\n//#include \"ClpSimplexPrimal.hpp\"\n\ntypedef int (*runIsPivotAcceptable_t)(void *instance);\ntypedef int (*varSelCriteria_t)(void *instance, int varInd);\n\n\nclass IClpSimplex : public ClpSimplex{\npublic:\n ClpPresolve pinfo;\n IClpSimplex(const ClpSimplex &rhs,PyObject *obj,\n runIsPivotAcceptable_t runPivotRow,\n varSelCriteria_t RunVarSelCriteria,\n int useCustomPrimal, int scalingMode=-1 );\n\tIClpSimplex(PyObject *obj, runIsPivotAcceptable_t runPivotRow,\n varSelCriteria_t RunVarSelCriteria );\n int initialSolve(int preSolveType=ClpSolve::presolveOn);\n\t// For initializing instances that are build using ClpSimplex consructor (NOT IClpSimplex)\n void setCriteria(varSelCriteria_t vsc);\n\n int argWeightedMax(PyObject* arr, PyObject* whr, double weight);\n int argWeightedMax(PyObject* arr, PyObject* arr_ind, PyObject* w, PyObject* w_ind);\n\n PyObject *obj;\n \trunIsPivotAcceptable_t runIsPivotAcceptable;\n\tint isPivotAcceptable();\n\n varSelCriteria_t varSelCriteria;\n int checkVar(int varInd);\n PyObject* filterVars(PyObject* inds);\n int* tempIntArray;\n bool tempArrayExists;\n void createTempArray(void);\n\n int* QP_ComplementarityList;\n\tint* QP_BanList;\n\tint QP_ExistsBannedVariable;\n\n\tvoid setComplementarityList(int *);\n\tint* ComplementarityList();\n\n bool varIsFree(int ind);\n bool varBasic(int ind);\n bool varAtUpperBound(int ind);\n bool varAtLowerBound(int ind);\n bool varSuperBasic(int ind);\n bool varIsFixed(int ind);\n\tPyObject * getReducedCosts();\n\tvoid setReducedCosts(double*);\n PyObject * getStatusArray();\n\tPyObject * getComplementarityList();\n\tPyObject * getPivotVariable();\n\tPyObject * getPrimalRowSolution();\n\tPyObject * getPrimalColumnSolution();\n PyObject * getPrimalColumnSolutionAll();\n PyObject * getSolutionRegion();\n PyObject * getCostRegion();\n\tPyObject * getDualRowSolution();\n\tPyObject * getDualColumnSolution();\n\tPyObject * getObjective();\n\tPyObject * getRowLower();\n\tPyObject * getRowUpper();\n\tPyObject * getColLower();\n PyObject * getColUpper();\n PyObject * getColumnScale();\n PyObject * getRowScale();\n\n\n PyObject* getLower();\n PyObject* getUpper();\n\n PyObject* getIntegerInformation();\n\n\n\n\n\tvoid getBInvACol(int col, double* vec);\n\tvoid getACol(int ncol, CoinIndexedVector * colArray);\n int updateColumnFT(CoinIndexedVector * spare,\n CoinIndexedVector * updatedColumn)\n {\n return this->factorization()->updateColumnFT(spare, updatedColumn);\n }\n\n int updateColumnTranspose (CoinIndexedVector * regionSparse,\n CoinIndexedVector * regionSparse2){\n return this->factorization()->updateColumnTranspose(regionSparse, regionSparse2);\n }\n\n\tint customPrimal;\n\tvoid useCustomPrimal(int);\n\tint getUseCustomPrimal();\n\n\n\tvoid setPrimalColumnPivotAlgorithm(ClpPrimalColumnPivot *choice){ClpSimplex::setPrimalColumnPivotAlgorithm(*choice);}\n void setDualRowPivotAlgorithm(ClpDualRowPivot *choice){ClpSimplex::setDualRowPivotAlgorithm(*choice);}\n\n void loadQuadraticObjective(const CoinPackedMatrix* matrix){ClpModel::loadQuadraticObjective(*matrix);}\n ICoinPackedMatrix* getMatrix(){return static_cast(ClpModel::matrix());}\n\n\tint loadProblem (CoinModel * modelObject,bool tryPlusMinusOne=false){return ClpSimplex::loadProblem(*modelObject, tryPlusMinusOne);}\n\t//double* infeasibilityRay();\n void loadProblem (const CoinPackedMatrix* matrix,\n\t\t const double* collb, const double* colub,\n\t\t const double* obj,\n\t\t const double* rowlb, const double* rowub,\n\t\t const double * rowObjective=NULL){\n ClpSimplex::loadProblem(*matrix, collb, colub, obj, rowlb, rowub, rowObjective);}\n\n\tint primal(int ifValuesPass=0, int startFinishOptions=0);\n\n\tIClpSimplex (ClpSimplex * wholeModel,\n\t int numberColumns, const int * whichColumns);\n\n\t~IClpSimplex();\n\n\tvoid dualExpanded(ClpSimplex * model,CoinIndexedVector * array, double * other,int mode);\n\n\n\tvoid convertBoundToSense(const double lower, const double upper,\n\t\t\t\t\t\t double& right);\n\tvoid extractSenseRhsRange(double* rhs_);\n\tvoid getRightHandSide(double* righthandside);\n\n\n\tdouble* tempRow;\n\tCoinIndexedVector* tempRow_vector;\n\n\tvoid vectorTimesB_1(CoinIndexedVector*);\n void transposeTimesSubsetAll(int number, long long int* which, double* pi, double* y);\n void transposeTimesSubset(int number, int* which, double* pi, double* y);\n void transposeTimes(const ClpSimplex * model, double scalar,\n const CoinIndexedVector * x,\n CoinIndexedVector * y,\n CoinIndexedVector * z);\n\n IClpSimplex*\tpreSolve(IClpSimplex* si,\n double feasibilityTolerance=0.0,\n bool keepIntegers=true,\n int numberPasses=5,\n bool dropNames=false,\n bool doRowObjective=false);\n void postSolve(bool updateStatus=true);\n\n int dualWithPresolve(IClpSimplex* si,\n double feasibilityTolerance=0.0,\n bool keepIntegers=true,\n int numberPasses=5,\n bool dropNames=false,\n bool doRowObjective=false);\n\n int primalWithPresolve(IClpSimplex* si,\n double feasibilityTolerance=0.0,\n bool keepIntegers=true,\n int numberPasses=5,\n bool dropNames=false,\n bool doRowObjective=false);\n\n void setComplement(int var1, int var2){QP_ComplementarityList[var1] = var2; QP_ComplementarityList[var2] = var1;}\n\n\n inline double getCoinInfinity(){return COIN_DBL_MAX;}\n\n inline void setColumnUpperArray(double *cu){columnUpper_ = cu;}\n inline void setColumnLowerArray(double *cl){columnLower_ = cl;}\n inline void setRowUpperArray(double *ru){rowUpper_ = ru;}\n inline void setRowLowerArray(double *rl){rowLower_ = rl;}\n\n inline void setColumnUpperSubset(int n, int *indicesOfIndices, int *indices, double* values){\n for (int i = 0 ; i < n ; i++)\n setColumnUpper(indices[indicesOfIndices[i]], values[indicesOfIndices[i]]);\n }\n inline void setColumnLowerSubset(int n, int *indicesOfIndices, int *indices, double* values){\n for (int i = 0 ; i < n ; i++)\n setColumnLower(indices[indicesOfIndices[i]], values[indicesOfIndices[i]]);\n }\n\n inline void setColumnUpperFirstElements(int n, double* values){\n for (int i = 0 ; i < n ; i++)\n setColumnUpper(i, values[i]);\n }\n inline void setColumnLowerFirstElements(int n, double* values){\n for (int i = 0 ; i < n ; i++)\n setColumnLower(i, values[i]);\n }\n\n inline void setObjectiveArray(double *o, int numberColumns)\n {\n if (objective_)\n \tdelete objective_;\n objective_ = new ClpLinearObjective(o, numberColumns);\n }\n\n\tvoid setVariableName(int varInd, char* name);\n void setConstraintName(int constInd, char* name);\n std::vector getVariableNames();\n\n /// Partial pricing\n int partialPrice(int start, int end, int* numberWanted)\n {\n int bestVarInd;\n this->clpMatrix()->partialPricing(this,\n static_cast(start),\n static_cast(end),\n bestVarInd,\n *numberWanted);\n return bestVarInd;\n }\n\n ICbcModel* getICbcModel();\n void writeLp(const char *filename,\n const char *extension = \"lp\",\n double epsilon = 1e-5,\n int numberAcross = 10,\n int decimals = 5,\n double objSense = 0.0,\n bool useRowNames = true);\n\n void setBasisStatus(const int* cstat, const int* rstat);\n void getBasisStatus(int* cstat, int* rstat);\n\n void setMaxNumIteration(int m);\n\n};\n\ndouble cdot(CoinIndexedVector* v1, CoinIndexedVector* v2);\n\n\n#endif\n"
},
{
"path": "cylp/cpp/IClpSimplexPrimal.cpp",
"content": "// Copyright (C) 2002, International Business Machines\n// Corporation and others. All Rights Reserved.\n\n/* Notes on implementation of primal simplex algorithm.\n\n When primal feasible(A):\n\n If dual feasible, we are optimal. Otherwise choose an infeasible\n basic variable to enter basis from a bound (B). We now need to find an\n outgoing variable which will leave problem primal feasible so we get\n the column of the tableau corresponding to the incoming variable\n (with the correct sign depending if variable will go up or down).\n\n We now perform a ratio test to determine which outgoing variable will\n preserve primal feasibility (C). If no variable found then problem\n is unbounded (in primal sense). If there is a variable, we then\n perform pivot and repeat. Trivial?\n\n -------------------------------------------\n\n A) How do we get primal feasible? All variables have fake costs\n outside their feasible region so it is trivial to declare problem\n feasible. OSL did not have a phase 1/phase 2 approach but\n instead effectively put an extra cost on infeasible basic variables\n I am taking the same approach here, although it is generalized\n to allow for non-linear costs and dual information.\n\n In OSL, this weight was changed heuristically, here at present\n it is only increased if problem looks finished. If problem is\n feasible I check for unboundedness. If not unbounded we\n could play with going into dual. As long as weights increase\n any algorithm would be finite.\n\n B) Which incoming variable to choose is a virtual base class.\n For difficult problems steepest edge is preferred while for\n very easy (large) problems we will need partial scan.\n\n C) Sounds easy, but this is hardest part of algorithm.\n 1) Instead of stopping at first choice, we may be able\n to allow that variable to go through bound and if objective\n still improving choose again. These mini iterations can\n increase speed by orders of magnitude but we may need to\n go to more of a bucket choice of variable rather than looking\n at them one by one (for speed).\n 2) Accuracy. Basic infeasibilities may be less than\n tolerance. Pivoting on these makes objective go backwards.\n OSL modified cost so a zero move was made, Gill et al\n modified so a strictly positive move was made.\n The two problems are that re-factorizations can\n change rinfeasibilities above and below tolerances and that when\n finished we need to reset costs and try again.\n 3) Degeneracy. Gill et al helps but may not be enough. We\n may need more. Also it can improve speed a lot if we perturb\n the rhs and bounds significantly.\n\n References:\n Forrest and Goldfarb, Steepest-edge simplex algorithms for\n linear programming - Mathematical Programming 1992\n Forrest and Tomlin, Implementing the simplex method for\n the Optimization Subroutine Library - IBM Systems Journal 1992\n Gill, Murray, Saunders, Wright A Practical Anti-Cycling\n Procedure for Linear and Nonlinear Programming SOL report 1988\n\n\n TODO:\n\n a) Better recovery procedures. At present I never check on forward\n progress. There is checkpoint/restart with reducing\n re-factorization frequency, but this is only on singular\n factorizations.\n b) Fast methods for large easy problems (and also the option for\n the code to automatically choose which method).\n c) We need to be able to stop in various ways for OSI - this\n is fairly easy.\n\n */\n\n#include \"CoinPragma.hpp\"\n\n#include \n\n#include \"CoinHelperFunctions.hpp\"\n#include \"IClpSimplexPrimal.hpp\"\n#include \"ClpFactorization.hpp\"\n#include \"ClpNonLinearCost.hpp\"\n#include \"CoinPackedMatrix.hpp\"\n#include \"CoinIndexedVector.hpp\"\n#include \"ClpPrimalColumnPivot.hpp\"\n#include \"ClpMessage.hpp\"\n#include \"ClpEventHandler.hpp\"\n#include \n#include \n#include \n#include \n#include \n\n\n#include \"CyClpSimplex_api.h\"\n\n// primal\nint IClpSimplexPrimal::primal (int ifValuesPass , int startFinishOptions)\n{\n\n\t/*\n\t Method\n\n It tries to be a single phase approach with a weight of 1.0 being\n given to getting optimal and a weight of infeasibilityCost_ being\n given to getting primal feasible. In this version I have tried to\n be clever in a stupid way. The idea of fake bounds in dual\n seems to work so the primal analogue would be that of getting\n bounds on reduced costs (by a presolve approach) and using\n these for being above or below feasible region. I decided to waste\n memory and keep these explicitly. This allows for non-linear\n costs!\n\n The code is designed to take advantage of sparsity so arrays are\n seldom zeroed out from scratch or gone over in their entirety.\n The only exception is a full scan to find incoming variable for\n Dantzig row choice. For steepest edge we keep an updated list\n of dual infeasibilities (actually squares).\n On easy problems we don't need full scan - just\n pick first reasonable.\n\n One problem is how to tackle degeneracy and accuracy. At present\n I am using the modification of costs which I put in OSL and which was\n extended by Gill et al. I am still not sure of the exact details.\n\n The flow of primal is three while loops as follows:\n\n while (not finished) {\n\n\t while (not clean solution) {\n\n\t Factorize and/or clean up solution by changing bounds so\n\t primal feasible. If looks finished check fake primal bounds.\n\t Repeat until status is iterating (-1) or finished (0,1,2)\n\n\t }\n\n\t while (status==-1) {\n\n\t Iterate until no pivot in or out or time to re-factorize.\n\n\t Flow is:\n\n\t choose pivot column (incoming variable). if none then\n\t we are primal feasible so looks as if done but we need to\n\t break and check bounds etc.\n\n\t Get pivot column in tableau\n\n\t Choose outgoing row. If we don't find one then we look\n\t primal unbounded so break and check bounds etc. (Also the\n\t pivot tolerance is larger after any iterations so that may be\n\t reason)\n\n\t If we do find outgoing row, we may have to adjust costs to\n\t keep going forwards (anti-degeneracy). Check pivot will be stable\n\t and if unstable throw away iteration and break to re-factorize.\n\t If minor error re-factorize after iteration.\n\n\t Update everything (this may involve changing bounds on\n\t variables to stay primal feasible.\n\n\t }\n\n }\n\n At present we never check we are going forwards. I overdid that in\n OSL so will try and make a last resort.\n\n Needs partial scan pivot in option.\n\n May need other anti-degeneracy measures, especially if we try and use\n loose tolerances as a way to solve in fewer iterations.\n\n I like idea of dynamic scaling. This gives opportunity to decouple\n different implications of scaling for accuracy, iteration count and\n feasibility tolerance.\n\n\t */\n\n\t // @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\t //int listSize = numberRows() + numberColumns();\n\n\t //QP_ComplementarityList = new int[listSize];\n\n\t//for (int i = 0 ; i < listSize ; i++)\n\t//\tQP_ComplementarityList[i] = i;\n\n\t//QP_ComplementarityList[0] = 2;\n\t//QP_ComplementarityList[2] = 0;\n\n\n\t//QP_BanList = new int[listSize];\n\t//for (int i = 0; i < listSize ; i++)\n\t//\tQP_BanList[i] = 0;\n\n\t//QP_ExistsBannedVariable = 0;\n\t// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n\n\talgorithm_ = +1;\n\tmoreSpecialOptions_ &= ~16; // clear check replaceColumn accuracy\n\n\t// save data\n\tClpDataSave data = saveData();\n\tmatrix_->refresh(this); // make sure matrix okay\n\n\n\t// Save so can see if doing after dual\n\tint initialStatus=problemStatus_;\n\tint initialIterations = numberIterations_;\n\tint initialNegDjs=-1;\n\t// initialize - maybe values pass and algorithm_ is +1\n#if 0\n\t// if so - put in any superbasic costed slacks\n\tif (ifValuesPass&&specialOptions_<0x01000000) {\n\t\t// Get column copy\n\t\tconst CoinPackedMatrix * columnCopy = matrix();\n\t\tconst int * row = columnCopy->getIndices();\n\t\tconst CoinBigIndex * columnStart = columnCopy->getVectorStarts();\n\t\tconst int * columnLength = columnCopy->getVectorLengths();\n\t\t//const double * element = columnCopy->getElements();\n\t\tint n=0;\n\t\tfor (int iColumn = 0;iColumnprimalTolerance_&&\n\t\t\t\t\t\tfabs(value-columnUpper_[iColumn])>primalTolerance_) {\n\t\t\t\t\t\tint iRow = row[columnStart[iColumn]];\n\t\t\t\t\t\tif (getRowStatus(iRow)==basic) {\n\t\t\t\t\t\t\tsetRowStatus(iRow,superBasic);\n\t\t\t\t\t\t\tsetColumnStatus(iColumn,basic);\n\t\t\t\t\t\t\tn++;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tprintf(\"%d costed slacks put in basis\\n\",n);\n\t}\n#endif\n\n\n\n\tif (!startup(ifValuesPass,startFinishOptions)) {\n\n\t\t// Set average theta\n\t\tnonLinearCost_->setAverageTheta(1.0e3);\n\t\tint lastCleaned=0; // last time objective or bounds cleaned up\n\n\t\t// Say no pivot has occurred (for steepest edge and updates)\n\t\tpivotRow_=-2;\n\n\t\t// This says whether to restore things etc\n\t\tint factorType=0;\n\t\tif (problemStatus_<0&&perturbation_<100&&!ifValuesPass) {\n\t\t\tperturb(0);\n\t\t\t// Can't get here if values pass\n\t\t\tassert (!ifValuesPass);\n\t\t\tgutsOfSolution(NULL,NULL);\n\t\t\tif (handler_->logLevel()>2) {\n\t\t\t\thandler_->message(CLP_SIMPLEX_STATUS,messages_)\n\t\t\t\t<printing(sumPrimalInfeasibilities_>0.0)\n\t\t\t\t<printing(sumDualInfeasibilities_>0.0)\n\t\t\t\t<printing(numberDualInfeasibilitiesWithoutFree_\n\t\t\t\t\t\t\t\t message()<clear();\n\t\t\t}\n\n\t\t\tfor (iColumn=0;iColumn<2;iColumn++) {\n\t\t\t\tcolumnArray_[iColumn]->clear();\n\t\t\t}\n\n\n\t\t\t// give matrix (and model costs and bounds a chance to be\n\t\t\t// refreshed (normally null)\n\t\t\tmatrix_->refresh(this);\n\t\t\t// If getting nowhere - why not give it a kick\n#if 1\n\t\t\tif (perturbation_<101&&numberIterations_>2*(numberRows_+numberColumns_)&&(specialOptions_&4)==0\n\t\t\t\t&&initialStatus!=10) {\n\t\t\t\tperturb(1);\n\t\t\t\tmatrix_->rhsOffset(this,true,false);\n\t\t\t}\n#endif\n\n\n\t\t\t// If we have done no iterations - special\n\t\t\tif (lastGoodIteration_==numberIterations_&&factorType)\n\t\t\t\tfactorType=3;\n\t\t\tif (saveModel) {\n\t\t\t\t// Doing sprint\n\t\t\t\tif (sequenceIn_<0||numberIterations_>=stopSprint) {\n\t\t\t\t\tproblemStatus_=-1;\n\t\t\t\t\toriginalModel(saveModel);\n\t\t\t\t\tsaveModel=NULL;\n\t\t\t\t\tif (sequenceIn_<0&&numberIterations_100)\n\t\t\t\t\t\tprimalColumnPivot_->switchOffSprint();\n\t\t\t\t\t//lastSprintIteration=numberIterations_;\n\t\t\t\t\tprintf(\"End small model\\n\");\n\t\t\t\t}\n\t\t\t}\n\n\n\n\n\t\t\t// may factorize, checks if problem finished\n\t\t\tstatusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,ifValuesPass,saveModel);\n\n\n\t\t\tif (initialStatus==10) {\n\n\n\t\t\t\t// cleanup phase\n\t\t\t\tif(initialIterations != numberIterations_) {\n\t\t\t\t\tif (numberDualInfeasibilities_>10000&&numberDualInfeasibilities_>10*initialNegDjs) {\n\t\t\t\t\t\t// getting worse - try perturbing\n\t\t\t\t\t\tif (perturbation_<101&&(specialOptions_&4)==0) {\n\n\t\t\t\t\t\t\tperturb(1);\n\t\t\t\t\t\t\tmatrix_->rhsOffset(this,true,false);\n\t\t\t\t\t\t\tstatusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,ifValuesPass,saveModel);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\n\t\t\t\t\t// save number of negative djs\n\t\t\t\t\tif (!numberPrimalInfeasibilities_)\n\t\t\t\t\t\tinitialNegDjs=numberDualInfeasibilities_;\n\t\t\t\t\t// make sure weight won't be changed\n\t\t\t\t\tif (infeasibilityCost_==1.0e10)\n\t\t\t\t\t\tinfeasibilityCost_=1.000001e10;\n\t\t\t\t}\n\t\t\t}\n\n\n\n\t\t\t// See if sprint says redo because of problems\n\t\t\tif (numberDualInfeasibilities_==-776) {\n\t\t\t\t// Need new set of variables\n\t\t\t\tproblemStatus_=-1;\n\n\t\t\t\toriginalModel(saveModel);\n\n\t\t\t\tsaveModel=NULL;\n\t\t\t\t//lastSprintIteration=numberIterations_;\n\t\t\t\tprintf(\"End small model after\\n\");\n\t\t\t\tstatusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,ifValuesPass,saveModel);\n\t\t\t}\n\n\n\n\t\t\tint numberSprintIterations=0;\n\t\t\tint numberSprintColumns = primalColumnPivot_->numberSprintColumns(numberSprintIterations);\n\n\t\t\tif (problemStatus_==777) {\n\t\t\t\t// problems so do one pass with normal\n\t\t\t\tproblemStatus_=-1;\n\t\t\t\toriginalModel(saveModel);\n\t\t\t\tsaveModel=NULL;\n\t\t\t\t// Skip factorization\n\t\t\t\t//statusOfProblemInPrimal(lastCleaned,factorType,&progress_,false,saveModel);\n\t\t\t\tstatusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,ifValuesPass,saveModel);\n\t\t\t} else if (problemStatus_<0&&!saveModel&&numberSprintColumns&&firstFree_<0) {\n\t\t\t\tint numberSort=0;\n\t\t\t\tint numberFixed=0;\n\t\t\t\tint numberBasic=0;\n\t\t\t\treasonableSprintIteration = numberIterations_ + 100;\n\t\t\t\tint * whichColumns = new int[numberColumns_];\n\t\t\t\tdouble * weight = new double[numberColumns_];\n\t\t\t\tint numberNegative=0;\n\t\t\t\tdouble sumNegative = 0.0;\n\n\t\t\t\t// now massage weight so all basic in plus good djs\n\t\t\t\tfor (iColumn=0;iColumn-1.0e50) {\n\t\t\t\t\t\tnumberNegative++;\n\t\t\t\t\t\tsumNegative -= dj;\n\t\t\t\t\t}\n\t\t\t\t\tweight[iColumn]=dj;\n\t\t\t\t\twhichColumns[iColumn] = iColumn;\n\t\t\t\t}\n\t\t\t\thandler_->message(CLP_SPRINT,messages_)\n\t\t\t\t<lastObjectiveValue-1.0e-7&&sprintPass>5) {\n\t\t\t\t\t// switch off\n\n\t\t\t\t\tprintf(\"Switching off sprint\\n\");\n\t\t\t\t\tprimalColumnPivot_->switchOffSprint();\n\t\t\t\t} else {\n\t\t\t\t\tlastObjectiveValue = objectiveValue()*optimizationDirection_;\n\t\t\t\t\t// sort\n\t\t\t\t\tCoinSort_2(weight,weight+numberColumns_,whichColumns);\n\t\t\t\t\tnumberSort = std::min(numberColumns_-numberFixed,numberBasic+numberSprintColumns);\n\t\t\t\t\t// Sort to make consistent ?\n\t\t\t\t\tstd::sort(whichColumns,whichColumns+numberSort);\n\t\t\t\t\t// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\t\t\t\t\t// FIXME: uncomment\n saveModel = new IClpSimplex(this,numberSort,whichColumns);\n\t\t\t\t\t// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n\t\t\t\t\tdelete [] whichColumns;\n\t\t\t\t\tdelete [] weight;\n\t\t\t\t\t// Skip factorization\n\t\t\t\t\t//statusOfProblemInPrimal(lastCleaned,factorType,&progress_,false,saveModel);\n\t\t\t\t\t//statusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,saveModel);\n\t\t\t\t\tstopSprint = numberIterations_+numberSprintIterations;\n\t\t\t\t\tprintf(\"Sprint with %d columns for %d iterations\\n\",\n\t\t\t\t\t\t numberSprintColumns,numberSprintIterations);\n\t\t\t\t}\n\n\n\t\t\t}\n\n\n\n\t\t\t// Say good factorization\n\t\t\tfactorType=1;\n\n\t\t\t// Say no pivot has occurred (for steepest edge and updates)\n\t\t\tpivotRow_=-2;\n\n\t\t\t// exit if victory declared\n\t\t\tif (problemStatus_>=0)\n\t\t\t\tbreak;\n\n\t\t\t// test for maximum iterations\n\t\t\tif (hitMaximumIterations()||(ifValuesPass==2&&firstFree_<0)) {\n\t\t\t\tproblemStatus_=3;\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tif (firstFree_<0) {\n\t\t\t\tif (ifValuesPass) {\n\t\t\t\t\t// end of values pass\n\t\t\t\t\tifValuesPass=0;\n\t\t\t\t\tint status = eventHandler_->event(ClpEventHandler::endOfValuesPass);\n\t\t\t\t\tif (status>=0) {\n\t\t\t\t\t\tproblemStatus_=5;\n\t\t\t\t\t\tsecondaryStatus_=ClpEventHandler::endOfValuesPass;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\t//#define FEB_TRY\n#ifdef FEB_TRY\n\t\t\t\t\tif (perturbation_<100)\n\t\t\t\t\t\tperturb(0);\n#endif\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Check event\n\t\t\t{\n\t\t\t\tint status = eventHandler_->event(ClpEventHandler::endOfFactorization);\n\t\t\t\tif (status>=0) {\n\t\t\t\t\tproblemStatus_=5;\n\t\t\t\t\tsecondaryStatus_=ClpEventHandler::endOfFactorization;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Iterate\n\t\t\twhileIterating(ifValuesPass ? 1 : 0);\n\t\t}\n\t}\n\t// if infeasible get real values\n\t//printf(\"XXXXY final cost %g\\n\",infeasibilityCost_);\n\tprogress_.initialWeight_=0.0;\n\tif (problemStatus_==1&&secondaryStatus_!=6) {\n\t\tinfeasibilityCost_=0.0;\n\t\tcreateRim(1+4);\n\t\tdelete nonLinearCost_;\n\t\tnonLinearCost_ = new ClpNonLinearCost(this);\n\t\tnonLinearCost_->checkInfeasibilities(0.0);\n\t\tsumPrimalInfeasibilities_=nonLinearCost_->sumInfeasibilities();\n\t\tnumberPrimalInfeasibilities_= nonLinearCost_->numberInfeasibilities();\n\t\t// and get good feasible duals\n\t\tcomputeDuals(NULL);\n\t}\n\t// clean up\n\tunflag();\n\tfinish(startFinishOptions);\n\trestoreData(data);\n\treturn problemStatus_;\n}\n/*\n Reasons to come out:\n -1 iterations etc\n -2 inaccuracy\n -3 slight inaccuracy (and done iterations)\n -4 end of values pass and done iterations\n +0 looks optimal (might be infeasible - but we will investigate)\n +2 looks unbounded\n +3 max iterations\n */\nint\nIClpSimplexPrimal::whileIterating(int valuesOption)\n{\n\t// Say if values pass\n\tint ifValuesPass=(firstFree_>=0) ? 1 : 0;\n\tint returnCode=-1;\n\tint superBasicType=1;\n\tif (valuesOption>1)\n\t\tsuperBasicType=3;\n\t// status stays at -1 while iterating, >=0 finished, -2 to invert\n\t// status -3 to go to top without an invert\n\twhile (problemStatus_==-1) {\n\t\t//#define CLP_DEBUG 1\n#ifdef CLP_DEBUG\n\t\t{\n\t\t\tint i;\n\t\t\t// not [1] as has information\n\t\t\tfor (i=0;i<4;i++) {\n\t\t\t\tif (i!=1)\n\t\t\t\t\trowArray_[i]->checkClear();\n\t\t\t}\n\t\t\tfor (i=0;i<2;i++) {\n\t\t\t\tcolumnArray_[i]->checkClear();\n\t\t\t}\n\t\t}\n#endif\n#if 0\n\t\t{\n\t\t\tint iPivot;\n\t\t\tdouble * array = rowArray_[3]->denseVector();\n\t\t\tint * index = rowArray_[3]->getIndices();\n\t\t\tint i;\n\t\t\tfor (iPivot=0;iPivotupdateColumn(rowArray_[2],rowArray_[3]);\n\t\t\t\tint number = rowArray_[3]->getNumElements();\n\t\t\t\tfor (i=0;iclear();\n\t\t\t}\n\t\t}\n#endif\n#if 0\n\t\tnonLinearCost_->checkInfeasibilities(primalTolerance_);\n\t\tprintf(\"suminf %g number %d\\n\",nonLinearCost_->sumInfeasibilities(),\n\t\t\t nonLinearCost_->numberInfeasibilities());\n#endif\n#if CLP_DEBUG>2\n\t\t// very expensive\n\t\tif (numberIterations_>0&&numberIterations_<100&&!ifValuesPass) {\n\t\t\thandler_->setLogLevel(63);\n\t\t\tdouble saveValue = objectiveValue_;\n\t\t\tdouble * saveRow1 = new double[numberRows_];\n\t\t\tdouble * saveRow2 = new double[numberRows_];\n\t\t\tCoinMemcpyN(rowReducedCost_,numberRows_,saveRow1);\n\t\t\tCoinMemcpyN(rowActivityWork_,numberRows_,saveRow2);\n\t\t\tdouble * saveColumn1 = new double[numberColumns_];\n\t\t\tdouble * saveColumn2 = new double[numberColumns_];\n\t\t\tCoinMemcpyN(reducedCostWork_,numberColumns_,saveColumn1);\n\t\t\tCoinMemcpyN(columnActivityWork_,numberColumns_,saveColumn2);\n\t\t\tgutsOfSolution(NULL,NULL,false);\n\t\t\tprintf(\"xxx %d old obj %g, recomputed %g, sum primal inf %g\\n\",\n\t\t\t\t numberIterations_,\n\t\t\t\t saveValue,objectiveValue_,sumPrimalInfeasibilities_);\n\t\t\tCoinMemcpyN(saveRow1,numberRows_,rowReducedCost_);\n\t\t\tCoinMemcpyN(saveRow2,numberRows_,rowActivityWork_);\n\t\t\tCoinMemcpyN(saveColumn1,numberColumns_,reducedCostWork_);\n\t\t\tCoinMemcpyN(saveColumn2,numberColumns_,columnActivityWork_);\n\t\t\tdelete [] saveRow1;\n\t\t\tdelete [] saveRow2;\n\t\t\tdelete [] saveColumn1;\n\t\t\tdelete [] saveColumn2;\n\t\t\tobjectiveValue_=saveValue;\n\t\t}\n#endif\n\t\tif (!ifValuesPass) {\n\t\t\t// choose column to come in\n\t\t\t// can use pivotRow_ to update weights\n\t\t\t// pass in list of cost changes so can do row updates (rowArray_[1])\n\t\t\t// NOTE rowArray_[0] is used by computeDuals which is a\n\t\t\t// slow way of getting duals but might be used\n\t\t\tprimalColumn(rowArray_[1],rowArray_[2],rowArray_[3],\n\t\t\t\t\t\t columnArray_[0],columnArray_[1]);\n\t\t} else {\n\t\t\t// in values pass\n\t\t\tint sequenceIn=nextSuperBasic(superBasicType,columnArray_[0]);\n\t\t\tif (valuesOption>1)\n\t\t\t\tsuperBasicType=2;\n\t\t\tif (sequenceIn<0) {\n\t\t\t\t// end of values pass - initialize weights etc\n\t\t\t\thandler_->message(CLP_END_VALUES_PASS,messages_)\n\t\t\t\t<saveWeights(this,5);\n\t\t\t\tproblemStatus_=-2; // factorize now\n\t\t\t\tpivotRow_=-1; // say no weights update\n\t\t\t\treturnCode=-4;\n\t\t\t\t// Clean up\n\t\t\t\tint i;\n\t\t\t\tfor (i=0;iclear();\n\t\tif (sequenceIn_>=0) {\n\t\t\t// we found a pivot column\n\t\t\tassert (!flagged(sequenceIn_));\n#ifdef CLP_DEBUG\n\t\t\tif ((handler_->logLevel()&32)) {\n\t\t\t\tchar x = isColumn(sequenceIn_) ? 'C' :'R';\n\t\t\t\tstd::cout<<\"pivot column \"<<\n\t\t\t\tx<=0&&checkSequencecheckClear();\n\t\t\t\t\trowArray_[3]->checkClear();\n\t\t\t\t\tdouble * array = rowArray_[3]->denseVector();\n\t\t\t\t\tint * index = rowArray_[3]->getIndices();\n\t\t\t\t\tunpackPacked(rowArray_[3],checkSequence);\n\t\t\t\t\tfactorization_->updateColumnForDebug(rowArray_[2],rowArray_[3]);\n\t\t\t\t\tint number = rowArray_[3]->getNumElements();\n\t\t\t\t\tdouble dualIn = cost_[checkSequence];\n\t\t\t\t\tint i;\n\t\t\t\t\tfor (i=0;iclear();\n\t\t\t\t\tif (numberIterations_>2000)\n\t\t\t\t\t\texit(1);\n\t\t\t\t}\n\t\t\t}\n#endif\n\t\t\t// do second half of iteration\n\t\t\treturnCode = pivotResult(ifValuesPass);\n\t\t\tif (returnCode<-1&&returnCode>-5) {\n\t\t\t\tproblemStatus_=-2; //\n\t\t\t} else if (returnCode==-5) {\n\t\t\t\tif ((moreSpecialOptions_&16)==0&&factorization_->pivots()) {\n\t\t\t\t\tmoreSpecialOptions_ |= 16;\n\t\t\t\t\tproblemStatus_=-2;\n\t\t\t\t}\n\t\t\t\t// otherwise something flagged - continue;\n\t\t\t} else if (returnCode==2) {\n\t\t\t\tproblemStatus_=-5; // looks unbounded\n\t\t\t} else if (returnCode==4) {\n\t\t\t\tproblemStatus_=-2; // looks unbounded but has iterated\n\t\t\t} else if (returnCode!=-1) {\n\t\t\t\tassert(returnCode==3);\n\t\t\t\tif (problemStatus_!=5)\n\t\t\t\t\tproblemStatus_=3;\n\t\t\t}\n\t\t} else {\n\t\t\t// no pivot column\n#ifdef CLP_DEBUG\n\t\t\tif (handler_->logLevel()&32)\n\t\t\t\tprintf(\"** no column pivot\\n\");\n#endif\n\t\t\tif (nonLinearCost_->numberInfeasibilities())\n\t\t\t\tproblemStatus_=-4; // might be infeasible\n\t\t\t// Force to re-factorize early next time\n\t\t\tint numberPivots = factorization_->pivots();\n\t\t\tforceFactorization_=std::min(forceFactorization_,(numberPivots+1)>>1);\n\t\t\treturnCode=0;\n\t\t\tbreak;\n\t\t}\n\t}\n\tif (valuesOption>1)\n\t\tcolumnArray_[0]->setNumElements(0);\n\treturn returnCode;\n}\n/* Checks if finished. Updates status */\nvoid\nIClpSimplexPrimal::statusOfProblemInPrimal(int & lastCleaned,int type,\n\t\t\t\t\t\t\t\t\t\t\t\t ClpSimplexProgress * progress,\n\t\t\t\t\t\t\t\t\t\t\t\t bool doFactorization,\n\t\t\t\t\t\t\t\t\t\t\t\t int ifValuesPass,\n\t\t\t\t\t\t\t\t\t\t\t\t IClpSimplex * originalModel)\n{\n\tint dummy; // for use in generalExpanded\n\tint saveFirstFree=firstFree_;\n\t// number of pivots done\n\tint numberPivots = factorization_->pivots();\n\tif (type==2) {\n\t\t// trouble - restore solution\n\t\tCoinMemcpyN(saveStatus_,numberColumns_+numberRows_,status_);\n\t\tCoinMemcpyN(savedSolution_+numberColumns_ ,\n\t\t\t\t\tnumberRows_,rowActivityWork_);\n\t\tCoinMemcpyN(savedSolution_ ,\n\t\t\t\t\tnumberColumns_,columnActivityWork_);\n\t\t// restore extra stuff\n\t\tmatrix_->generalExpanded(this,6,dummy);\n\t\tforceFactorization_=1; // a bit drastic but ..\n\t\tpivotRow_=-1; // say no weights update\n\t\tchangeMade_++; // say change made\n\t}\n\n\tint saveThreshold = factorization_->sparseThreshold();\n\tint tentativeStatus = problemStatus_;\n\tint numberThrownOut=1; // to loop round on bad factorization in values pass\n\tdouble lastSumInfeasibility=COIN_DBL_MAX;\n\tif (numberIterations_)\n\t\tlastSumInfeasibility=nonLinearCost_->sumInfeasibilities();\n\tint nPass=0;\n\twhile (numberThrownOut) {\n\n\t\tint nSlackBasic=0;\n\t\tif (nPass) {\n\t\t\tfor (int i=0;i-3||problemStatus_==-4) {\n\t\t\t// factorize\n\t\t\t// later on we will need to recover from singularities\n\t\t\t// also we could skip if first time\n\t\t\t// do weights\n\t\t\t// This may save pivotRow_ for use\n\t\t\tif (doFactorization)\n\t\t\t\tprimalColumnPivot_->saveWeights(this,1);\n\n\t\t\tif ((type&&doFactorization)||nSlackBasic==numberRows_) {\n\t\t\t\t// is factorization okay?\n\t\t\t\tint factorStatus = internalFactorize(1);\n\n\t\t\t\tif (factorStatus) {\n\t\t\t\t\tif (solveType_==2+8) {\n\t\t\t\t\t\t// say odd\n\t\t\t\t\t\tproblemStatus_=5;\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tif (type!=1||largestPrimalError_>1.0e3\n\t\t\t\t\t\t||largestDualError_>1.0e3) {\n\t\t\t\t\t\t// switch off dense\n\t\t\t\t\t\tint saveDense = factorization_->denseThreshold();\n\n\t\t\t\t\t\tfactorization_->setDenseThreshold(0);\n\t\t\t\t\t\t// Go to safe\n\t\t\t\t\t\tfactorization_->pivotTolerance(0.99);\n\t\t\t\t\t\t// make sure will do safe factorization\n\t\t\t\t\t\tpivotVariable_[0]=-1;\n\t\t\t\t\t\tinternalFactorize(2);\n\t\t\t\t\t\tfactorization_->setDenseThreshold(saveDense);\n\t\t\t\t\t\t// restore extra stuff\n\t\t\t\t\t\tmatrix_->generalExpanded(this,6,dummy);\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// no - restore previous basis\n\t\t\t\t\t\t// Keep any flagged variables\n\n\t\t\t\t\t\tint i;\n\t\t\t\t\t\tfor (i=0;i=0&&getStatus(sequenceIn_)!=basic) {\n\t\t\t\t\t\t\t\tsetFlagged(sequenceIn_);\n\t\t\t\t\t\t\t} else if (sequenceOut_>=0&&getStatus(sequenceOut_)!=basic) {\n\t\t\t\t\t\t\t\tsetFlagged(sequenceOut_);\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tdouble newTolerance = std::max(0.5 + 0.499*randomNumberGenerator_.randomDouble(),factorization_->pivotTolerance());\n\t\t\t\t\t\t\tfactorization_->pivotTolerance(newTolerance);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// Go to safe\n\t\t\t\t\t\t\tfactorization_->pivotTolerance(0.99);\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tCoinMemcpyN(savedSolution_+numberColumns_ ,\n\t\t\t\t\t\t\t\t\tnumberRows_,rowActivityWork_);\n\t\t\t\t\t\tCoinMemcpyN(savedSolution_ ,\n\t\t\t\t\t\t\t\t\tnumberColumns_,columnActivityWork_);\n\t\t\t\t\t\t// restore extra stuff\n\t\t\t\t\t\tmatrix_->generalExpanded(this,6,dummy);\n\t\t\t\t\t\tmatrix_->generalExpanded(this,5,dummy);\n\n\t\t\t\t\t\tforceFactorization_=1; // a bit drastic but ..\n\t\t\t\t\t\ttype = 2;\n\t\t\t\t\t\tif (internalFactorize(2)!=0) {\n\t\t\t\t\t\t\tlargestPrimalError_=1.0e4; // force other type\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tchangeMade_++; // say change made\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (problemStatus_!=-4)\n\t\t\t\tproblemStatus_=-3;\n\t\t}\n\n\t\t// at this stage status is -3 or -5 if looks unbounded\n\t\t// get primal and dual solutions\n\t\t// put back original costs and then check\n\t\t// createRim(4); // costs do not change\n\t\t// May need to do more if column generation\n\t\tdummy=4;\n\t\tmatrix_->generalExpanded(this,9,dummy);\n\t\tnumberThrownOut=gutsOfSolution(NULL,NULL,(firstFree_>=0));\n\t\tdouble sumInfeasibility = nonLinearCost_->sumInfeasibilities();\n\t\tif (numberThrownOut||\n\t\t\t(sumInfeasibility>1.0e7&&sumInfeasibility>100.0*lastSumInfeasibility\n\t\t\t &&factorization_->pivotTolerance()<0.11)||(largestPrimalError_>1.0e10&&largestDualError_>1.0e10)) {\n\t\t\t\tproblemStatus_=tentativeStatus;\n\t\t\t\tdoFactorization=true;\n\t\t\t\tif (numberPivots) {\n\t\t\t\t\t// go back\n\t\t\t\t\tnumberThrownOut=-1;\n\t\t\t\t\t// trouble - restore solution\n\t\t\t\t\tCoinMemcpyN(saveStatus_,numberColumns_+numberRows_,status_);\n\t\t\t\t\tCoinMemcpyN(savedSolution_+numberColumns_ ,\n\t\t\t\t\t\t\t\tnumberRows_,rowActivityWork_);\n\t\t\t\t\tCoinMemcpyN(savedSolution_ ,\n\t\t\t\t\t\t\t\tnumberColumns_,columnActivityWork_);\n\t\t\t\t\t// restore extra stuff\n\t\t\t\t\tmatrix_->generalExpanded(this,6,dummy);\n\t\t\t\t\tforceFactorization_=1; // a bit drastic but ..\n\t\t\t\t\t// Go to safe\n\t\t\t\t\tfactorization_->pivotTolerance(0.99);\n\t\t\t\t\tpivotRow_=-1; // say no weights update\n\t\t\t\t\tchangeMade_++; // say change made\n\t\t\t\t\tif (numberPivots==1) {\n\t\t\t\t\t\t// throw out something\n\t\t\t\t\t\tif (sequenceIn_>=0&&getStatus(sequenceIn_)!=basic) {\n\t\t\t\t\t\t\tsetFlagged(sequenceIn_);\n\t\t\t\t\t\t} else if (sequenceOut_>=0&&getStatus(sequenceOut_)!=basic) {\n\t\t\t\t\t\t\tsetFlagged(sequenceOut_);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tnumberPivots=0;\n\t\t\t\t}\n\t\t\t}\n\t}\n\n\t// Double check reduced costs if no action\n\tif (progress->lastIterationNumber(0)==numberIterations_) {\n\t\tif (primalColumnPivot_->looksOptimal()) {\n\t\t\tnumberDualInfeasibilities_ = 0;\n\t\t\tsumDualInfeasibilities_ = 0.0;\n\t\t}\n\t}\n\t// If in primal and small dj give up\n\tif ((specialOptions_&1024)!=0&&!numberPrimalInfeasibilities_&&numberDualInfeasibilities_) {\n\t\tdouble average = sumDualInfeasibilities_/(static_cast (numberDualInfeasibilities_));\n\t\tif (numberIterations_>300&&average<1.0e-4) {\n\t\t\tnumberDualInfeasibilities_ = 0;\n\t\t\tsumDualInfeasibilities_ = 0.0;\n\t\t}\n\t}\n\n\t// Check if looping\n\tint loop;\n\tif (type!=2&&!ifValuesPass)\n\t\tloop = progress->looping();\n\telse\n\t\tloop=-1;\n\tif (loop>=0) {\n\t\tif (!problemStatus_) {\n\t\t\t// declaring victory\n\t\t\tnumberPrimalInfeasibilities_ = 0;\n\t\t\tsumPrimalInfeasibilities_ = 0.0;\n\t\t} else {\n\t\t\tproblemStatus_ = loop; //exit if in loop\n\t\t\tproblemStatus_ = 10; // instead - try other algorithm\n\t\t\tnumberPrimalInfeasibilities_ = nonLinearCost_->numberInfeasibilities();\n\t\t}\n\t\tproblemStatus_ = 10; // instead - try other algorithm\n\t\treturn ;\n\t} else if (loop<-1) {\n\t\t// Is it time for drastic measures\n\t\tif (nonLinearCost_->numberInfeasibilities()&&progress->badTimes()>5&&\n\t\t\tprogress->oddState()<10&&progress->oddState()>=0) {\n\t\t\tprogress->newOddState();\n\t\t\tnonLinearCost_->zapCosts();\n\t\t}\n\t\t// something may have changed\n\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t}\n\t// If progress then reset costs\n\tif (loop==-1&&!nonLinearCost_->numberInfeasibilities()&&progress->oddState()<0) {\n\t\tcreateRim(4,false); // costs back\n\t\tdelete nonLinearCost_;\n\t\tnonLinearCost_ = new ClpNonLinearCost(this);\n\t\tprogress->endOddState();\n\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t}\n\t// Flag to say whether to go to dual to clean up\n\tbool goToDual=false;\n\t// really for free variables in\n\t//if((progressFlag_&2)!=0)\n\t//problemStatus_=-1;;\n\tprogressFlag_ = 0; //reset progress flag\n\n\thandler_->message(CLP_SIMPLEX_STATUS,messages_)\n <feasibleReportCost();\n\thandler_->printing(nonLinearCost_->numberInfeasibilities()>0)\n <sumInfeasibilities()<numberInfeasibilities();\n\thandler_->printing(sumDualInfeasibilities_>0.0)\n <printing(numberDualInfeasibilitiesWithoutFree_\n\t\t\t\t\t message()<checkInfeasibilities(primalTolerance_);\n\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t\tnonLinearCost_->checkInfeasibilities(primalTolerance_);\n\t}\n\tif (nonLinearCost_->numberInfeasibilities()>0&&!progress->initialWeight_&&!ifValuesPass&&infeasibilityCost_==1.0e10) {\n\t\t// first time infeasible - start up weight computation\n\t\tdouble * oldDj = dj_;\n\t\tdouble * oldCost = cost_;\n\t\tint numberRows2 = numberRows_+numberExtraRows_;\n\t\tint numberTotal = numberRows2+numberColumns_;\n\t\tdj_ = new double[numberTotal];\n\t\tcost_ = new double[numberTotal];\n\t\treducedCostWork_ = dj_;\n\t\trowReducedCost_ = dj_+numberColumns_;\n\t\tobjectiveWork_ = cost_;\n\t\trowObjectiveWork_ = cost_+numberColumns_;\n\t\tdouble direction = optimizationDirection_*objectiveScale_;\n\t\tconst double * obj = objective();\n\t\tmemset(rowObjectiveWork_,0,numberRows_*sizeof(double));\n\t\tint iSequence;\n\t\tif (columnScale_)\n\t\t\tfor (iSequence=0;iSequenceprimalTolerance_) {\n\t\t\t\t\t// Check if \"free\"\n\t\t\t\t\tif (distanceDown>primalTolerance_) {\n\t\t\t\t\t\t// free\n\t\t\t\t\t\tif (value>dualTolerance_) {\n\t\t\t\t\t\t\tnumberFreeSame++;\n\t\t\t\t\t\t} else if(value<-dualTolerance_) {\n\t\t\t\t\t\t\tnumberFreeDifferent++;\n\t\t\t\t\t\t\tdj_[n++] = feasibleDj/infeasibleDj;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tnumberFreeZero++;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// should not be negative\n\t\t\t\t\t\tif (value>dualTolerance_) {\n\t\t\t\t\t\t\tnumberSame++;\n\t\t\t\t\t\t} else if(value<-dualTolerance_) {\n\t\t\t\t\t\t\tnumberDifferent++;\n\t\t\t\t\t\t\tdj_[n++] = feasibleDj/infeasibleDj;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tnumberZero++;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else if (distanceDown>primalTolerance_) {\n\t\t\t\t\t// should not be positive\n\t\t\t\t\tif (value>dualTolerance_) {\n\t\t\t\t\t\tnumberSame++;\n\t\t\t\t\t} else if(value<-dualTolerance_) {\n\t\t\t\t\t\tnumberDifferent++;\n\t\t\t\t\t\tdj_[n++] = feasibleDj/infeasibleDj;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tnumberZero++;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tprogress->initialWeight_=-1.0;\n\t\t}\n\t\t//printf(\"XXXX %d same, %d different, %d zero, -- free %d %d %d\\n\",\n\t\t// numberSame,numberDifferent,numberZero,\n\t\t// numberFreeSame,numberFreeDifferent,numberFreeZero);\n\t\t// we want most to be same\n\t\tif (n) {\n\t\t\tdouble most = 0.95;\n\t\t\tstd::sort(dj_,dj_+n);\n\t\t\tint which = static_cast ((1.0-most)*static_cast (n));\n\t\t\tdouble take = -dj_[which]*infeasibilityCost_;\n\t\t\t//printf(\"XXXXZ inf cost %g take %g (range %g %g)\\n\",infeasibilityCost_,take,-dj_[0]*infeasibilityCost_,-dj_[n-1]*infeasibilityCost_);\n\t\t\ttake = -dj_[0]*infeasibilityCost_;\n\t\t\tinfeasibilityCost_ = std::min(std::max(1000.0*take,1.0e8),1.0000001e10);;\n\t\t\t//printf(\"XXXX increasing weight to %g\\n\",infeasibilityCost_);\n\t\t}\n\t\tdelete [] dj_;\n\t\tdelete [] cost_;\n\t\tdj_= oldDj;\n\t\tcost_ = oldCost;\n\t\treducedCostWork_ = dj_;\n\t\trowReducedCost_ = dj_+numberColumns_;\n\t\tobjectiveWork_ = cost_;\n\t\trowObjectiveWork_ = cost_+numberColumns_;\n\t\tif (n)\n\t\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t}\n\tdouble trueInfeasibility =nonLinearCost_->sumInfeasibilities();\n\tif (!nonLinearCost_->numberInfeasibilities()&&infeasibilityCost_==1.0e10&&!ifValuesPass&&true) {\n\t\t// relax if default\n\t\tinfeasibilityCost_ = std::min(std::max(100.0*sumDualInfeasibilities_,1.0e8),1.00000001e10);\n\t\t// reset looping criterion\n\t\tprogress->reset();\n\t\ttrueInfeasibility = 1.123456e10;\n\t}\n\tif (trueInfeasibility>1.0) {\n\t\t// If infeasibility going up may change weights\n\t\tdouble testValue = trueInfeasibility-1.0e-4*(10.0+trueInfeasibility);\n\t\tdouble lastInf = progress->lastInfeasibility(1);\n\t\tdouble lastInf3 = progress->lastInfeasibility(3);\n\t\tdouble thisObj = progress->lastObjective(0);\n\t\tdouble thisInf = progress->lastInfeasibility(0);\n\t\tthisObj += infeasibilityCost_*2.0*thisInf;\n\t\tdouble lastObj = progress->lastObjective(1);\n\t\tlastObj += infeasibilityCost_*2.0*lastInf;\n\t\tdouble lastObj3 = progress->lastObjective(3);\n\t\tlastObj3 += infeasibilityCost_*2.0*lastInf3;\n\t\tif (lastObjlogLevel()==63)\n\t\t\t\tprintf(\"lastobj %g this %g force %d \",lastObj,thisObj,forceFactorization_);\n\t\t\tint maxFactor = factorization_->maximumPivots();\n\t\t\tif (maxFactor>10) {\n\t\t\t\tif (forceFactorization_<0)\n\t\t\t\t\tforceFactorization_= maxFactor;\n\t\t\t\tforceFactorization_ = std::max(1,(forceFactorization_>>2));\n\t\t\t\tif (handler_->logLevel()==63)\n\t\t\t\t\tprintf(\"Reducing factorization frequency to %d\\n\",forceFactorization_);\n\t\t\t}\n\t\t} else if (lastObj3logLevel()==63)\n\t\t\t\tprintf(\"lastobj3 %g this3 %g `force %d \",lastObj3,thisObj,forceFactorization_);\n\t\t\tint maxFactor = factorization_->maximumPivots();\n\t\t\tif (maxFactor>10) {\n\t\t\t\tif (forceFactorization_<0)\n\t\t\t\t\tforceFactorization_= maxFactor;\n\t\t\t\tforceFactorization_ = std::max(1,(forceFactorization_*2)/3);\n\t\t\t\tif (handler_->logLevel()==63)\n\t\t\t\t\tprintf(\"Reducing factorization frequency to %d\\n\",forceFactorization_);\n\t\t\t}\n\t\t} else if(lastInfreset();\n\t\t\t\tif (handler_->logLevel()==63)\n\t\t\t\t\tprintf(\"increasing weight to %g\\n\",infeasibilityCost_);\n\t\t\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t\t\t}\n\t\t}\n\t}\n\t// we may wish to say it is optimal even if infeasible\n\tbool alwaysOptimal = (specialOptions_&1)!=0;\n\t// give code benefit of doubt\n\tif (sumOfRelaxedDualInfeasibilities_ == 0.0&&\n\t\tsumOfRelaxedPrimalInfeasibilities_ == 0.0) {\n\t\t// say optimal (with these bounds etc)\n\t\tnumberDualInfeasibilities_ = 0;\n\t\tsumDualInfeasibilities_ = 0.0;\n\t\tnumberPrimalInfeasibilities_ = 0;\n\t\tsumPrimalInfeasibilities_ = 0.0;\n\t\t// But check if in sprint\n\t\tif (originalModel) {\n\t\t\t// Carry on and re-do\n\t\t\tnumberDualInfeasibilities_ = -776;\n\t\t}\n\t\t// But if real primal infeasibilities nonzero carry on\n\t\tif (nonLinearCost_->numberInfeasibilities()) {\n\t\t\t// most likely to happen if infeasible\n\t\t\tdouble relaxedToleranceP=primalTolerance_;\n\t\t\t// we can't really trust infeasibilities if there is primal error\n\t\t\tdouble error = std::min(1.0e-2,largestPrimalError_);\n\t\t\t// allow tolerance at least slightly bigger than standard\n\t\t\trelaxedToleranceP = relaxedToleranceP + error;\n\t\t\tint ninfeas = nonLinearCost_->numberInfeasibilities();\n\t\t\tdouble sum = nonLinearCost_->sumInfeasibilities();\n\t\t\tdouble average = sum/ static_cast (ninfeas);\n#ifdef COIN_DEVELOP\n\t\t\tif (handler_->logLevel()>0)\n\t\t\t\tprintf(\"nonLinearCost says infeasible %d summing to %g\\n\",\n\t\t\t\t\t ninfeas,sum);\n#endif\n\t\t\tif (average>relaxedToleranceP) {\n\t\t\t\tsumOfRelaxedPrimalInfeasibilities_ = sum;\n\t\t\t\tnumberPrimalInfeasibilities_ = ninfeas;\n\t\t\t\tsumPrimalInfeasibilities_ = sum;\n#ifdef COIN_DEVELOP\n\t\t\t\tbool unflagged =\n#endif\n\t\t\t\tunflag();\n#ifdef COIN_DEVELOP\n\t\t\t\tif (unflagged&&handler_->logLevel()>0)\n\t\t\t\t\tprintf(\" - but flagged variables\\n\");\n#endif\n\t\t\t}\n\t\t}\n\t}\n\t// had ||(type==3&&problemStatus_!=-5) -- ??? why ????\n\tif ((dualFeasible()||problemStatus_==-4)&&!ifValuesPass) {\n\t\t// see if extra helps\n\t\tif (nonLinearCost_->numberInfeasibilities()&&\n\t\t\t(nonLinearCost_->sumInfeasibilities()>1.0e-3||sumOfRelaxedPrimalInfeasibilities_)\n\t\t\t&&!alwaysOptimal) {\n\t\t\t//may need infeasiblity cost changed\n\t\t\t// we can see if we can construct a ray\n\t\t\t// make up a new objective\n\t\t\tdouble saveWeight = infeasibilityCost_;\n\t\t\t// save nonlinear cost as we are going to switch off costs\n\t\t\tClpNonLinearCost * nonLinear = nonLinearCost_;\n\t\t\t// do twice to make sure Primal solution has settled\n\t\t\t// put non-basics to bounds in case tolerance moved\n\t\t\t// put back original costs\n\t\t\tcreateRim(4);\n\t\t\tnonLinearCost_->checkInfeasibilities(0.0);\n\t\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\n\t\t\tinfeasibilityCost_=1.0e100;\n\t\t\t// put back original costs\n\t\t\tcreateRim(4);\n\t\t\tnonLinearCost_->checkInfeasibilities(primalTolerance_);\n\t\t\t// may have fixed infeasibilities - double check\n\t\t\tif (nonLinearCost_->numberInfeasibilities()==0) {\n\t\t\t\t// carry on\n\t\t\t\tproblemStatus_ = -1;\n\t\t\t\tinfeasibilityCost_=saveWeight;\n\t\t\t\tnonLinearCost_->checkInfeasibilities(primalTolerance_);\n\t\t\t} else {\n\t\t\t\tnonLinearCost_=NULL;\n\t\t\t\t// scale\n\t\t\t\tint i;\n\t\t\t\tfor (i=0;i=1.0e18||\n\t\t\t\t\t numberDualInfeasibilities_==0)&&perturbation_==101) {\n\t\t\t\t\tgoToDual=unPerturb(); // stop any further perturbation\n\t\t\t\t\tif (nonLinearCost_->sumInfeasibilities()>1.0e-1)\n\t\t\t\t\t\tgoToDual=false;\n\t\t\t\t\tnonLinearCost_->checkInfeasibilities(primalTolerance_);\n\t\t\t\t\tnumberDualInfeasibilities_=1; // carry on\n\t\t\t\t\tproblemStatus_=-1;\n\t\t\t\t} else if (numberDualInfeasibilities_==0&&largestDualError_>1.0e-2) {\n\t\t\t\t\tgoToDual=true;\n\t\t\t\t\tfactorization_->pivotTolerance(std::max(0.9,factorization_->pivotTolerance()));\n\t\t\t\t}\n\t\t\t\tif (!goToDual) {\n\t\t\t\t\tif (infeasibilityCost_>=1.0e20||\n\t\t\t\t\t\tnumberDualInfeasibilities_==0) {\n\t\t\t\t\t\t// we are infeasible - use as ray\n\t\t\t\t\t\tdelete [] ray_;\n\t\t\t\t\t\tray_ = new double [numberRows_];\n\t\t\t\t\t\tCoinMemcpyN(dual_,numberRows_,ray_);\n\t\t\t\t\t\t// and get feasible duals\n\t\t\t\t\t\tinfeasibilityCost_=0.0;\n\t\t\t\t\t\tcreateRim(4);\n\t\t\t\t\t\tnonLinearCost_->checkInfeasibilities(primalTolerance_);\n\t\t\t\t\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t\t\t\t\t\t// so will exit\n\t\t\t\t\t\tinfeasibilityCost_=1.0e30;\n\t\t\t\t\t\t// reset infeasibilities\n\t\t\t\t\t\tsumPrimalInfeasibilities_=nonLinearCost_->sumInfeasibilities();;\n\t\t\t\t\t\tnumberPrimalInfeasibilities_=\n\t\t\t\t\t\tnonLinearCost_->numberInfeasibilities();\n\t\t\t\t\t}\n\t\t\t\t\tif (infeasibilityCost_<1.0e20) {\n\t\t\t\t\t\tinfeasibilityCost_ *= 5.0;\n\t\t\t\t\t\t// reset looping criterion\n\t\t\t\t\t\tprogress->reset();\n\t\t\t\t\t\tchangeMade_++; // say change made\n\t\t\t\t\t\thandler_->message(CLP_PRIMAL_WEIGHT,messages_)\n\t\t\t\t\t\t<checkInfeasibilities(0.0);\n\t\t\t\t\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t\t\t\t\t\tproblemStatus_=-1; //continue\n\t\t\t\t\t\tgoToDual=false;\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// say infeasible\n\t\t\t\t\t\tproblemStatus_ = 1;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\t// may be optimal\n\t\t\tif (perturbation_==101) {\n\t\t\t\tgoToDual=unPerturb(); // stop any further perturbation\n\t\t\t\tif (numberRows_>20000&&!numberTimesOptimal_)\n\t\t\t\t\tgoToDual=0; // Better to carry on a bit longer\n\t\t\t\tlastCleaned=-1; // carry on\n\t\t\t}\n\t\t\tbool unflagged = (unflag()!=0);\n\t\t\tif ( lastCleaned!=numberIterations_||unflagged) {\n\t\t\t\thandler_->message(CLP_PRIMAL_OPTIMAL,messages_)\n\t\t\t\t<zeroTolerance(std::min(factorization_->zeroTolerance(),1.0e-15));\n\t\t\t\t\t}\n\t\t\t\t\tlastCleaned=numberIterations_;\n\t\t\t\t\tif (primalTolerance_!=dblParam_[ClpPrimalTolerance])\n\t\t\t\t\t\thandler_->message(CLP_PRIMAL_ORIGINAL,messages_)\n\t\t\t\t\t\t<checkInfeasibilities(oldTolerance);\n#if 0\n\t\t\t\t\tint i;\n\t\t\t\t\tfor (i=0;inumberInfeasibilities()&&lastCleaned>=0)\n\t\t\t\t\t\tproblemStatus_=0;\n\t\t\t\t\telse\n\t\t\t\t\t\tproblemStatus_ = -1;\n\t\t\t\t} else {\n\t\t\t\t\tproblemStatus_=0; // optimal\n\t\t\t\t\tif (lastCleanedmessage(CLP_SIMPLEX_GIVINGUP,messages_)\n\t\t\t\t\t\t<numberInfeasibilities()) {\n\t\t\t\tif (infeasibilityCost_>1.0e18&&perturbation_==101) {\n\t\t\t\t\t// back off weight\n\t\t\t\t\tinfeasibilityCost_ = 1.0e13;\n\t\t\t\t\t// reset looping criterion\n\t\t\t\t\tprogress->reset();\n\t\t\t\t\tunPerturb(); // stop any further perturbation\n\t\t\t\t}\n\t\t\t\t//we need infeasiblity cost changed\n\t\t\t\tif (infeasibilityCost_<1.0e20) {\n\t\t\t\t\tinfeasibilityCost_ *= 5.0;\n\t\t\t\t\t// reset looping criterion\n\t\t\t\t\tprogress->reset();\n\t\t\t\t\tchangeMade_++; // say change made\n\t\t\t\t\thandler_->message(CLP_PRIMAL_WEIGHT,messages_)\n\t\t\t\t\t< (numberDualInfeasibilities_))<1.0e-5||\n\t\t\t\t\tprogress->lastIterationNumber(0)==numberIterations_) {\n\t\t\t\t\tif (!numberPrimalInfeasibilities_) {\n\t\t\t\t\t\tif (numberTimesOptimal_<4) {\n\t\t\t\t\t\t\tnumberTimesOptimal_++;\n\t\t\t\t\t\t\tchangeMade_++; // say change made\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tproblemStatus_=0;\n\t\t\t\t\t\t\tsecondaryStatus_=5;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tif (problemStatus_==0) {\n\t\tdouble objVal = nonLinearCost_->feasibleCost();\n\t\tdouble tol = 1.0e-10*std::max(fabs(objVal),fabs(objectiveValue_))+1.0e-8;\n\t\tif (fabs(objVal-objectiveValue_)>tol) {\n#ifdef COIN_DEVELOP\n\t\t\tif (handler_->logLevel()>0)\n\t\t\t\tprintf(\"nonLinearCost has feasible obj of %g, objectiveValue_ is %g\\n\",\n\t\t\t\t\t objVal,objectiveValue_);\n#endif\n\t\t\tobjectiveValue_ = objVal;\n\t\t}\n\t}\n\t// save extra stuff\n\tmatrix_->generalExpanded(this,5,dummy);\n\tif (type==0||type==1) {\n\t\tif (type!=1||!saveStatus_) {\n\t\t\t// create save arrays\n\t\t\tdelete [] saveStatus_;\n\t\t\tdelete [] savedSolution_;\n\t\t\tsaveStatus_ = new unsigned char [numberRows_+numberColumns_];\n\t\t\tsavedSolution_ = new double [numberRows_+numberColumns_];\n\t\t}\n\t\t// save arrays\n\t\tCoinMemcpyN(status_,numberColumns_+numberRows_,saveStatus_);\n\t\tCoinMemcpyN(rowActivityWork_,\n\t\t\t\t\tnumberRows_,savedSolution_+numberColumns_);\n\t\tCoinMemcpyN(columnActivityWork_,numberColumns_,savedSolution_);\n\t}\n\t// see if in Cbc etc\n\tbool inCbcOrOther = (specialOptions_&0x03000000)!=0;\n\tbool disaster=false;\n\tif (disasterArea_&&inCbcOrOther&&disasterArea_->check()) {\n\t\tdisasterArea_->saveInfo();\n\t\tdisaster=true;\n\t}\n\tif (disaster)\n\t\tproblemStatus_=3;\n\tif (problemStatus_<0&&!changeMade_) {\n\t\tproblemStatus_=4; // unknown\n\t}\n\tlastGoodIteration_ = numberIterations_;\n\tif (numberIterations_>lastBadIteration_+100)\n\t\tmoreSpecialOptions_ &= ~16; // clear check accuracy flag\n\tif (goToDual)\n\t\tproblemStatus_=10; // try dual\n\t// make sure first free monotonic\n\tif (firstFree_>=0&&saveFirstFree>=0) {\n\t\tfirstFree_=saveFirstFree;\n\t\tnextSuperBasic(1,NULL);\n\t}\n\tif (doFactorization) {\n\t\t// restore weights (if saved) - also recompute infeasibility list\n\t\tif (tentativeStatus>-3)\n\t\t\tprimalColumnPivot_->saveWeights(this,(type <2) ? 2 : 4);\n\t\telse\n\t\t\tprimalColumnPivot_->saveWeights(this,3);\n\t\tif (saveThreshold) {\n\t\t\t// use default at present\n\t\t\tfactorization_->sparseThreshold(0);\n\t\t\tfactorization_->goSparse();\n\t\t}\n\t}\n\t// Allow matrices to be sorted etc\n\tint fake=-999; // signal sort\n\tmatrix_->correctSequence(this,fake,fake);\n}\n\n// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\nvoid\nIClpSimplexPrimal::primalRow(CoinIndexedVector * rowArray,\n\t\t\t\t\t\t\t\t CoinIndexedVector * rhsArray,\n\t\t\t\t\t\t\t\t CoinIndexedVector * spareArray,\n\t\t\t\t\t\t\t\t CoinIndexedVector * spareArray2,\n\t\t\t\t\t\t\t\t int valuesPass)\n{\n\tDantzigPrimalRow(rowArray, rhsArray, spareArray, spareArray2, valuesPass);\n\t//import_CyClpSimplex();\n\t//CyPostPrimalRow(static_cast(this));\n}\n/*\n Row array has pivot column\n This chooses pivot row.\n For speed, we may need to go to a bucket approach when many\n variables go through bounds\n On exit rhsArray will have changes in costs of basic variables\n */\nvoid\nIClpSimplexPrimal::DantzigPrimalRow(CoinIndexedVector * rowArray,\n\t\t\t\t\t\t\t\t CoinIndexedVector * rhsArray,\n\t\t\t\t\t\t\t\t CoinIndexedVector * spareArray,\n\t\t\t\t\t\t\t\t CoinIndexedVector * spareArray2,\n\t\t\t\t\t\t\t\t int valuesPass)\n{\n\tdouble saveDj = dualIn_;\n\tif (valuesPass&&objective_->type()<2) {\n\t\tdualIn_ = cost_[sequenceIn_];\n\n\t\tdouble * work=rowArray->denseVector();\n\t\tint number=rowArray->getNumElements();\n\t\tint * which=rowArray->getIndices();\n\n\t\tint iIndex;\n\t\tfor (iIndex=0;iIndexdualTolerance_) {\n\t\t\tdirectionIn_=-1;\n\t\t} else {\n\t\t\t// towards nearest bound\n\t\t\tif (valueIn_-lowerIn_100)\n\t\tacceptablePivot=acceptablePivot_;\n\tif (factorization_->pivots()>10)\n\t\tacceptablePivot=1.0e+3*acceptablePivot_; // if we have iterated be more strict\n\telse if (factorization_->pivots()>5)\n\t\tacceptablePivot=1.0e+2*acceptablePivot_; // if we have iterated be slightly more strict\n\telse if (factorization_->pivots())\n\t\tacceptablePivot=acceptablePivot_; // relax\n\tdouble bestEverPivot=acceptablePivot;\n\tint lastPivotRow = -1;\n\tdouble lastPivot=0.0;\n\tdouble lastTheta=1.0e50;\n\n\t// use spareArrays to put ones looked at in\n\t// First one is list of candidates\n\t// We could compress if we really know we won't need any more\n\t// Second array has current set of pivot candidates\n\t// with a backup list saved in double * part of indexed vector\n\n\t// pivot elements\n\tdouble * spare;\n\t// indices\n\tint * index;\n\tspareArray->clear();\n\tspare = spareArray->denseVector();\n\tindex = spareArray->getIndices();\n\n\t// we also need somewhere for effective rhs\n\tdouble * rhs=rhsArray->denseVector();\n\t// and we can use indices to point to alpha\n\t// that way we can store fabs(alpha)\n\tint * indexPoint = rhsArray->getIndices();\n\t//int numberFlip=0; // Those which may change if flips\n\n\t/*\n\t First we get a list of possible pivots. We can also see if the\n\t problem looks unbounded.\n\n\t At first we increase theta and see what happens. We start\n\t theta at a reasonable guess. If in right area then we do bit by bit.\n\t We save possible pivot candidates\n\n\t */\n\n\t// do first pass to get possibles\n\t// We can also see if unbounded\n\n\tdouble * work=rowArray->denseVector();\n\tint number=rowArray->getNumElements();\n\tint * which=rowArray->getIndices();\n\n\t// we need to swap sign if coming in from ub\n\tdouble way = directionIn_;\n\tdouble maximumMovement;\n\tif (way>0.0)\n\t\tmaximumMovement = std::min(1.0e30,upperIn_-valueIn_);\n\telse\n\t\tmaximumMovement = std::min(1.0e30,valueIn_-lowerIn_);\n\n\tdouble averageTheta = nonLinearCost_->averageTheta();\n\tdouble tentativeTheta = std::min(10.0*averageTheta,maximumMovement);\n\tdouble upperTheta = maximumMovement;\n\tif (tentativeTheta>0.5*maximumMovement)\n\t\ttentativeTheta=maximumMovement;\n\tbool thetaAtMaximum=tentativeTheta==maximumMovement;\n\t// In case tiny bounds increase\n\tif (maximumMovement<1.0)\n\t\ttentativeTheta *= 1.1;\n\tdouble dualCheck = fabs(dualIn_);\n\t// but make a bit more pessimistic\n\tdualCheck=std::max(dualCheck-100.0*dualTolerance_,0.99*dualCheck);\n\n\tint iIndex;\n\tint pivotOne=-1;\n\t//#define CLP_DEBUG\n#ifdef CLP_DEBUG\n\tif (numberIterations_==-3839||numberIterations_==-3840) {\n\t\tdouble dj=cost_[sequenceIn_];\n\t\tprintf(\"cost in on %d is %g, dual in %g\\n\",sequenceIn_,dj,dualIn_);\n\t\tfor (iIndex=0;iIndex %g (cost %g, dj %g)\\n\",\n\t\t\t\t iRow,iPivot,lower_[iPivot],solution_[iPivot],upper_[iPivot],\n\t\t\t\t alpha, solution_[iPivot]-1.0e9*alpha,cost_[iPivot],dj);\n\t\t}\n\t}\n#endif\n\twhile (true) {\n\t\tpivotOne=-1;\n\t\ttotalThru=0.0;\n\t\t// We also re-compute reduced cost\n\t\tnumberRemaining=0;\n\t\tdualIn_ = cost_[sequenceIn_];\n#ifndef NDEBUG\n\t\tdouble tolerance = primalTolerance_*1.002;\n#endif\n\t\tfor (iIndex=0;iIndex0.0) {\n\t\t\t\t// basic variable going towards lower bound\n\t\t\t\tdouble bound = lower_[iPivot];\n\t\t\t\t// must be exactly same as when used\n\t\t\t\tdouble change = tentativeTheta*alpha;\n\t\t\t\tpossible = (oldValue-change)<=bound+primalTolerance_;\n\t\t\t\toldValue -= bound;\n\t\t\t} else {\n\t\t\t\t// basic variable going towards upper bound\n\t\t\t\tdouble bound = upper_[iPivot];\n\t\t\t\t// must be exactly same as when used\n\t\t\t\tdouble change = tentativeTheta*alpha;\n\t\t\t\tpossible = (oldValue-change)>=bound-primalTolerance_;\n\t\t\t\toldValue = bound-oldValue;\n\t\t\t\talpha = - alpha;\n\t\t\t}\n\t\t\tdouble value;\n\t\t\tassert (oldValue>=-tolerance);\n\t\t\tif (possible) {\n\t\t\t\tvalue=oldValue-upperTheta*alpha;\n\t\t\t\tif (value<-primalTolerance_&&alpha>=acceptablePivot) {\n\t\t\t\t\tupperTheta = (oldValue+primalTolerance_)/alpha;\n\t\t\t\t\tpivotOne=numberRemaining;\n\t\t\t\t}\n\t\t\t\t// add to list\n\t\t\t\tspare[numberRemaining]=alpha;\n\t\t\t\trhs[numberRemaining]=oldValue;\n\t\t\t\tindexPoint[numberRemaining]=iIndex;\n\t\t\t\tindex[numberRemaining++]=iRow;\n\t\t\t\ttotalThru += alpha;\n\t\t\t\tsetActive(iRow);\n\t\t\t\t//} else if (value=1.0001*dualCheck) {\n\t\t\t// Can pivot here\n\t\t\tbreak;\n\t\t} else if (!thetaAtMaximum) {\n\t\t\t//printf(\"Going round with average theta of %g\\n\",averageTheta);\n\t\t\ttentativeTheta=maximumMovement;\n\t\t\tthetaAtMaximum=true; // seems to be odd compiler error\n\t\t} else {\n\t\t\tbreak;\n\t\t}\n\t}\n\ttotalThru=0.0;\n\n\ttheta_=maximumMovement;\n\n\tbool goBackOne = false;\n\tif (objective_->type()>1)\n\t\tdualIn_=saveDj;\n\n\t//printf(\"%d remain out of %d\\n\",numberRemaining,number);\n\tint iTry=0;\n#define MAXTRY 1000\n\tif (numberRemaining&&upperTheta=0&&0) {\n\t\t\tdouble thruCost = infeasibilityCost_*spare[pivotOne];\n\t\t\tif (thruCost>=0.99*fabs(dualIn_))\n\t\t\t\tprintf(\"Could pivot on %d as change %g dj %g\\n\",\n\t\t\t\t\t index[pivotOne],thruCost,dualIn_);\n\t\t\tdouble alpha = spare[pivotOne];\n\t\t\tdouble oldValue = rhs[pivotOne];\n\t\t\ttheta_ = oldValue/alpha;\n\t\t\tpivotRow_=pivotOne;\n\t\t\t// Stop loop\n\t\t\tiTry=MAXTRY;\n\t\t}\n\n\t\t// first get ratio with tolerance\n\t\tfor ( ;iTry=acceptablePivot) {\n\t\t\t\t\tupperTheta = (oldValue+primalTolerance_)/alpha;\n\t\t\t\t\tiBest=iIndex; // just in case weird numbers\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// now look at best in this lot\n\t\t\t// But also see how infeasible small pivots will make\n\t\t\tdouble sumInfeasibilities=0.0;\n\t\t\tdouble bestPivot=acceptablePivot;\n\t\t\tpivotRow_=-1;\n\t\t\tfor (iIndex=0;iIndexchangeInCost(pivotVariable_[iRow],trueAlpha,rhs[iIndex]);\n\t\t\t\t\tsetActive(iRow);\n\t\t\t\t\tif (alpha>bestPivot) {\n\t\t\t\t\t\tbestPivot=alpha;\n\t\t\t\t\t\ttheta_ = oldValue/bestPivot;\n\t\t\t\t\t\tpivotRow_=iIndex;\n\t\t\t\t\t} else if (alpha1.0e-6&& bestPivot<1.0e-3) {\n\t\t\t\t// back to previous one\n\t\t\t\tgoBackOne = true;\n\t\t\t\tbreak;\n\t\t\t} else if (pivotRow_==-1&&upperTheta>largeValue_) {\n\t\t\t\tif (lastPivot>acceptablePivot) {\n\t\t\t\t\t// back to previous one\n\t\t\t\t\tgoBackOne = true;\n\t\t\t\t} else {\n\t\t\t\t\t// can only get here if all pivots so far too small\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t} else if (totalThru>=dualCheck) {\n\t\t\t\tif (sumInfeasibilities>primalTolerance_&&!nonLinearCost_->numberInfeasibilities()) {\n\t\t\t\t\t// Looks a bad choice\n\t\t\t\t\tif (lastPivot>acceptablePivot) {\n\t\t\t\t\t\tgoBackOne=true;\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// say no good\n\t\t\t\t\t\tdualIn_=0.0;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t\tbreak; // no point trying another loop\n\t\t\t} else {\n\t\t\t\tlastPivotRow=pivotRow_;\n\t\t\t\tlastTheta = theta_;\n\t\t\t\tif (bestPivot>bestEverPivot)\n\t\t\t\t\tbestEverPivot=bestPivot;\n\t\t\t}\n\t\t}\n\t\t// can get here without pivotRow_ set but with lastPivotRow\n\t\tif (goBackOne||(pivotRow_<0&&lastPivotRow>=0)) {\n\t\t\t// back to previous one\n\t\t\tpivotRow_=lastPivotRow;\n\t\t\ttheta_ = lastTheta;\n\t\t}\n\t} else if (pivotRow_<0&&maximumMovement>1.0e20) {\n\t\t// looks unbounded\n\t\tvalueOut_=COIN_DBL_MAX; // say odd\n\t\tif (nonLinearCost_->numberInfeasibilities()) {\n\t\t\t// but infeasible??\n\t\t\t// move variable but don't pivot\n\t\t\ttentativeTheta=1.0e50;\n\t\t\tfor (iIndex=0;iIndex0.0) {\n\t\t\t\t\t// basic variable going towards lower bound\n\t\t\t\t\tdouble bound = lower_[iPivot];\n\t\t\t\t\toldValue -= bound;\n\t\t\t\t} else {\n\t\t\t\t\t// basic variable going towards upper bound\n\t\t\t\t\tdouble bound = upper_[iPivot];\n\t\t\t\t\toldValue = bound-oldValue;\n\t\t\t\t\talpha = - alpha;\n\t\t\t\t}\n\t\t\t\tif (oldValue-tentativeTheta*alpha<0.0) {\n\t\t\t\t\ttentativeTheta = oldValue/alpha;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// If free in then see if we can get to 0.0\n\t\t\tif (lowerIn_<-1.0e20&&upperIn_>1.0e20) {\n\t\t\t\tif (dualIn_*valueIn_>0.0) {\n\t\t\t\t\tif (fabs(valueIn_)<1.0e-2&&(tentativeTheta1.0e20)) {\n\t\t\t\t\t\ttentativeTheta = fabs(valueIn_);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (tentativeTheta<1.0e10)\n\t\t\t\tvalueOut_=valueIn_+way*tentativeTheta;\n\t\t}\n\t}\n\t//if (iTry>50)\n\t//printf(\"** %d tries\\n\",iTry);\n\tif (pivotRow_>=0) {\n\t\tint position=pivotRow_; // position in list\n\t\tpivotRow_=index[position];\n\t\talpha_=work[indexPoint[position]];\n\t\t// translate to sequence\n\t\tsequenceOut_ = pivotVariable_[pivotRow_];\n\t\tvalueOut_ = solution(sequenceOut_);\n\t\tlowerOut_=lower_[sequenceOut_];\n\t\tupperOut_=upper_[sequenceOut_];\n#define MINIMUMTHETA 1.0e-12\n\t\t// Movement should be minimum for anti-degeneracy - unless\n\t\t// fixed variable out\n\t\tdouble minimumTheta;\n\t\tif (upperOut_>lowerOut_)\n\t\t\tminimumTheta=MINIMUMTHETA;\n\t\telse\n\t\t\tminimumTheta=0.0;\n\t\t// But can't go infeasible\n\t\tdouble distance;\n\t\tif (alpha_*way>0.0)\n\t\t\tdistance=valueOut_-lowerOut_;\n\t\telse\n\t\t\tdistance=upperOut_-valueOut_;\n\t\tif (distance-minimumTheta*fabs(alpha_)<-primalTolerance_)\n\t\t\tminimumTheta = std::max(0.0,(distance+0.5*primalTolerance_)/fabs(alpha_));\n\t\t// will we need to increase tolerance\n\t\t//#define CLP_DEBUG\n\t\tdouble largestInfeasibility = primalTolerance_;\n\t\tif (theta_primalTolerance_&&(handler_->logLevel()&32)>-1)\n\t\t\t\tprintf(\"Primal tolerance increased from %g to %g\\n\",\n\t\t\t\t\t primalTolerance_,largestInfeasibility);\n#endif\n\t\t\t//#undef CLP_DEBUG\n\t\t\tprimalTolerance_ = std::max(primalTolerance_,largestInfeasibility);\n\t\t}\n\t\t// Need to look at all in some cases\n\t\tif (theta_>tentativeTheta) {\n\t\t\tfor (iIndex=0;iIndex1.0e-6||(specialOptions_&4)!=0) {\n\t\t\t\tupperOut_ = nonLinearCost_->nearest(sequenceOut_,newValue);\n\t\t\t} else {\n\t\t\t\tupperOut_ = newValue;\n\t\t\t}\n\t\t} else {\n\t\t\tdirectionOut_=1; // to lower bound\n\t\t\tif (fabs(theta_)>1.0e-6||(specialOptions_&4)!=0) {\n\t\t\t\tlowerOut_ = nonLinearCost_->nearest(sequenceOut_,newValue);\n\t\t\t} else {\n\t\t\t\tlowerOut_ = newValue;\n\t\t\t}\n\t\t}\n\t\tdualOut_ = reducedCost(sequenceOut_);\n\t} else if (maximumMovement<1.0e20) {\n\t\t// flip\n\t\tpivotRow_ = -2; // so we can tell its a flip\n\t\tsequenceOut_ = sequenceIn_;\n\t\tvalueOut_ = valueIn_;\n\t\tdualOut_ = dualIn_;\n\t\tlowerOut_ = lowerIn_;\n\t\tupperOut_ = upperIn_;\n\t\talpha_ = 0.0;\n\t\tif (way<0.0) {\n\t\t\tdirectionOut_=1; // to lower bound\n\t\t\ttheta_ = lowerOut_ - valueOut_;\n\t\t} else {\n\t\t\tdirectionOut_=-1; // to upper bound\n\t\t\ttheta_ = upperOut_ - valueOut_;\n\t\t}\n\t}\n\n\tdouble theta1 = std::max(theta_,1.0e-12);\n\tdouble theta2 = numberIterations_*nonLinearCost_->averageTheta();\n\t// Set average theta\n\tnonLinearCost_->setAverageTheta((theta1+theta2)/(static_cast (numberIterations_+1)));\n\t//if (numberIterations_%1000==0)\n\t//printf(\"average theta is %g\\n\",nonLinearCost_->averageTheta());\n\n\t// clear arrays\n\n\tCoinZeroN(spare,numberRemaining);\n\n\t// put back original bounds etc\n\tCoinMemcpyN(index,numberRemaining,rhsArray->getIndices());\n\trhsArray->setNumElements(numberRemaining);\n\trhsArray->setPacked();\n\tnonLinearCost_->goBackAll(rhsArray);\n\trhsArray->clear();\n\n}\n/*\n Chooses primal pivot column\n updateArray has cost updates (also use pivotRow_ from last iteration)\n Would be faster with separate region to scan\n and will have this (with square of infeasibility) when steepest\n For easy problems we can just choose one of the first columns we look at\n */\nvoid\nIClpSimplexPrimal::primalColumn(CoinIndexedVector * updates,\n\t\t\t\t\t\t\t\t\t CoinIndexedVector * spareRow1,\n\t\t\t\t\t\t\t\t\t CoinIndexedVector * spareRow2,\n\t\t\t\t\t\t\t\t\t CoinIndexedVector * spareColumn1,\n\t\t\t\t\t\t\t\t\t CoinIndexedVector * spareColumn2)\n{\n\n\tClpMatrixBase * saveMatrix = matrix_;\n\tdouble * saveRowScale = rowScale_;\n\tif (scaledMatrix_) {\n\t\trowScale_=NULL;\n\t\tmatrix_ = scaledMatrix_;\n\t}\n\tsequenceIn_ = primalColumnPivot_->pivotColumn(updates,spareRow1,\n\t\t\t\t\t\t\t\t\t\t\t\t spareRow2,spareColumn1,\n\t\t\t\t\t\t\t\t\t\t\t\t spareColumn2);\n\tif (scaledMatrix_) {\n\t\tmatrix_ = saveMatrix;\n\t\trowScale_ = saveRowScale;\n\t}\n\tif (sequenceIn_>=0) {\n\t\tvalueIn_=solution_[sequenceIn_];\n\t\tdualIn_=dj_[sequenceIn_];\n\t\tif (nonLinearCost_->lookBothWays()) {\n\t\t\t// double check\n\t\t\tIClpSimplex::Status status = getStatus(sequenceIn_);\n\n\t\t\tswitch(status) {\n\t\t\t\tcase IClpSimplex::atUpperBound:\n\t\t\t\t\tif (dualIn_<0.0) {\n\t\t\t\t\t\t// move to other side\n\t\t\t\t\t\tprintf(\"For %d U (%g, %g, %g) dj changed from %g\",\n\t\t\t\t\t\t\t sequenceIn_,lower_[sequenceIn_],solution_[sequenceIn_],\n\t\t\t\t\t\t\t upper_[sequenceIn_],dualIn_);\n\t\t\t\t\t\tdualIn_ -= nonLinearCost_->changeUpInCost(sequenceIn_);\n\t\t\t\t\t\tprintf(\" to %g\\n\",dualIn_);\n\t\t\t\t\t\tnonLinearCost_->setOne(sequenceIn_,upper_[sequenceIn_]+2.0*currentPrimalTolerance());\n\t\t\t\t\t\tsetStatus(sequenceIn_,IClpSimplex::atLowerBound);\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase IClpSimplex::atLowerBound:\n\t\t\t\t\tif (dualIn_>0.0) {\n\t\t\t\t\t\t// move to other side\n\t\t\t\t\t\tprintf(\"For %d L (%g, %g, %g) dj changed from %g\",\n\t\t\t\t\t\t\t sequenceIn_,lower_[sequenceIn_],solution_[sequenceIn_],\n\t\t\t\t\t\t\t upper_[sequenceIn_],dualIn_);\n\t\t\t\t\t\tdualIn_ -= nonLinearCost_->changeDownInCost(sequenceIn_);\n\t\t\t\t\t\tprintf(\" to %g\\n\",dualIn_);\n\t\t\t\t\t\tnonLinearCost_->setOne(sequenceIn_,lower_[sequenceIn_]-2.0*currentPrimalTolerance());\n\t\t\t\t\t\tsetStatus(sequenceIn_,IClpSimplex::atUpperBound);\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tlowerIn_=lower_[sequenceIn_];\n\t\tupperIn_=upper_[sequenceIn_];\n\t\tif (dualIn_>0.0)\n\t\t\tdirectionIn_ = -1;\n\t\telse\n\t\t\tdirectionIn_ = 1;\n\t} else {\n\t\tsequenceIn_ = -1;\n\t}\n}\n/* The primals are updated by the given array.\n Returns number of infeasibilities.\n After rowArray will have list of cost changes\n */\nint\nIClpSimplexPrimal::updatePrimalsInPrimal(CoinIndexedVector * rowArray,\n\t\t\t\t\t\t\t\t\t\t\t double theta,\n\t\t\t\t\t\t\t\t\t\t\t double & objectiveChange,\n\t\t\t\t\t\t\t\t\t\t\t int valuesPass)\n{\n\t// Cost on pivot row may change - may need to change dualIn\n\tdouble oldCost=0.0;\n\tif (pivotRow_>=0)\n\t\toldCost = cost_[sequenceOut_];\n\t//rowArray->scanAndPack();\n\tdouble * work=rowArray->denseVector();\n\tint number=rowArray->getNumElements();\n\tint * which=rowArray->getIndices();\n\n\tint newNumber = 0;\n\tint pivotPosition = -1;\n\tnonLinearCost_->setChangeInCost(0.0);\n\t//printf(\"XX 4138 sol %g lower %g upper %g cost %g status %d\\n\",\n\t// solution_[4138],lower_[4138],upper_[4138],cost_[4138],status_[4138]);\n\t// allow for case where bound+tolerance == bound\n\t//double tolerance = 0.999999*primalTolerance_;\n\tdouble relaxedTolerance = 1.001*primalTolerance_;\n\tint iIndex;\n\tif (!valuesPass) {\n\t\tfor (iIndex=0;iIndex0.0) {\n\t\t\t\t\t// going down\n\t\t\t\t\tif (value<=lower_[iPivot]+primalTolerance_) {\n\t\t\t\t\t\tif (iPivot==sequenceOut_&&value>lower_[iPivot]-relaxedTolerance)\n\t\t\t\t\t\t\tvalue=lower_[iPivot];\n\t\t\t\t\t\tdouble difference = nonLinearCost_->setOne(iPivot,value);\n\t\t\t\t\t\tassert (!difference||fabs(change)>1.0e9);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\t// going up\n\t\t\t\t\tif (value>=upper_[iPivot]-primalTolerance_) {\n\t\t\t\t\t\tif (iPivot==sequenceOut_&&valuesetOne(iPivot,value);\n\t\t\t\t\t\tassert (!difference||fabs(change)>1.0e9);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n#endif\n\t\t\tif (active(iRow)||theta_<0.0) {\n\t\t\t\tclearActive(iRow);\n\t\t\t\t// But make sure one going out is feasible\n\t\t\t\tif (change>0.0) {\n\t\t\t\t\t// going down\n\t\t\t\t\tif (value<=lower_[iPivot]+primalTolerance_) {\n\t\t\t\t\t\tif (iPivot==sequenceOut_&&value>=lower_[iPivot]-relaxedTolerance)\n\t\t\t\t\t\t\tvalue=lower_[iPivot];\n\t\t\t\t\t\tdouble difference = nonLinearCost_->setOne(iPivot,value);\n\t\t\t\t\t\tif (difference) {\n\t\t\t\t\t\t\tif (iRow==pivotRow_)\n\t\t\t\t\t\t\t\tpivotPosition=newNumber;\n\t\t\t\t\t\t\twork[newNumber] = difference;\n\t\t\t\t\t\t\t//change reduced cost on this\n\t\t\t\t\t\t\tdj_[iPivot] = -difference;\n\t\t\t\t\t\t\twhich[newNumber++]=iRow;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\t// going up\n\t\t\t\t\tif (value>=upper_[iPivot]-primalTolerance_) {\n\t\t\t\t\t\tif (iPivot==sequenceOut_&&valuesetOne(iPivot,value);\n\t\t\t\t\t\tif (difference) {\n\t\t\t\t\t\t\tif (iRow==pivotRow_)\n\t\t\t\t\t\t\t\tpivotPosition=newNumber;\n\t\t\t\t\t\t\twork[newNumber] = difference;\n\t\t\t\t\t\t\t//change reduced cost on this\n\t\t\t\t\t\t\tdj_[iPivot] = -difference;\n\t\t\t\t\t\t\twhich[newNumber++]=iRow;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t} else {\n\t\t// values pass so look at all\n\t\tfor (iIndex=0;iIndex0.0) {\n\t\t\t\t// going down\n\t\t\t\tif (value<=lower_[iPivot]+primalTolerance_) {\n\t\t\t\t\tif (iPivot==sequenceOut_&&value>lower_[iPivot]-relaxedTolerance)\n\t\t\t\t\t\tvalue=lower_[iPivot];\n\t\t\t\t\tdouble difference = nonLinearCost_->setOne(iPivot,value);\n\t\t\t\t\tif (difference) {\n\t\t\t\t\t\tif (iRow==pivotRow_)\n\t\t\t\t\t\t\tpivotPosition=newNumber;\n\t\t\t\t\t\twork[newNumber] = difference;\n\t\t\t\t\t\t//change reduced cost on this\n\t\t\t\t\t\tdj_[iPivot] = -difference;\n\t\t\t\t\t\twhich[newNumber++]=iRow;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\t// going up\n\t\t\t\tif (value>=upper_[iPivot]-primalTolerance_) {\n\t\t\t\t\tif (iPivot==sequenceOut_&&valuesetOne(iPivot,value);\n\t\t\t\t\tif (difference) {\n\t\t\t\t\t\tif (iRow==pivotRow_)\n\t\t\t\t\t\t\tpivotPosition=newNumber;\n\t\t\t\t\t\twork[newNumber] = difference;\n\t\t\t\t\t\t//change reduced cost on this\n\t\t\t\t\t\tdj_[iPivot] = -difference;\n\t\t\t\t\t\twhich[newNumber++]=iRow;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tobjectiveChange += nonLinearCost_->changeInCost();\n\trowArray->setPacked();\n#if 0\n\trowArray->setNumElements(newNumber);\n\trowArray->expand();\n\tif (pivotRow_>=0) {\n\t\tdualIn_ += (oldCost-cost_[sequenceOut_]);\n\t\t// update change vector to include pivot\n\t\trowArray->add(pivotRow_,-dualIn_);\n\t\t// and convert to packed\n\t\trowArray->scanAndPack();\n\t} else {\n\t\t// and convert to packed\n\t\trowArray->scanAndPack();\n\t}\n#else\n\tif (pivotRow_>=0) {\n\t\tdouble dualIn = dualIn_+(oldCost-cost_[sequenceOut_]);\n\t\t// update change vector to include pivot\n\t\tif (pivotPosition>=0) {\n\t\t\twork[pivotPosition] -= dualIn;\n\t\t} else {\n\t\t\twork[newNumber]=-dualIn;\n\t\t\twhich[newNumber++]=pivotRow_;\n\t\t}\n\t}\n\trowArray->setNumElements(newNumber);\n#endif\n\treturn 0;\n}\n// Perturbs problem\nvoid\nIClpSimplexPrimal::perturb(int type)\n{\n\tif (perturbation_>100)\n\t\treturn; //perturbed already\n\tif (perturbation_==100)\n\t\tperturbation_=50; // treat as normal\n\tint savePerturbation = perturbation_;\n\tint i;\n\tif (!numberIterations_)\n\t\tcleanStatus(); // make sure status okay\n\t// Make sure feasible bounds\n\tif (nonLinearCost_)\n\t\tnonLinearCost_->feasibleBounds();\n\t// look at element range\n\tdouble smallestNegative;\n\tdouble largestNegative;\n\tdouble smallestPositive;\n\tdouble largestPositive;\n\tmatrix_->rangeOfElements(smallestNegative, largestNegative,\n\t\t\t\t\t\t\t smallestPositive, largestPositive);\n\tsmallestPositive = std::min(fabs(smallestNegative),smallestPositive);\n\tlargestPositive = std::max(fabs(largestNegative),largestPositive);\n\tdouble elementRatio = largestPositive/smallestPositive;\n\tif (!numberIterations_&&perturbation_==50) {\n\t\t// See if we need to perturb\n\t\tdouble * sort = new double[numberRows_];\n\t\tfor (i=0;inumberRows_||elementRatio>1.0e12) {\n\t\t\tperturbation_=100;\n\t\t\treturn; // good enough\n\t\t}\n\t}\n\t// primal perturbation\n\tdouble perturbation=1.0e-20;\n\tint numberNonZero=0;\n\t// maximum fraction of rhs/bounds to perturb\n\tdouble maximumFraction = 1.0e-5;\n\tif (perturbation_>=50) {\n\t\tperturbation = 1.0e-4;\n\t\tfor (i=0;ilower_[i]+primalTolerance_) {\n\t\t\t\tdouble lowerValue, upperValue;\n\t\t\t\tif (lower_[i]>-1.0e20)\n\t\t\t\t\tlowerValue = fabs(lower_[i]);\n\t\t\t\telse\n\t\t\t\t\tlowerValue=0.0;\n\t\t\t\tif (upper_[i]<1.0e20)\n\t\t\t\t\tupperValue = fabs(upper_[i]);\n\t\t\t\telse\n\t\t\t\t\tupperValue=0.0;\n\t\t\t\tdouble value = std::max(fabs(lowerValue),fabs(upperValue));\n\t\t\t\tvalue = std::min(value,upper_[i]-lower_[i]);\n#if 1\n\t\t\t\tif (value) {\n\t\t\t\t\tperturbation += value;\n\t\t\t\t\tnumberNonZero++;\n\t\t\t\t}\n#else\n\t\t\t\tperturbation = std::max(perturbation,value);\n#endif\n\t\t\t}\n\t\t}\n\t\tif (numberNonZero)\n\t\t\tperturbation /= static_cast (numberNonZero);\n\t\telse\n\t\t\tperturbation = 1.0e-1;\n\t\tif (perturbation_>50&&perturbation_<60) {\n\t\t\t// reduce\n\t\t\twhile (perturbation_>50) {\n\t\t\t\tperturbation_--;\n\t\t\t\tperturbation *= 0.25;\n\t\t\t}\n\t\t}\n\t} else if (perturbation_<100) {\n\t\tperturbation = pow(10.0,perturbation_);\n\t\t// user is in charge\n\t\tmaximumFraction = 1.0;\n\t}\n\tdouble largestZero=0.0;\n\tdouble largest=0.0;\n\tdouble largestPerCent=0.0;\n\tbool printOut=(handler_->logLevel()==63);\n\tprintOut=false; //off\n\t// Check if all slack\n\tint number=0;\n\tint iSequence;\n\tfor (iSequence=0;iSequence100.0) {\n\t\t// tone down perturbation\n\t\tmaximumFraction *= 0.1;\n\t}\n\tif (number!=numberRows_)\n\t\ttype=1;\n\t// modify bounds\n\t// Change so at least 1.0e-5 and no more than 0.1\n\t// For now just no more than 0.1\n\t// printf(\"Pert type %d perturbation %g, maxF %g\\n\",type,perturbation,maximumFraction);\n\t// seems much slower???#define SAVE_PERT\n#ifdef SAVE_PERT\n\tif (2*numberColumns_>maximumPerturbationSize_) {\n\t\tdelete [] perturbationArray_;\n\t\tmaximumPerturbationSize_ = 2* numberColumns_;\n\t\tperturbationArray_ = new double [maximumPerturbationSize_];\n\t\tfor (int iColumn=0;iColumnlowerValue+tolerance) {\n\t\t\t\t\tdouble solutionValue = solution_[iSequence];\n\t\t\t\t\tdouble difference = upperValue-lowerValue;\n\t\t\t\t\tdifference = std::min(difference,perturbation);\n\t\t\t\t\tdifference = std::min(difference,fabs(solutionValue)+1.0);\n\t\t\t\t\tdouble value = maximumFraction*(difference+1.0);\n\t\t\t\t\tvalue = std::min(value,0.1);\n#ifndef SAVE_PERT\n\t\t\t\t\tvalue *= randomNumberGenerator_.randomDouble();\n#else\n\t\t\t\t\tvalue *= perturbationArray_[2*iSequence];\n#endif\n\t\t\t\t\tif (solutionValue-lowerValue<=primalTolerance_) {\n\t\t\t\t\t\tlower_[iSequence] -= value;\n\t\t\t\t\t} else if (upperValue-solutionValue<=primalTolerance_) {\n\t\t\t\t\t\tupper_[iSequence] += value;\n\t\t\t\t\t} else {\n#if 0\n\t\t\t\t\t\tif (iSequence>=numberColumns_) {\n\t\t\t\t\t\t\t// may not be at bound - but still perturb (unless free)\n\t\t\t\t\t\t\tif (upperValue>1.0e30&&lowerValue<-1.0e30)\n\t\t\t\t\t\t\t\tvalue=0.0;\n\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\tvalue = - value; // as -1.0 in matrix\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tvalue = 0.0;\n\t\t\t\t\t\t}\n#else\n\t\t\t\t\t\tvalue=0.0;\n#endif\n\t\t\t\t\t}\n\t\t\t\t\tif (value) {\n\t\t\t\t\t\tif (printOut)\n\t\t\t\t\t\t\tprintf(\"col %d lower from %g to %g, upper from %g to %g\\n\",\n\t\t\t\t\t\t\t\t iSequence,lower_[iSequence],lowerValue,upper_[iSequence],upperValue);\n\t\t\t\t\t\tif (solutionValue) {\n\t\t\t\t\t\t\tlargest = std::max(largest,value);\n\t\t\t\t\t\t\tif (value>(fabs(solutionValue)+1.0)*largestPerCent)\n\t\t\t\t\t\t\t\tlargestPerCent=value/(fabs(solutionValue)+1.0);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tlargestZero = std::max(largestZero,value);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t} else {\n\t\tdouble tolerance = 100.0*primalTolerance_;\n\t\tfor (i=0;ilowerValue+primalTolerance_) {\n\t\t\t\tdouble value = perturbation*maximumFraction;\n\t\t\t\tvalue = std::min(value,0.1);\n#ifndef SAVE_PERT\n\t\t\t\tvalue *= randomNumberGenerator_.randomDouble();\n#else\n\t\t\t\tvalue *= perturbationArray_[2*i+1];\n#endif\n\t\t\t\tvalue *= randomNumberGenerator_.randomDouble();\n\t\t\t\tif (savePerturbation!=50) {\n\t\t\t\t\tif (fabs(value)<=primalTolerance_)\n\t\t\t\t\t\tvalue=0.0;\n\t\t\t\t\tif (lowerValue>-1.0e20&&lowerValue)\n\t\t\t\t\t\tlowerValue -= value * (std::max(1.0e-2,1.0e-5*fabs(lowerValue)));\n\t\t\t\t\tif (upperValue<1.0e20&&upperValue)\n\t\t\t\t\t\tupperValue += value * (std::max(1.0e-2,1.0e-5*fabs(upperValue)));\n\t\t\t\t} else if (value) {\n\t\t\t\t\tdouble valueL =value *(std::max(1.0e-2,1.0e-5*fabs(lowerValue)));\n\t\t\t\t\t// get in range\n\t\t\t\t\tif (valueL<=tolerance) {\n\t\t\t\t\t\tvalueL *= 10.0;\n\t\t\t\t\t\twhile (valueL<=tolerance)\n\t\t\t\t\t\t\tvalueL *= 10.0;\n\t\t\t\t\t} else if (valueL>1.0) {\n\t\t\t\t\t\tvalueL *= 0.1;\n\t\t\t\t\t\twhile (valueL>1.0)\n\t\t\t\t\t\t\tvalueL *= 0.1;\n\t\t\t\t\t}\n\t\t\t\t\tif (lowerValue>-1.0e20&&lowerValue)\n\t\t\t\t\t\tlowerValue -= valueL;\n\t\t\t\t\tdouble valueU =value *(std::max(1.0e-2,1.0e-5*fabs(upperValue)));\n\t\t\t\t\t// get in range\n\t\t\t\t\tif (valueU<=tolerance) {\n\t\t\t\t\t\tvalueU *= 10.0;\n\t\t\t\t\t\twhile (valueU<=tolerance)\n\t\t\t\t\t\t\tvalueU *= 10.0;\n\t\t\t\t\t} else if (valueU>1.0) {\n\t\t\t\t\t\tvalueU *= 0.1;\n\t\t\t\t\t\twhile (valueU>1.0)\n\t\t\t\t\t\t\tvalueU *= 0.1;\n\t\t\t\t\t}\n\t\t\t\t\tif (upperValue<1.0e20&&upperValue)\n\t\t\t\t\t\tupperValue += valueU;\n\t\t\t\t}\n\t\t\t\tif (lowerValue!=lower_[i]) {\n\t\t\t\t\tdouble difference = fabs(lowerValue-lower_[i]);\n\t\t\t\t\tlargest = std::max(largest,difference);\n\t\t\t\t\tif (difference>fabs(lower_[i])*largestPerCent)\n\t\t\t\t\t\tlargestPerCent=fabs(difference/lower_[i]);\n\t\t\t\t}\n\t\t\t\tif (upperValue!=upper_[i]) {\n\t\t\t\t\tdouble difference = fabs(upperValue-upper_[i]);\n\t\t\t\t\tlargest = std::max(largest,difference);\n\t\t\t\t\tif (difference>fabs(upper_[i])*largestPerCent)\n\t\t\t\t\t\tlargestPerCent=fabs(difference/upper_[i]);\n\t\t\t\t}\n\t\t\t\tif (printOut)\n\t\t\t\t\tprintf(\"col %d lower from %g to %g, upper from %g to %g\\n\",\n\t\t\t\t\t\t i,lower_[i],lowerValue,upper_[i],upperValue);\n\t\t\t}\n\t\t\tlower_[i]=lowerValue;\n\t\t\tupper_[i]=upperValue;\n\t\t}\n\t\tfor (;ilowerValue+tolerance) {\n\t\t\t\tif (savePerturbation!=50) {\n\t\t\t\t\tif (fabs(value)<=primalTolerance_)\n\t\t\t\t\t\tvalue=0.0;\n\t\t\t\t\tif (lowerValue>-1.0e20&&lowerValue)\n\t\t\t\t\t\tlowerValue -= value * (std::max(1.0e-2,1.0e-5*fabs(lowerValue)));\n\t\t\t\t\tif (upperValue<1.0e20&&upperValue)\n\t\t\t\t\t\tupperValue += value * (std::max(1.0e-2,1.0e-5*fabs(upperValue)));\n\t\t\t\t} else if (value) {\n\t\t\t\t\tdouble valueL =value *(std::max(1.0e-2,1.0e-5*fabs(lowerValue)));\n\t\t\t\t\t// get in range\n\t\t\t\t\tif (valueL<=tolerance) {\n\t\t\t\t\t\tvalueL *= 10.0;\n\t\t\t\t\t\twhile (valueL<=tolerance)\n\t\t\t\t\t\t\tvalueL *= 10.0;\n\t\t\t\t\t} else if (valueL>1.0) {\n\t\t\t\t\t\tvalueL *= 0.1;\n\t\t\t\t\t\twhile (valueL>1.0)\n\t\t\t\t\t\t\tvalueL *= 0.1;\n\t\t\t\t\t}\n\t\t\t\t\tif (lowerValue>-1.0e20&&lowerValue)\n\t\t\t\t\t\tlowerValue -= valueL;\n\t\t\t\t\tdouble valueU =value *(std::max(1.0e-2,1.0e-5*fabs(upperValue)));\n\t\t\t\t\t// get in range\n\t\t\t\t\tif (valueU<=tolerance) {\n\t\t\t\t\t\tvalueU *= 10.0;\n\t\t\t\t\t\twhile (valueU<=tolerance)\n\t\t\t\t\t\t\tvalueU *= 10.0;\n\t\t\t\t\t} else if (valueU>1.0) {\n\t\t\t\t\t\tvalueU *= 0.1;\n\t\t\t\t\t\twhile (valueU>1.0)\n\t\t\t\t\t\t\tvalueU *= 0.1;\n\t\t\t\t\t}\n\t\t\t\t\tif (upperValue<1.0e20&&upperValue)\n\t\t\t\t\t\tupperValue += valueU;\n\t\t\t\t}\n\t\t\t} else if (upperValue>0.0) {\n\t\t\t\tupperValue -= value * (std::max(1.0e-2,1.0e-5*fabs(lowerValue)));\n\t\t\t\tlowerValue -= value * (std::max(1.0e-2,1.0e-5*fabs(lowerValue)));\n\t\t\t} else if (upperValue<0.0) {\n\t\t\t\tupperValue += value * (std::max(1.0e-2,1.0e-5*fabs(lowerValue)));\n\t\t\t\tlowerValue += value * (std::max(1.0e-2,1.0e-5*fabs(lowerValue)));\n\t\t\t} else {\n\t\t\t}\n\t\t\tif (lowerValue!=lower_[i]) {\n\t\t\t\tdouble difference = fabs(lowerValue-lower_[i]);\n\t\t\t\tlargest = std::max(largest,difference);\n\t\t\t\tif (difference>fabs(lower_[i])*largestPerCent)\n\t\t\t\t\tlargestPerCent=fabs(difference/lower_[i]);\n\t\t\t}\n\t\t\tif (upperValue!=upper_[i]) {\n\t\t\t\tdouble difference = fabs(upperValue-upper_[i]);\n\t\t\t\tlargest = std::max(largest,difference);\n\t\t\t\tif (difference>fabs(upper_[i])*largestPerCent)\n\t\t\t\t\tlargestPerCent=fabs(difference/upper_[i]);\n\t\t\t}\n\t\t\tif (printOut)\n\t\t\t\tprintf(\"row %d lower from %g to %g, upper from %g to %g\\n\",\n\t\t\t\t\t i-numberColumns_,lower_[i],lowerValue,upper_[i],upperValue);\n\t\t\tlower_[i]=lowerValue;\n\t\t\tupper_[i]=upperValue;\n\t\t}\n\t}\n\t// Clean up\n\tfor (i=0;imessage(CLP_SIMPLEX_PERTURB,messages_)\n <<100.0*maximumFraction<checkInfeasibilities(0.0);\n#if 1\n\t// Try using dual\n\treturn true;\n#else\n\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\treturn false;\n#endif\n\n}\n// Unflag all variables and return number unflagged\nint\nIClpSimplexPrimal::unflag()\n{\n\tint i;\n\tint number = numberRows_+numberColumns_;\n\tint numberFlagged=0;\n\t// we can't really trust infeasibilities if there is dual error\n\t// allow tolerance bigger than standard to check on duals\n\tdouble relaxedToleranceD=dualTolerance_ + std::min(1.0e-2,10.0*largestDualError_);\n\tfor (i=0;irelaxedToleranceD)\n\t\t\t\tnumberFlagged++;\n\t\t}\n\t}\n\tnumberFlagged += matrix_->generalExpanded(this,8,i);\n\tif (handler_->logLevel()>2&&numberFlagged&&objective_->type()>1)\n\t\tprintf(\"%d unflagged\\n\",numberFlagged);\n\treturn numberFlagged;\n}\n// Do not change infeasibility cost and always say optimal\nvoid\nIClpSimplexPrimal::alwaysOptimal(bool onOff)\n{\n\tif (onOff)\n\t\tspecialOptions_ |= 1;\n\telse\n\t\tspecialOptions_ &= ~1;\n}\nbool\nIClpSimplexPrimal::alwaysOptimal() const\n{\n\treturn (specialOptions_&1)!=0;\n}\n// Flatten outgoing variables i.e. - always to exact bound\nvoid\nIClpSimplexPrimal::exactOutgoing(bool onOff)\n{\n\tif (onOff)\n\t\tspecialOptions_ |= 4;\n\telse\n\t\tspecialOptions_ &= ~4;\n}\nbool\nIClpSimplexPrimal::exactOutgoing() const\n{\n\treturn (specialOptions_&4)!=0;\n}\n/*\n Reasons to come out (normal mode/user mode):\n -1 normal\n -2 factorize now - good iteration/ NA\n -3 slight inaccuracy - refactorize - iteration done/ same but factor done\n -4 inaccuracy - refactorize - no iteration/ NA\n -5 something flagged - go round again/ pivot not possible\n +2 looks unbounded\n +3 max iterations (iteration done)\n */\nint\nIClpSimplexPrimal::pivotResult(int ifValuesPass)\n{\n\t// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n\t// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n\n\tbool roundAgain=true;\n\tint returnCode=-1;\n\n\n\t//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\t//int returnCodeBack = 1000;\n\t//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n//\n\n\n\t// loop round if user setting and doing refactorization\n\twhile (roundAgain) {\n\t\troundAgain=false;\n\t\treturnCode=-1;\n\t\tpivotRow_=-1;\n\t\tsequenceOut_=-1;\n\t\trowArray_[1]->clear();\n#if 0\n\t\t{\n\t\t\tint seq[]={612,643};\n\t\t\tint k;\n\t\t\tfor (k=0;kupdateColumn(rowArray_[2],rowArray_[1]);\n\t\t\t\t\tdjval = cost_[iSeq];\n\t\t\t\t\twork=rowArray_[1]->denseVector();\n\t\t\t\t\tnumber=rowArray_[1]->getNumElements();\n\t\t\t\t\twhich=rowArray_[1]->getIndices();\n\n\t\t\t\t\tfor (iIndex=0;iIndexcomp)\n\t\t\t\t\t\tprintf(\"Bad dj %g for %d - true is %g\\n\",\n\t\t\t\t\t\t\t dj_[iSeq],iSeq,djval);\n\t\t\t\t\tassert (fabs(djval)<1.0e-3||djval*dj_[iSeq]>0.0);\n\t\t\t\t\trowArray_[1]->clear();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n#endif\n\n\t\t// we found a pivot column\n\t\t// update the incoming column\n\t\tunpackPacked(rowArray_[1]);\n\t\t// save reduced cost\n\t\tdouble saveDj = dualIn_;\n\t\tfactorization_->updateColumnFT(rowArray_[2],rowArray_[1]);\n\t\t// Get extra rows\n\t\tmatrix_->extendUpdated(this,rowArray_[1],0);\n\t\t// do ratio test and re-compute dj\n\t\tprimalRow(rowArray_[1],rowArray_[3],rowArray_[2],rowArray_[0],\n\t\t\t\t ifValuesPass);\n\n\n\n\t\t//TODO: We are heading to an actual pivot. Clear the flags for the next iteration\n\n\t\t// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\n\n\t\t//if (CyPivotIsAcceptable(static_cast(this)) == 0)\n\t\tif (!isPivotAcceptable())\n\t\t\t{\n\t\t\treturnCode = -5;\n\t\t\tclearAll();\n\t\t\tpivotRow_=-1;\n\t\t\tbreak;\n\t\t\t}\n\n\t\tif (ifValuesPass) {\n\t\t\tsaveDj=dualIn_;\n\t\t\t//assert (fabs(alpha_)>=1.0e-5||(objective_->type()<2||!objective_->activated())||pivotRow_==-2);\n\t\t\tif (pivotRow_==-1||(pivotRow_>=0&&fabs(alpha_)<1.0e-5)) {\n\t\t\t\tif(fabs(dualIn_)<1.0e2*dualTolerance_&&objective_->type()<2) {\n\t\t\t\t\t// try other way\n\t\t\t\t\tdirectionIn_=-directionIn_;\n\t\t\t\t\tprimalRow(rowArray_[1],rowArray_[3],rowArray_[2],rowArray_[0],\n\t\t\t\t\t\t\t 0);\n\t\t\t\t}\n\t\t\t\tif (pivotRow_==-1||(pivotRow_>=0&&fabs(alpha_)<1.0e-5)) {\n\t\t\t\t\tif (solveType_==1) {\n\t\t\t\t\t\t// reject it\n\t\t\t\t\t\tchar x = isColumn(sequenceIn_) ? 'C' :'R';\n\t\t\t\t\t\thandler_->message(CLP_SIMPLEX_FLAG,messages_)\n\t\t\t\t\t\t<extendUpdated(this,rowArray_[1],1);\n\t\tdouble checkValue=1.0e-2;\n\t\tif (largestDualError_>1.0e-5)\n\t\t\tcheckValue=1.0e-1;\n\t\tdouble test2 = dualTolerance_;\n\t\tdouble test1 = 1.0e-20;\n#if 0 //def FEB_TRY\n\t\tif (factorization_->pivots()<1) {\n\t\t\ttest1 = -1.0e-4;\n\t\t\tif ((saveDj<0.0&&dualIn_<-1.0e-5*dualTolerance_)||\n\t\t\t\t(saveDj>0.0&&dualIn_>1.0e-5*dualTolerance_))\n\t\t\t\ttest2=0.0; // allow through\n\t\t}\n#endif\n\t\tif (!ifValuesPass&&solveType_==1&&(saveDj*dualIn_checkValue*(1.0+fabs(saveDj))||\n\t\t\t\t\t\t\t\t\t\t fabs(dualIn_)message(CLP_PRIMAL_DJ,messages_)\n\t\t\t<checkInfeasibilities(0.0);\n\t\t\t\t}\n\t\t\t\tsequenceOut_=-1;\n\t\t\t\tbreak;\n\t\t\t} else {\n\t\t\t\t// take on more relaxed criterion\n\t\t\t\tif (saveDj*dualIn_2.0e-1*(1.0+fabs(dualIn_))||\n\t\t\t\t\tfabs(dualIn_)message(CLP_SIMPLEX_FLAG,messages_)\n\t\t\t\t\t<saferTolerances (1.0e-15,-1.03);\n#endif\n\t\t\t\t\tprogress_.clearBadTimes();\n\t\t\t\t\tlastBadIteration_ = numberIterations_; // say be more cautious\n\t\t\t\t\tclearAll();\n\t\t\t\t\tpivotRow_=-1;\n\t\t\t\t\treturnCode=-5;\n\t\t\t\t\tsequenceOut_=-1;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tif (pivotRow_>=0) {\n\t\t\tif (solveType_==2) {\n\t\t\t\t// **** Coding for user interface\n\t\t\t\t// do ray\n\t\t\t\tprimalRay(rowArray_[1]);\n\t\t\t\t// update duals\n\t\t\t\t// as packed need to find pivot row\n\t\t\t\t//assert (rowArray_[1]->packedMode());\n\t\t\t\t//int i;\n\n\t\t\t\t//alpha_ = rowArray_[1]->denseVector()[pivotRow_];\n\t\t\t\tCoinAssert (fabs(alpha_)>1.0e-8);\n\t\t\t\tdouble multiplier = dualIn_/alpha_;\n\t\t\t\trowArray_[0]->insert(pivotRow_,multiplier);\n\t\t\t\tfactorization_->updateColumnTranspose(rowArray_[2],rowArray_[0]);\n\t\t\t\t// put row of tableau in rowArray[0] and columnArray[0]\n\t\t\t\tmatrix_->transposeTimes(this,-1.0,\n\t\t\t\t\t\t\t\t\t\trowArray_[0],columnArray_[1],columnArray_[0]);\n\t\t\t\t// update column djs\n\t\t\t\tint i;\n\t\t\t\tint * index = columnArray_[0]->getIndices();\n\t\t\t\tint number = columnArray_[0]->getNumElements();\n\t\t\t\tdouble * element = columnArray_[0]->denseVector();\n\t\t\t\tfor (i=0;isetNumElements(0);\n\t\t\t\t// and row djs\n\t\t\t\tindex = rowArray_[0]->getIndices();\n\t\t\t\tnumber = rowArray_[0]->getNumElements();\n\t\t\t\telement = rowArray_[0]->denseVector();\n\t\t\t\tfor (i=0;isetNumElements(0);\n\t\t\t\t// check incoming\n\t\t\t\tCoinAssert (fabs(dj_[sequenceIn_])<1.0e-1);\n\t\t\t}\n\t\t\t// if stable replace in basis\n\t\t\t// If gub or odd then alpha and pivotRow may change\n\t\t\tint updateType=0;\n\t\t\tint updateStatus = matrix_->generalExpanded(this,3,updateType);\n\t\t\tif (updateType>=0)\n\t\t\t\tupdateStatus = factorization_->replaceColumn(this,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t rowArray_[2],\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t rowArray_[1],\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t pivotRow_,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t alpha_,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t (moreSpecialOptions_&16)!=0);\n\n\t\t\t// if no pivots, bad update but reasonable alpha - take and invert\n\t\t\tif (updateStatus==2&&\n\t\t\t\tlastGoodIteration_==numberIterations_&&fabs(alpha_)>1.0e-5)\n\t\t\t\tupdateStatus=4;\n\t\t\tif (updateStatus==1||updateStatus==4) {\n\t\t\t\t// slight error\n\t\t\t\tif (factorization_->pivots()>5||updateStatus==4) {\n\t\t\t\t\treturnCode=-3;\n\t\t\t\t}\n\t\t\t} else if (updateStatus==2) {\n\t\t\t\t// major error\n\t\t\t\t// better to have small tolerance even if slower\n\t\t\t\tfactorization_->zeroTolerance(std::min(factorization_->zeroTolerance(),1.0e-15));\n\t\t\t\tint maxFactor = factorization_->maximumPivots();\n\t\t\t\tif (maxFactor>10) {\n\t\t\t\t\tif (forceFactorization_<0)\n\t\t\t\t\t\tforceFactorization_= maxFactor;\n\t\t\t\t\tforceFactorization_ = std::max(1,(forceFactorization_>>1));\n\t\t\t\t}\n\t\t\t\t// later we may need to unwind more e.g. fake bounds\n\t\t\t\tif(lastGoodIteration_ != numberIterations_) {\n\t\t\t\t\tclearAll();\n\t\t\t\t\tpivotRow_=-1;\n\t\t\t\t\tif (solveType_==1) {\n\t\t\t\t\t\treturnCode=-4;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// user in charge - re-factorize\n\t\t\t\t\t\tint lastCleaned=0;\n\t\t\t\t\t\tClpSimplexProgress dummyProgress;\n\t\t\t\t\t\tif (saveStatus_)\n\t\t\t\t\t\t\tstatusOfProblemInPrimal(lastCleaned,1,&dummyProgress,true,ifValuesPass);\n\t\t\t\t\t\telse\n\t\t\t\t\t\t\tstatusOfProblemInPrimal(lastCleaned,0,&dummyProgress,true,ifValuesPass);\n\t\t\t\t\t\troundAgain=true;\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\t// need to reject something\n\t\t\t\t\tif (solveType_==1) {\n\t\t\t\t\t\tchar x = isColumn(sequenceIn_) ? 'C' :'R';\n\t\t\t\t\t\thandler_->message(CLP_SIMPLEX_FLAG,messages_)\n\t\t\t\t\t\t<pivots()<\n\t\t\t\t\t0.5*factorization_->maximumPivots()&&\n\t\t\t\t\tfactorization_->pivots()<200)\n\t\t\t\t\tfactorization_->areaFactor(\n\t\t\t\t\t\t\t\t\t\t\t factorization_->areaFactor() * 1.1);\n\t\t\t\treturnCode =-2; // factorize now\n\t\t\t} else if (updateStatus==5) {\n\t\t\t\tproblemStatus_=-2; // factorize now\n\t\t\t}\n\t\t\t// here do part of steepest - ready for next iteration\n\t\t\tif (!ifValuesPass)\n\t\t\t\tprimalColumnPivot_->updateWeights(rowArray_[1]);\n\t\t} else {\n\t\t\tif (pivotRow_==-1) {\n\t\t\t\t// no outgoing row is valid\n\t\t\t\tif (valueOut_!=COIN_DBL_MAX) {\n\t\t\t\t\tdouble objectiveChange=0.0;\n\t\t\t\t\ttheta_=valueOut_-valueIn_;\n\t\t\t\t\tupdatePrimalsInPrimal(rowArray_[1],theta_, objectiveChange,ifValuesPass);\n\t\t\t\t\tsolution_[sequenceIn_] += theta_;\n\t\t\t\t}\n\t\t\t\trowArray_[0]->clear();\n\t\t\t\tif (!factorization_->pivots()&&acceptablePivot_<=1.0e-8) {\n\t\t\t\t\treturnCode = 2; //say looks unbounded\n\t\t\t\t\t// do ray\n\t\t\t\t\tprimalRay(rowArray_[1]);\n\t\t\t\t} else if (solveType_==2) {\n\t\t\t\t\t// refactorize\n\t\t\t\t\tint lastCleaned=0;\n\t\t\t\t\tClpSimplexProgress dummyProgress;\n\t\t\t\t\tif (saveStatus_)\n\t\t\t\t\t\tstatusOfProblemInPrimal(lastCleaned,1,&dummyProgress,true,ifValuesPass);\n\t\t\t\t\telse\n\t\t\t\t\t\tstatusOfProblemInPrimal(lastCleaned,0,&dummyProgress,true,ifValuesPass);\n\t\t\t\t\troundAgain=true;\n\t\t\t\t\tcontinue;\n\t\t\t\t} else {\n\t\t\t\t\tacceptablePivot_=1.0e-8;\n\t\t\t\t\treturnCode = 4; //say looks unbounded but has iterated\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t} else {\n\t\t\t\t// flipping from bound to bound\n\t\t\t}\n\t\t}\n\n\t\tdouble oldCost = 0.0;\n\t\tif (sequenceOut_>=0)\n\t\t\toldCost=cost_[sequenceOut_];\n\t\t// update primal solution\n\n\t\tdouble objectiveChange=0.0;\n\t\t// after this rowArray_[1] is not empty - used to update djs\n\t\t// If pivot row >= numberRows then may be gub\n\t\tint savePivot = pivotRow_;\n\t\tif (pivotRow_>=numberRows_)\n\t\t\tpivotRow_=-1;\n\t\tupdatePrimalsInPrimal(rowArray_[1],theta_, objectiveChange,ifValuesPass);\n\t\tpivotRow_=savePivot;\n\n\t\tdouble oldValue = valueIn_;\n\t\tif (directionIn_==-1) {\n\t\t\t// as if from upper bound\n\t\t\tif (sequenceIn_!=sequenceOut_) {\n\t\t\t\t// variable becoming basic\n\t\t\t\tvalueIn_ -= fabs(theta_);\n\t\t\t} else {\n\t\t\t\tvalueIn_=lowerIn_;\n\t\t\t}\n\t\t} else {\n\t\t\t// as if from lower bound\n\t\t\tif (sequenceIn_!=sequenceOut_) {\n\t\t\t\t// variable becoming basic\n\t\t\t\tvalueIn_ += fabs(theta_);\n\t\t\t} else {\n\t\t\t\tvalueIn_=upperIn_;\n\t\t\t}\n\t\t}\n\t\tobjectiveChange += dualIn_*(valueIn_-oldValue);\n\t\t// outgoing\n\t\tif (sequenceIn_!=sequenceOut_) {\n\t\t\tif (directionOut_>0) {\n\t\t\t\tvalueOut_ = lowerOut_;\n\t\t\t} else {\n\t\t\t\tvalueOut_ = upperOut_;\n\t\t\t}\n\t\t\tif(valueOut_upper_[sequenceOut_]+primalTolerance_)\n\t\t\t\tvalueOut_=upper_[sequenceOut_]+0.9*primalTolerance_;\n\t\t\t// may not be exactly at bound and bounds may have changed\n\t\t\t// Make sure outgoing looks feasible\n\t\t\tdirectionOut_=nonLinearCost_->setOneOutgoing(sequenceOut_,valueOut_);\n\t\t\t// May have got inaccurate\n\t\t\t//if (oldCost!=cost_[sequenceOut_])\n\t\t\t//printf(\"costchange on %d from %g to %g\\n\",sequenceOut_,\n\t\t\t// oldCost,cost_[sequenceOut_]);\n\t\t\tif (solveType_!=2)\n\t\t\t\tdj_[sequenceOut_]=cost_[sequenceOut_]-oldCost; // normally updated next iteration\n\t\t\tsolution_[sequenceOut_]=valueOut_;\n\t\t}\n\t\t// change cost and bounds on incoming if primal\n\t\tnonLinearCost_->setOne(sequenceIn_,valueIn_);\n\t\tint whatNext=housekeeping(objectiveChange);\n\t\t//nonLinearCost_->validate();\n#if CLP_DEBUG >1\n\t\t{\n\t\t\tdouble sum;\n\t\t\tint ninf= matrix_->checkFeasible(this,sum);\n\t\t\tif (ninf)\n\t\t\t\tprintf(\"infeas %d\\n\",ninf);\n\t\t}\n#endif\n\t\tif (whatNext==1) {\n\t\t\treturnCode =-2; // refactorize\n\t\t} else if (whatNext==2) {\n\t\t\t// maximum iterations or equivalent\n\t\t\treturnCode=3;\n\t\t} else if(numberIterations_ == lastGoodIteration_\n\t\t\t\t + 2 * factorization_->maximumPivots()) {\n\t\t\t// done a lot of flips - be safe\n\t\t\treturnCode =-2; // refactorize\n\t\t}\n\t\t// Check event\n\t\t{\n\t\t\tint status = eventHandler_->event(ClpEventHandler::endOfIteration);\n\t\t\tif (status>=0) {\n\t\t\t\tproblemStatus_=5;\n\t\t\t\tsecondaryStatus_=ClpEventHandler::endOfIteration;\n\t\t\t\treturnCode=3;\n\t\t\t}\n\t\t}\n\t}\n\tif (solveType_==2&&(returnCode == -2||returnCode==-3)) {\n\t\t// refactorize here\n\t\tint lastCleaned=0;\n\t\tClpSimplexProgress dummyProgress;\n\t\tif (saveStatus_)\n\t\t\tstatusOfProblemInPrimal(lastCleaned,1,&dummyProgress,true,ifValuesPass);\n\t\telse\n\t\t\tstatusOfProblemInPrimal(lastCleaned,0,&dummyProgress,true,ifValuesPass);\n\t\tif (problemStatus_==5) {\n\t\t\tprintf(\"Singular basis\\n\");\n\t\t\tproblemStatus_=-1;\n\t\t\treturnCode=5;\n\t\t}\n\t}\n#ifdef CLP_DEBUG\n\t{\n\t\tint i;\n\t\t// not [1] as may have information\n\t\tfor (i=0;i<4;i++) {\n\t\t\tif (i!=1)\n\t\t\t\trowArray_[i]->checkClear();\n\t\t}\n\t\tfor (i=0;i<2;i++) {\n\t\t\tcolumnArray_[i]->checkClear();\n\t\t}\n\t}\n#endif\n\n// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n// \t\tif (QP_ExistsBannedVariable && returnCode != -5 && returnCode != -4)\n// \t\t\t{\n// \t\t\tstd::cout << \"resetting banlist@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\\n\";\n// \t\t\tint listSize = numberRows() + numberColumns();\n// \t\t\tfor (int ii = 0 ; ii < listSize ; ii++)\n// \t\t\t\tQP_BanList[ii] = 0;\n// \t\t\tQP_ExistsBannedVariable = 0;\n// \t\t\t}\n// // @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n// \tstd::cout << \"return code: \" << returnCode << \"\\n\";\n\t//if (returnCode != -1 && returnCode!= -4 && returnCode != -5)\n\t//{\n\t//\tstd::cout << \"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\\n\";\n\t//}\n\n// \tif (returnCodeBack == -5 && returnCode != -5)\n// \t\tassert(0);\n//\tstd::cout << \"return code: \" << returnCode << \"\\n\";\n\treturn returnCode;\n}\n// Create primal ray\nvoid\nIClpSimplexPrimal::primalRay(CoinIndexedVector * rowArray)\n{\n\tdelete [] ray_;\n\tray_ = new double [numberColumns_];\n\tCoinZeroN(ray_,numberColumns_);\n\tint number=rowArray->getNumElements();\n\tint * index = rowArray->getIndices();\n\tdouble * array = rowArray->denseVector();\n\tdouble way=-directionIn_;\n\tint i;\n\tdouble zeroTolerance=1.0e-12;\n\tif (sequenceIn_packedMode()) {\n\t\tfor (i=0;i=zeroTolerance)\n\t\t\t\tray_[iPivot] = way* arrayValue;\n\t\t}\n\t} else {\n\t\tfor (i=0;i=zeroTolerance)\n\t\t\t\tray_[iPivot] = way* arrayValue;\n\t\t}\n\t}\n}\n/* Get next superbasic -1 if none,\n Normal type is 1\n If type is 3 then initializes sorted list\n if 2 uses list.\n */\nint\nIClpSimplexPrimal::nextSuperBasic(int superBasicType,CoinIndexedVector * columnArray)\n{\n\tif (firstFree_>=0&&superBasicType) {\n\t\tint returnValue=-1;\n\t\tbool finished=false;\n\t\twhile (!finished) {\n\t\t\treturnValue=firstFree_;\n\t\t\tint iColumn=firstFree_+1;\n\t\t\tif (superBasicType>1) {\n\t\t\t\tif (superBasicType>2) {\n\t\t\t\t\t// Initialize list\n\t\t\t\t\t// Wild guess that lower bound more natural than upper\n\t\t\t\t\tint number=0;\n\t\t\t\t\tdouble * work=columnArray->denseVector();\n\t\t\t\t\tint * which=columnArray->getIndices();\n\t\t\t\t\tfor (iColumn=0;iColumn1.0e20) {\n\t\t\t\t\t\t\t\t\tsetStatus(iColumn,isFree);\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t} else if (!flagged(iColumn)) {\n\t\t\t\t\t\t\t\t\t// put ones near bounds at end after sorting\n\t\t\t\t\t\t\t\t\twork[number]= - std::min(0.1*(solution_[iColumn]-lower_[iColumn]),\n\t\t\t\t\t\t\t\t\t\t\t\t\t\t\tupper_[iColumn]-solution_[iColumn]);\n\t\t\t\t\t\t\t\t\twhich[number++] = iColumn;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tCoinSort_2(work,work+number,which);\n\t\t\t\t\tcolumnArray->setNumElements(number);\n\t\t\t\t\tCoinZeroN(work,number);\n\t\t\t\t}\n\t\t\t\tint * which=columnArray->getIndices();\n\t\t\t\tint number = columnArray->getNumElements();\n\t\t\t\tif (!number) {\n\t\t\t\t\t// finished\n\t\t\t\t\tiColumn = numberRows_+numberColumns_;\n\t\t\t\t\treturnValue=-1;\n\t\t\t\t} else {\n\t\t\t\t\tnumber--;\n\t\t\t\t\treturnValue=which[number];\n\t\t\t\t\tiColumn=returnValue;\n\t\t\t\t\tcolumnArray->setNumElements(number);\n\t\t\t\t}\n\t\t\t} else {\n\t\t\t\tfor (;iColumn1.0e20) {\n\t\t\t\t\t\t\t\tsetStatus(iColumn,isFree);\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tfirstFree_ = iColumn;\n\t\t\tfinished=true;\n\t\t\tif (firstFree_==numberRows_+numberColumns_)\n\t\t\t\tfirstFree_=-1;\n\t\t\tif (returnValue>=0&&getStatus(returnValue)!=superBasic&&getStatus(returnValue)!=isFree)\n\t\t\t\tfinished=false; // somehow picked up odd one\n\t\t}\n\t\treturn returnValue;\n\t} else {\n\t\treturn -1;\n\t}\n}\nvoid\nIClpSimplexPrimal::clearAll()\n{\n\t// Clean up any gub stuff\n\tmatrix_->extendUpdated(this,rowArray_[1],1);\n\tint number=rowArray_[1]->getNumElements();\n\tint * which=rowArray_[1]->getIndices();\n\n\tint iIndex;\n\tfor (iIndex=0;iIndexclear();\n\t// make sure any gub sets are clean\n\tmatrix_->generalExpanded(this,11,sequenceIn_);\n\n}\n// Sort of lexicographic resolve\nint\nIClpSimplexPrimal::lexSolve()\n{\n\talgorithm_ = +1;\n\t//specialOptions_ |= 4;\n\n\t// save data\n\tClpDataSave data = saveData();\n\tmatrix_->refresh(this); // make sure matrix okay\n\n\t// Save so can see if doing after dual\n\tint initialStatus=problemStatus_;\n\tint initialIterations = numberIterations_;\n\tint initialNegDjs=-1;\n\t// initialize - maybe values pass and algorithm_ is +1\n\tint ifValuesPass=0;\n#if 0\n\t// if so - put in any superbasic costed slacks\n\tif (ifValuesPass&&specialOptions_<0x01000000) {\n\t\t// Get column copy\n\t\tconst CoinPackedMatrix * columnCopy = matrix();\n\t\tconst int * row = columnCopy->getIndices();\n\t\tconst CoinBigIndex * columnStart = columnCopy->getVectorStarts();\n\t\tconst int * columnLength = columnCopy->getVectorLengths();\n\t\t//const double * element = columnCopy->getElements();\n\t\tint n=0;\n\t\tfor (int iColumn = 0;iColumnprimalTolerance_&&\n\t\t\t\t\t\tfabs(value-columnUpper_[iColumn])>primalTolerance_) {\n\t\t\t\t\t\tint iRow = row[columnStart[iColumn]];\n\t\t\t\t\t\tif (getRowStatus(iRow)==basic) {\n\t\t\t\t\t\t\tsetRowStatus(iRow,superBasic);\n\t\t\t\t\t\t\tsetColumnStatus(iColumn,basic);\n\t\t\t\t\t\t\tn++;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tprintf(\"%d costed slacks put in basis\\n\",n);\n\t}\n#endif\n\tdouble * originalCost = NULL;\n\tdouble * originalLower = NULL;\n\tdouble * originalUpper = NULL;\n\tif (!startup(0,0)) {\n\n\t\t// Set average theta\n\t\tnonLinearCost_->setAverageTheta(1.0e3);\n\t\tint lastCleaned=0; // last time objective or bounds cleaned up\n\n\t\t// Say no pivot has occurred (for steepest edge and updates)\n\t\tpivotRow_=-2;\n\n\t\t// This says whether to restore things etc\n\t\tint factorType=0;\n\t\tif (problemStatus_<0&&perturbation_<100) {\n\t\t\tperturb(0);\n\t\t\t// Can't get here if values pass\n\t\t\tassert (!ifValuesPass);\n\t\t\tgutsOfSolution(NULL,NULL);\n\t\t\tif (handler_->logLevel()>2) {\n\t\t\t\thandler_->message(CLP_SIMPLEX_STATUS,messages_)\n\t\t\t\t<printing(sumPrimalInfeasibilities_>0.0)\n\t\t\t\t<printing(sumDualInfeasibilities_>0.0)\n\t\t\t\t<printing(numberDualInfeasibilitiesWithoutFree_\n\t\t\t\t\t\t\t\t message()<clear();\n\t\t\t}\n\n\t\t\tfor (iColumn=0;iColumn<2;iColumn++) {\n\t\t\t\tcolumnArray_[iColumn]->clear();\n\t\t\t}\n\n\t\t\t// give matrix (and model costs and bounds a chance to be\n\t\t\t// refreshed (normally null)\n\t\t\tmatrix_->refresh(this);\n\t\t\t// If getting nowhere - why not give it a kick\n#if 1\n\t\t\tif (perturbation_<101&&numberIterations_>2*(numberRows_+numberColumns_)&&(specialOptions_&4)==0\n\t\t\t\t&&initialStatus!=10) {\n\t\t\t\tperturb(1);\n\t\t\t\tmatrix_->rhsOffset(this,true,false);\n\t\t\t}\n#endif\n\t\t\t// If we have done no iterations - special\n\t\t\tif (lastGoodIteration_==numberIterations_&&factorType)\n\t\t\t\tfactorType=3;\n\t\t\tif (saveModel) {\n\t\t\t\t// Doing sprint\n\t\t\t\tif (sequenceIn_<0||numberIterations_>=stopSprint) {\n\t\t\t\t\tproblemStatus_=-1;\n\t\t\t\t\toriginalModel(saveModel);\n\t\t\t\t\tsaveModel=NULL;\n\t\t\t\t\tif (sequenceIn_<0&&numberIterations_100)\n\t\t\t\t\t\tprimalColumnPivot_->switchOffSprint();\n\t\t\t\t\t//lastSprintIteration=numberIterations_;\n\t\t\t\t\tprintf(\"End small model\\n\");\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// may factorize, checks if problem finished\n\t\t\tstatusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,ifValuesPass,saveModel);\n\t\t\tif (initialStatus==10) {\n\t\t\t\t// cleanup phase\n\t\t\t\tif(initialIterations != numberIterations_) {\n\t\t\t\t\tif (numberDualInfeasibilities_>10000&&numberDualInfeasibilities_>10*initialNegDjs) {\n\t\t\t\t\t\t// getting worse - try perturbing\n\t\t\t\t\t\tif (perturbation_<101&&(specialOptions_&4)==0) {\n\t\t\t\t\t\t\tperturb(1);\n\t\t\t\t\t\t\tmatrix_->rhsOffset(this,true,false);\n\t\t\t\t\t\t\tstatusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,ifValuesPass,saveModel);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\t// save number of negative djs\n\t\t\t\t\tif (!numberPrimalInfeasibilities_)\n\t\t\t\t\t\tinitialNegDjs=numberDualInfeasibilities_;\n\t\t\t\t\t// make sure weight won't be changed\n\t\t\t\t\tif (infeasibilityCost_==1.0e10)\n\t\t\t\t\t\tinfeasibilityCost_=1.000001e10;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// See if sprint says redo because of problems\n\t\t\tif (numberDualInfeasibilities_==-776) {\n\t\t\t\t// Need new set of variables\n\t\t\t\tproblemStatus_=-1;\n\t\t\t\toriginalModel(saveModel);\n\t\t\t\tsaveModel=NULL;\n\t\t\t\t//lastSprintIteration=numberIterations_;\n\t\t\t\tprintf(\"End small model after\\n\");\n\t\t\t\tstatusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,ifValuesPass,saveModel);\n\t\t\t}\n\t\t\tint numberSprintIterations=0;\n\t\t\tint numberSprintColumns = primalColumnPivot_->numberSprintColumns(numberSprintIterations);\n\t\t\tif (problemStatus_==777) {\n\t\t\t\t// problems so do one pass with normal\n\t\t\t\tproblemStatus_=-1;\n\t\t\t\toriginalModel(saveModel);\n\t\t\t\tsaveModel=NULL;\n\t\t\t\t// Skip factorization\n\t\t\t\t//statusOfProblemInPrimal(lastCleaned,factorType,&progress_,false,saveModel);\n\t\t\t\tstatusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,ifValuesPass,saveModel);\n\t\t\t} else if (problemStatus_<0&&!saveModel&&numberSprintColumns&&firstFree_<0) {\n\t\t\t\tint numberSort=0;\n\t\t\t\tint numberFixed=0;\n\t\t\t\tint numberBasic=0;\n\t\t\t\treasonableSprintIteration = numberIterations_ + 100;\n\t\t\t\tint * whichColumns = new int[numberColumns_];\n\t\t\t\tdouble * weight = new double[numberColumns_];\n\t\t\t\tint numberNegative=0;\n\t\t\t\tdouble sumNegative = 0.0;\n\t\t\t\t// now massage weight so all basic in plus good djs\n\t\t\t\tfor (iColumn=0;iColumn-1.0e50) {\n\t\t\t\t\t\tnumberNegative++;\n\t\t\t\t\t\tsumNegative -= dj;\n\t\t\t\t\t}\n\t\t\t\t\tweight[iColumn]=dj;\n\t\t\t\t\twhichColumns[iColumn] = iColumn;\n\t\t\t\t}\n\t\t\t\thandler_->message(CLP_SPRINT,messages_)\n\t\t\t\t<lastObjectiveValue-1.0e-7&&sprintPass>5) {\n\t\t\t\t\t// switch off\n\t\t\t\t\tprintf(\"Switching off sprint\\n\");\n\t\t\t\t\tprimalColumnPivot_->switchOffSprint();\n\t\t\t\t} else {\n\t\t\t\t\tlastObjectiveValue = objectiveValue()*optimizationDirection_;\n\t\t\t\t\t// sort\n\t\t\t\t\tCoinSort_2(weight,weight+numberColumns_,whichColumns);\n\t\t\t\t\tnumberSort = std::min(numberColumns_-numberFixed,numberBasic+numberSprintColumns);\n\t\t\t\t\t// Sort to make consistent ?\n\t\t\t\t\tstd::sort(whichColumns,whichColumns+numberSort);\n\t\t\t\t\tsaveModel = new IClpSimplex(this,numberSort,whichColumns);\n\t\t\t\t\tdelete [] whichColumns;\n\t\t\t\t\tdelete [] weight;\n\t\t\t\t\t// Skip factorization\n\t\t\t\t\t//statusOfProblemInPrimal(lastCleaned,factorType,&progress_,false,saveModel);\n\t\t\t\t\t//statusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,saveModel);\n\t\t\t\t\tstopSprint = numberIterations_+numberSprintIterations;\n\t\t\t\t\tprintf(\"Sprint with %d columns for %d iterations\\n\",\n\t\t\t\t\t\t numberSprintColumns,numberSprintIterations);\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// Say good factorization\n\t\t\tfactorType=1;\n\n\t\t\t// Say no pivot has occurred (for steepest edge and updates)\n\t\t\tpivotRow_=-2;\n\n\t\t\t// exit if victory declared\n\t\t\tif (problemStatus_>=0) {\n\t\t\t\tif (originalCost) {\n\t\t\t\t\t// find number nonbasic with zero reduced costs\n\t\t\t\t\tint numberDegen=0;\n\t\t\t\t\tint numberTotal = numberColumns_; //+numberRows_;\n\t\t\t\t\tfor (int i=0;i=-dualTolerance_) {\n\t\t\t\t\t\t\t\tcost_[i]=(numberTotal-i)+randomNumberGenerator_.randomDouble()*0.5;\n\t\t\t\t\t\t\t\tnumberDegen++;\n\t\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t\t// fix\n\t\t\t\t\t\t\t\tcost_[i]=-1.0e10;//lower_[i]=upper_[i];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t} else if (getStatus(i)==basic) {\n\t\t\t\t\t\t\tcost_[i] = (numberTotal-i)+randomNumberGenerator_.randomDouble()*0.5;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tproblemStatus_=-1;\n\t\t\t\t\tlastObjectiveValue=COIN_DBL_MAX;\n\t\t\t\t\t// Start check for cycles\n\t\t\t\t\tprogress_.fillFromModel(this);\n\t\t\t\t\tprogress_.startCheck();\n\t\t\t\t\tprintf(\"%d degenerate after %d iterations\\n\",numberDegen,\n\t\t\t\t\t\t numberIterations_);\n\t\t\t\t\tif (!numberDegen) {\n\t\t\t\t\t\tCoinMemcpyN(originalCost,numberTotal,cost_);\n\t\t\t\t\t\tdelete [] originalCost;\n\t\t\t\t\t\toriginalCost=NULL;\n\t\t\t\t\t\tCoinMemcpyN(originalLower,numberTotal,lower_);\n\t\t\t\t\t\tdelete [] originalLower;\n\t\t\t\t\t\tCoinMemcpyN(originalUpper,numberTotal,upper_);\n\t\t\t\t\t\tdelete [] originalUpper;\n\t\t\t\t\t}\n\t\t\t\t\tdelete nonLinearCost_;\n\t\t\t\t\tnonLinearCost_ = new ClpNonLinearCost(this);\n\t\t\t\t\tprogress_.endOddState();\n\t\t\t\t\tcontinue;\n\t\t\t\t} else {\n\t\t\t\t\tprintf(\"exiting after %d iterations\\n\",numberIterations_);\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\t// test for maximum iterations\n\t\t\tif (hitMaximumIterations()||(ifValuesPass==2&&firstFree_<0)) {\n\t\t\t\tproblemStatus_=3;\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tif (firstFree_<0) {\n\t\t\t\tif (ifValuesPass) {\n\t\t\t\t\t// end of values pass\n\t\t\t\t\tifValuesPass=0;\n\t\t\t\t\tint status = eventHandler_->event(ClpEventHandler::endOfValuesPass);\n\t\t\t\t\tif (status>=0) {\n\t\t\t\t\t\tproblemStatus_=5;\n\t\t\t\t\t\tsecondaryStatus_=ClpEventHandler::endOfValuesPass;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Check event\n\t\t\t{\n\t\t\t\tint status = eventHandler_->event(ClpEventHandler::endOfFactorization);\n\t\t\t\tif (status>=0) {\n\t\t\t\t\tproblemStatus_=5;\n\t\t\t\t\tsecondaryStatus_=ClpEventHandler::endOfFactorization;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Iterate\n\t\t\twhileIterating(ifValuesPass ? 1 : 0);\n\t\t}\n\t}\n\tassert (!originalCost);\n\t// if infeasible get real values\n\t//printf(\"XXXXY final cost %g\\n\",infeasibilityCost_);\n\tprogress_.initialWeight_=0.0;\n\tif (problemStatus_==1&&secondaryStatus_!=6) {\n\t\tinfeasibilityCost_=0.0;\n\t\tcreateRim(1+4);\n\t\tnonLinearCost_->checkInfeasibilities(0.0);\n\t\tsumPrimalInfeasibilities_=nonLinearCost_->sumInfeasibilities();\n\t\tnumberPrimalInfeasibilities_= nonLinearCost_->numberInfeasibilities();\n\t\t// and get good feasible duals\n\t\tcomputeDuals(NULL);\n\t}\n\t// clean up\n\tunflag();\n\tfinish(0);\n\trestoreData(data);\n\treturn problemStatus_;\n}\n"
},
{
"path": "cylp/cpp/IClpSimplexPrimal.hpp",
"content": "// Copyright (C) 2002, International Business Machines\n// Corporation and others. All Rights Reserved.\n\n/*\n Authors\n\n John Forrest\n\n */\n#ifndef IClpSimplexPrimal_H\n#define IClpSimplexPrimal_H\n\n#include \"IClpSimplex.hpp\"\n\n\n/** This solves LPs using the primal simplex method\n\n It inherits from IClpSimplex. It has no data of its own and\n is never created - only cast from a IClpSimplex object at algorithm time.\n\n */\n\nclass IClpSimplexPrimal : public IClpSimplex{\n\npublic:\n\n\t/**@name Description of algorithm */\n\t//@{\n\t/** Primal algorithm\n\n\t Method\n\n It tries to be a single phase approach with a weight of 1.0 being\n given to getting optimal and a weight of infeasibilityCost_ being\n given to getting primal feasible. In this version I have tried to\n be clever in a stupid way. The idea of fake bounds in dual\n seems to work so the primal analogue would be that of getting\n bounds on reduced costs (by a presolve approach) and using\n these for being above or below feasible region. I decided to waste\n memory and keep these explicitly. This allows for non-linear\n costs! I have not tested non-linear costs but will be glad\n to do something if a reasonable example is provided.\n\n The code is designed to take advantage of sparsity so arrays are\n seldom zeroed out from scratch or gone over in their entirety.\n The only exception is a full scan to find incoming variable for\n Dantzig row choice. For steepest edge we keep an updated list\n of dual infeasibilities (actually squares).\n On easy problems we don't need full scan - just\n pick first reasonable. This method has not been coded.\n\n One problem is how to tackle degeneracy and accuracy. At present\n I am using the modification of costs which I put in OSL and which was\n extended by Gill et al. I am still not sure whether we will also\n need explicit perturbation.\n\n The flow of primal is three while loops as follows:\n\n while (not finished) {\n\n\t while (not clean solution) {\n\n\t Factorize and/or clean up solution by changing bounds so\n\t primal feasible. If looks finished check fake primal bounds.\n\t Repeat until status is iterating (-1) or finished (0,1,2)\n\n\t }\n\n\t while (status==-1) {\n\n\t Iterate until no pivot in or out or time to re-factorize.\n\n\t Flow is:\n\n\t choose pivot column (incoming variable). if none then\n\t we are primal feasible so looks as if done but we need to\n\t break and check bounds etc.\n\n\t Get pivot column in tableau\n\n\t Choose outgoing row. If we don't find one then we look\n\t primal unbounded so break and check bounds etc. (Also the\n\t pivot tolerance is larger after any iterations so that may be\n\t reason)\n\n\t If we do find outgoing row, we may have to adjust costs to\n\t keep going forwards (anti-degeneracy). Check pivot will be stable\n\t and if unstable throw away iteration and break to re-factorize.\n\t If minor error re-factorize after iteration.\n\n\t Update everything (this may involve changing bounds on\n\t variables to stay primal feasible.\n\n\t }\n\n }\n\n TODO's (or maybe not)\n\n At present we never check we are going forwards. I overdid that in\n OSL so will try and make a last resort.\n\n Needs partial scan pivot in option.\n\n May need other anti-degeneracy measures, especially if we try and use\n loose tolerances as a way to solve in fewer iterations.\n\n I like idea of dynamic scaling. This gives opportunity to decouple\n different implications of scaling for accuracy, iteration count and\n feasibility tolerance.\n\n for use of exotic parameter startFinishoptions see IClpSimplex.hpp\n\t */\n\n\tint primal(int ifValuesPass=0, int startFinishOptions=0);\n\t//@}\n\n\t/**@name For advanced users */\n\t//@{\n\t/// Do not change infeasibility cost and always say optimal\n\tvoid alwaysOptimal(bool onOff);\n\tbool alwaysOptimal() const;\n\t/** Normally outgoing variables can go out to slightly negative\n\t values (but within tolerance) - this is to help stability and\n\t and degeneracy. This can be switched off\n\t */\n\tvoid exactOutgoing(bool onOff);\n\tbool exactOutgoing() const;\n\t//@}\n\n\t/**@name Functions used in primal */\n\t//@{\n\t/** This has the flow between re-factorizations\n\n\t Returns a code to say where decision to exit was made\n\t Problem status set to:\n\n\t -2 re-factorize\n\t -4 Looks optimal/infeasible\n\t -5 Looks unbounded\n\t +3 max iterations\n\n\t valuesOption has original value of valuesPass\n\t */\n\tint whileIterating(int valuesOption);\n\n\t/** Do last half of an iteration. This is split out so people can\n\t force incoming variable. If solveType_ is 2 then this may\n\t re-factorize while normally it would exit to re-factorize.\n\t Return codes\n\t Reasons to come out (normal mode/user mode):\n\t -1 normal\n\t -2 factorize now - good iteration/ NA\n\t -3 slight inaccuracy - refactorize - iteration done/ same but factor done\n\t -4 inaccuracy - refactorize - no iteration/ NA\n\t -5 something flagged - go round again/ pivot not possible\n\t +2 looks unbounded\n\t +3 max iterations (iteration done)\n\n\t With solveType_ ==2 this should\n\t Pivot in a variable and choose an outgoing one. Assumes primal\n\t feasible - will not go through a bound. Returns step length in theta\n\t Returns ray in ray_\n\t */\n\tint pivotResult(int ifValuesPass=0);\n\n\n\t/** The primals are updated by the given array.\n\t Returns number of infeasibilities.\n\t After rowArray will have cost changes for use next iteration\n\t */\n\tint updatePrimalsInPrimal(CoinIndexedVector * rowArray,\n\t\t\t\t\t\t\t double theta,\n\t\t\t\t\t\t\t double & objectiveChange,\n\t\t\t\t\t\t\t int valuesPass);\n\t/**\n\t Row array has pivot column\n\t This chooses pivot row.\n\t Rhs array is used for distance to next bound (for speed)\n\t For speed, we may need to go to a bucket approach when many\n\t variables go through bounds\n\t If valuesPass non-zero then compute dj for direction\n\t */\n\tvoid primalRow(CoinIndexedVector * rowArray,\n\t\t\t\t CoinIndexedVector * rhsArray,\n\t\t\t\t CoinIndexedVector * spareArray,\n\t\t\t\t CoinIndexedVector * spareArray2,\n\t\t\t\t int valuesPass);\n\n\t//@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\tvoid DantzigPrimalRow(CoinIndexedVector * rowArray,\n\t\t\t\t CoinIndexedVector * rhsArray,\n\t\t\t\t CoinIndexedVector * spareArray,\n\t\t\t\t CoinIndexedVector * spareArray2,\n\t\t\t\t int valuesPass);\n\t// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\t/**\n\t Chooses primal pivot column\n\t updateArray has cost updates (also use pivotRow_ from last iteration)\n\t Would be faster with separate region to scan\n\t and will have this (with square of infeasibility) when steepest\n\t For easy problems we can just choose one of the first columns we look at\n\t */\n\tvoid primalColumn(CoinIndexedVector * updateArray,\n\t\t\t\t\t CoinIndexedVector * spareRow1,\n\t\t\t\t\t CoinIndexedVector * spareRow2,\n\t\t\t\t\t CoinIndexedVector * spareColumn1,\n\t\t\t\t\t CoinIndexedVector * spareColumn2);\n\n\t/** Checks if tentative optimal actually means unbounded in primal\n\t Returns -3 if not, 2 if is unbounded */\n\tint checkUnbounded(CoinIndexedVector * ray,CoinIndexedVector * spare,\n\t\t\t\t\t double changeCost);\n\t/** Refactorizes if necessary\n\t Checks if finished. Updates status.\n\t lastCleaned refers to iteration at which some objective/feasibility\n\t cleaning too place.\n\n\t type - 0 initial so set up save arrays etc\n\t - 1 normal -if good update save\n\t - 2 restoring from saved\n\t saveModel is normally NULL but may not be if doing Sprint\n\t */\n\tvoid statusOfProblemInPrimal(int & lastCleaned, int type,\n\t\t\t\t\t\t\t\t ClpSimplexProgress * progress,\n\t\t\t\t\t\t\t\t bool doFactorization,\n\t\t\t\t\t\t\t\t int ifValuesPass,\n\t\t\t\t\t\t\t\t IClpSimplex * saveModel=NULL);\n\t/// Perturbs problem (method depends on perturbation())\n\tvoid perturb(int type);\n\t/// Take off effect of perturbation and say whether to try dual\n\tbool unPerturb();\n\t/// Unflag all variables and return number unflagged\n\tint unflag();\n\t/** Get next superbasic -1 if none,\n\t Normal type is 1\n\t If type is 3 then initializes sorted list\n\t if 2 uses list.\n\t */\n\tint nextSuperBasic(int superBasicType,CoinIndexedVector * columnArray);\n\n\t/// Create primal ray\n\tvoid primalRay(CoinIndexedVector * rowArray);\n\t/// Clears all bits and clears rowArray[1] etc\n\tvoid clearAll();\n\n\t/// Sort of lexicographic resolve\n\tint lexSolve();\n\n\t//@}\n\n\n};\n#endif\n\n"
},
{
"path": "cylp/cpp/IClpSimplexPrimal_Wolfe.cpp",
"content": "// Copyright (C) 2002, International Business Machines\n// Corporation and others. All Rights Reserved.\n\n/* Notes on implementation of primal simplex algorithm.\n \n When primal feasible(A):\n \n If dual feasible, we are optimal. Otherwise choose an infeasible\n basic variable to enter basis from a bound (B). We now need to find an \n outgoing variable which will leave problem primal feasible so we get\n the column of the tableau corresponding to the incoming variable\n (with the correct sign depending if variable will go up or down).\n \n We now perform a ratio test to determine which outgoing variable will\n preserve primal feasibility (C). If no variable found then problem\n is unbounded (in primal sense). If there is a variable, we then \n perform pivot and repeat. Trivial?\n \n -------------------------------------------\n \n A) How do we get primal feasible? All variables have fake costs\n outside their feasible region so it is trivial to declare problem\n feasible. OSL did not have a phase 1/phase 2 approach but\n instead effectively put an extra cost on infeasible basic variables\n I am taking the same approach here, although it is generalized\n to allow for non-linear costs and dual information.\n \n In OSL, this weight was changed heuristically, here at present\n it is only increased if problem looks finished. If problem is\n feasible I check for unboundedness. If not unbounded we \n could play with going into dual. As long as weights increase\n any algorithm would be finite.\n \n B) Which incoming variable to choose is a virtual base class.\n For difficult problems steepest edge is preferred while for\n very easy (large) problems we will need partial scan.\n \n C) Sounds easy, but this is hardest part of algorithm.\n 1) Instead of stopping at first choice, we may be able\n to allow that variable to go through bound and if objective\n still improving choose again. These mini iterations can\n increase speed by orders of magnitude but we may need to\n go to more of a bucket choice of variable rather than looking\n at them one by one (for speed).\n 2) Accuracy. Basic infeasibilities may be less than\n tolerance. Pivoting on these makes objective go backwards.\n OSL modified cost so a zero move was made, Gill et al\n modified so a strictly positive move was made.\n The two problems are that re-factorizations can\n change rinfeasibilities above and below tolerances and that when\n finished we need to reset costs and try again.\n 3) Degeneracy. Gill et al helps but may not be enough. We\n may need more. Also it can improve speed a lot if we perturb\n the rhs and bounds significantly. \n \n References:\n Forrest and Goldfarb, Steepest-edge simplex algorithms for\n linear programming - Mathematical Programming 1992\n Forrest and Tomlin, Implementing the simplex method for\n the Optimization Subroutine Library - IBM Systems Journal 1992\n Gill, Murray, Saunders, Wright A Practical Anti-Cycling\n Procedure for Linear and Nonlinear Programming SOL report 1988\n \n \n TODO:\n \n a) Better recovery procedures. At present I never check on forward\n progress. There is checkpoint/restart with reducing \n re-factorization frequency, but this is only on singular \n factorizations.\n b) Fast methods for large easy problems (and also the option for\n the code to automatically choose which method).\n c) We need to be able to stop in various ways for OSI - this\n is fairly easy.\n \n */\n\n\n#include \"CoinPragma.hpp\"\n\n#include \n\n#include \"CoinHelperFunctions.hpp\"\n#include \"IClpSimplexPrimal_Wolfe.hpp\"\n#include \"ClpFactorization.hpp\"\n#include \"ClpNonLinearCost.hpp\"\n#include \"CoinPackedMatrix.hpp\"\n#include \"CoinIndexedVector.hpp\"\n#include \"ClpPrimalColumnPivot.hpp\"\n#include \"ClpMessage.hpp\"\n#include \"ClpEventHandler.hpp\"\n#include \n#include \n#include \n#include \n#include \n// primal \nint IClpSimplexPrimal_Wolfe::primal (int ifValuesPass , int startFinishOptions)\n{\n\t\n\t/*\n\t Method\n\t \n It tries to be a single phase approach with a weight of 1.0 being\n given to getting optimal and a weight of infeasibilityCost_ being\n given to getting primal feasible. In this version I have tried to\n be clever in a stupid way. The idea of fake bounds in dual\n seems to work so the primal analogue would be that of getting\n bounds on reduced costs (by a presolve approach) and using\n these for being above or below feasible region. I decided to waste\n memory and keep these explicitly. This allows for non-linear\n costs!\n\t \n The code is designed to take advantage of sparsity so arrays are\n seldom zeroed out from scratch or gone over in their entirety.\n The only exception is a full scan to find incoming variable for \n Dantzig row choice. For steepest edge we keep an updated list \n of dual infeasibilities (actually squares). \n On easy problems we don't need full scan - just\n pick first reasonable.\n\t \n One problem is how to tackle degeneracy and accuracy. At present\n I am using the modification of costs which I put in OSL and which was\n extended by Gill et al. I am still not sure of the exact details.\n\t \n The flow of primal is three while loops as follows:\n\t \n while (not finished) {\n\t \n\t while (not clean solution) {\n\t \n\t Factorize and/or clean up solution by changing bounds so\n\t primal feasible. If looks finished check fake primal bounds.\n\t Repeat until status is iterating (-1) or finished (0,1,2)\n\t \n\t }\n\t \n\t while (status==-1) {\n\t \n\t Iterate until no pivot in or out or time to re-factorize.\n\t \n\t Flow is:\n\t \n\t choose pivot column (incoming variable). if none then\n\t we are primal feasible so looks as if done but we need to\n\t break and check bounds etc.\n\t \n\t Get pivot column in tableau\n\t \n\t Choose outgoing row. If we don't find one then we look\n\t primal unbounded so break and check bounds etc. (Also the\n\t pivot tolerance is larger after any iterations so that may be\n\t reason)\n\t \n\t If we do find outgoing row, we may have to adjust costs to\n\t keep going forwards (anti-degeneracy). Check pivot will be stable\n\t and if unstable throw away iteration and break to re-factorize.\n\t If minor error re-factorize after iteration.\n\t \n\t Update everything (this may involve changing bounds on \n\t variables to stay primal feasible.\n\t \n\t }\n\t \n }\n\t \n At present we never check we are going forwards. I overdid that in\n OSL so will try and make a last resort.\n\t \n Needs partial scan pivot in option.\n\t \n May need other anti-degeneracy measures, especially if we try and use\n loose tolerances as a way to solve in fewer iterations.\n\t \n I like idea of dynamic scaling. This gives opportunity to decouple\n different implications of scaling for accuracy, iteration count and\n feasibility tolerance.\n\t \n\t */\n\t \n\t // @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n//\t int listSize = numberRows() + numberColumns();\n//\t \n//\t\n//\tQP_BanList = new int[listSize];\n//\tfor (int i = 0; i < listSize ; i++)\n//\t\tQP_BanList[i] = 0;\n//\t\t\n//\tQP_ExistsBannedVariable = 0;\n\t// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\t\n\t\n\talgorithm_ = +1;\n\tmoreSpecialOptions_ &= ~16; // clear check replaceColumn accuracy\n\t\n\t// save data\n\tClpDataSave data = saveData();\n\tmatrix_->refresh(this); // make sure matrix okay\n\t\n\t\n\t// Save so can see if doing after dual\n\tint initialStatus=problemStatus_;\n\tint initialIterations = numberIterations_;\n\tint initialNegDjs=-1;\n\t// initialize - maybe values pass and algorithm_ is +1\n#if 0\n\t// if so - put in any superbasic costed slacks\n\tif (ifValuesPass&&specialOptions_<0x01000000) {\n\t\t// Get column copy\n\t\tconst CoinPackedMatrix * columnCopy = matrix();\n\t\tconst int * row = columnCopy->getIndices();\n\t\tconst CoinBigIndex * columnStart = columnCopy->getVectorStarts();\n\t\tconst int * columnLength = columnCopy->getVectorLengths(); \n\t\t//const double * element = columnCopy->getElements();\n\t\tint n=0;\n\t\tfor (int iColumn = 0;iColumnprimalTolerance_&&\n\t\t\t\t\t\tfabs(value-columnUpper_[iColumn])>primalTolerance_) {\n\t\t\t\t\t\tint iRow = row[columnStart[iColumn]];\n\t\t\t\t\t\tif (getRowStatus(iRow)==basic) {\n\t\t\t\t\t\t\tsetRowStatus(iRow,superBasic);\n\t\t\t\t\t\t\tsetColumnStatus(iColumn,basic);\n\t\t\t\t\t\t\tn++;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} \n\t\t\t}\n\t\t}\n\t\tprintf(\"%d costed slacks put in basis\\n\",n);\n\t}\n#endif\n\t\n\t\n\t\n\tif (!startup(ifValuesPass,startFinishOptions)) {\n\t\t\n\t\t// Set average theta\n\t\tnonLinearCost_->setAverageTheta(1.0e3);\n\t\tint lastCleaned=0; // last time objective or bounds cleaned up\n\t\t\n\t\t// Say no pivot has occurred (for steepest edge and updates)\n\t\tpivotRow_=-2;\n\t\t\n\t\t// This says whether to restore things etc\n\t\tint factorType=0;\n\t\tif (problemStatus_<0&&perturbation_<100&&!ifValuesPass) {\n\t\t\tperturb(0);\n\t\t\t// Can't get here if values pass\n\t\t\tassert (!ifValuesPass);\n\t\t\tgutsOfSolution(NULL,NULL);\n\t\t\tif (handler_->logLevel()>2) {\n\t\t\t\thandler_->message(CLP_SIMPLEX_STATUS,messages_)\n\t\t\t\t<printing(sumPrimalInfeasibilities_>0.0)\n\t\t\t\t<printing(sumDualInfeasibilities_>0.0)\n\t\t\t\t<printing(numberDualInfeasibilitiesWithoutFree_\n\t\t\t\t\t\t\t\t message()<clear();\n\t\t\t} \n\t\t\t\n\t\t\tfor (iColumn=0;iColumn<2;iColumn++) {\n\t\t\t\tcolumnArray_[iColumn]->clear();\n\t\t\t} \n\t\t\t\n\t\t\t// give matrix (and model costs and bounds a chance to be\n\t\t\t// refreshed (normally null)\n\t\t\tmatrix_->refresh(this);\n\t\t\t// If getting nowhere - why not give it a kick\n#if 1\n\t\t\tif (perturbation_<101&&numberIterations_>2*(numberRows_+numberColumns_)&&(specialOptions_&4)==0\n\t\t\t\t&&initialStatus!=10) {\n\t\t\t\tperturb(1);\n\t\t\t\tmatrix_->rhsOffset(this,true,false);\n\t\t\t}\n#endif\n\n\t\t\t\n\t\t\t// If we have done no iterations - special\n\t\t\tif (lastGoodIteration_==numberIterations_&&factorType)\n\t\t\t\tfactorType=3;\n\t\t\tif (saveModel) {\n\t\t\t\t// Doing sprint\n\t\t\t\tif (sequenceIn_<0||numberIterations_>=stopSprint) {\n\t\t\t\t\tproblemStatus_=-1;\n\t\t\t\t\toriginalModel(saveModel);\n\t\t\t\t\tsaveModel=NULL;\n\t\t\t\t\tif (sequenceIn_<0&&numberIterations_100)\n\t\t\t\t\t\tprimalColumnPivot_->switchOffSprint();\n\t\t\t\t\t//lastSprintIteration=numberIterations_;\n\t\t\t\t\tprintf(\"End small model\\n\");\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\t// may factorize, checks if problem finished\n\t\t\tstatusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,ifValuesPass,saveModel);\n\t\n\t\t\tif (initialStatus==10) {\n\t\n\t\t\t\t// cleanup phase\n\t\t\t\tif(initialIterations != numberIterations_) {\n\t\t\t\t\tif (numberDualInfeasibilities_>10000&&numberDualInfeasibilities_>10*initialNegDjs) {\n\t\t\t\t\t\t// getting worse - try perturbing\n\t\t\t\t\t\tif (perturbation_<101&&(specialOptions_&4)==0) {\n\t\t\t\t\t\t\tperturb(1);\n\t\t\t\t\t\t\tmatrix_->rhsOffset(this,true,false);\n\t\t\t\t\t\t\tstatusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,ifValuesPass,saveModel);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\n\t\t\t\t\t// save number of negative djs\n\t\t\t\t\tif (!numberPrimalInfeasibilities_)\n\t\t\t\t\t\tinitialNegDjs=numberDualInfeasibilities_;\n\t\t\t\t\t// make sure weight won't be changed\n\t\t\t\t\tif (infeasibilityCost_==1.0e10)\n\t\t\t\t\t\tinfeasibilityCost_=1.000001e10;\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\t// See if sprint says redo because of problems\n\t\t\tif (numberDualInfeasibilities_==-776) {\n\t\t\t\t// Need new set of variables\n\t\t\t\tproblemStatus_=-1;\n\t\t\t\toriginalModel(saveModel);\n\t\t\t\t\n\t\t\t\tsaveModel=NULL;\n\t\t\t\t//lastSprintIteration=numberIterations_;\n\t\t\t\tprintf(\"End small model after\\n\");\n\t\t\t\tstatusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,ifValuesPass,saveModel);\n\t\t\t} \n\t\t\t\n\t\t\tint numberSprintIterations=0;\n\t\t\tint numberSprintColumns = primalColumnPivot_->numberSprintColumns(numberSprintIterations);\n\t\n\t\t\tif (problemStatus_==777) {\n\t\t\t\t// problems so do one pass with normal\n\t\t\t\tproblemStatus_=-1;\n\t\t\t\toriginalModel(saveModel);\n\t\t\t\tsaveModel=NULL;\n\t\t\t\t// Skip factorization\n\t\t\t\t//statusOfProblemInPrimal(lastCleaned,factorType,&progress_,false,saveModel);\n\t\t\t\tstatusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,ifValuesPass,saveModel);\n\t\t\t} else if (problemStatus_<0&&!saveModel&&numberSprintColumns&&firstFree_<0) {\n\t\t\t\tint numberSort=0;\n\t\t\t\tint numberFixed=0;\n\t\t\t\tint numberBasic=0;\n\t\t\t\treasonableSprintIteration = numberIterations_ + 100;\n\t\t\t\tint * whichColumns = new int[numberColumns_];\n\t\t\t\tdouble * weight = new double[numberColumns_];\n\t\t\t\tint numberNegative=0;\n\t\t\t\tdouble sumNegative = 0.0;\n\t\t\t\t\n\t\t\t\t// now massage weight so all basic in plus good djs\n\t\t\t\tfor (iColumn=0;iColumn-1.0e50) {\n\t\t\t\t\t\tnumberNegative++;\n\t\t\t\t\t\tsumNegative -= dj;\n\t\t\t\t\t}\n\t\t\t\t\tweight[iColumn]=dj;\n\t\t\t\t\twhichColumns[iColumn] = iColumn;\n\t\t\t\t}\n\t\t\t\thandler_->message(CLP_SPRINT,messages_)\n\t\t\t\t<lastObjectiveValue-1.0e-7&&sprintPass>5) {\n\t\t\t\t\t// switch off\n\t\n\t\t\t\t\tprintf(\"Switching off sprint\\n\");\n\t\t\t\t\tprimalColumnPivot_->switchOffSprint();\n\t\t\t\t} else {\n\t\t\t\t\tlastObjectiveValue = objectiveValue()*optimizationDirection_;\n\t\t\t\t\t// sort\n\t\t\t\t\tCoinSort_2(weight,weight+numberColumns_,whichColumns);\n\t\t\t\t\tnumberSort = std::min(numberColumns_-numberFixed,numberBasic+numberSprintColumns);\n\t\t\t\t\t// Sort to make consistent ?\n\t\t\t\t\tstd::sort(whichColumns,whichColumns+numberSort);\n\t\t\t\t\t// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\t\t\t\t\tsaveModel = new IClpSimplex(this,numberSort,whichColumns);\n\t\t\t\t\t// @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n\t\t\t\t\t\n\t\t\t\t\tdelete [] whichColumns;\n\t\t\t\t\tdelete [] weight;\n\t\t\t\t\t// Skip factorization\n\t\t\t\t\t//statusOfProblemInPrimal(lastCleaned,factorType,&progress_,false,saveModel);\n\t\t\t\t\t//statusOfProblemInPrimal(lastCleaned,factorType,&progress_,true,saveModel);\n\t\t\t\t\tstopSprint = numberIterations_+numberSprintIterations;\n\t\t\t\t\tprintf(\"Sprint with %d columns for %d iterations\\n\",\n\t\t\t\t\t\t numberSprintColumns,numberSprintIterations);\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\t\t\t\n\t\t\t\n\t\t\t// Say good factorization\n\t\t\tfactorType=1;\n\t\t\t\n\t\t\t// Say no pivot has occurred (for steepest edge and updates)\n\t\t\tpivotRow_=-2;\n\t\t\t\n\t\t\t// exit if victory declared\n\t\t\tif (problemStatus_>=0)\n\t\t\t\tbreak;\n\t\t\t\n\t\t\t// test for maximum iterations\n\t\t\tif (hitMaximumIterations()||(ifValuesPass==2&&firstFree_<0)) {\n\t\t\t\tproblemStatus_=3;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\t\n\t\t\tif (firstFree_<0) {\n\t\t\t\tif (ifValuesPass) {\n\t\t\t\t\t// end of values pass\n\t\t\t\t\tifValuesPass=0;\n\t\t\t\t\tint status = eventHandler_->event(ClpEventHandler::endOfValuesPass);\n\t\t\t\t\tif (status>=0) {\n\t\t\t\t\t\tproblemStatus_=5;\n\t\t\t\t\t\tsecondaryStatus_=ClpEventHandler::endOfValuesPass;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\t//#define FEB_TRY\n#ifdef FEB_TRY\n\t\t\t\t\tif (perturbation_<100) \n\t\t\t\t\t\tperturb(0);\n#endif\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Check event\n\t\t\t{\n\t\t\t\tint status = eventHandler_->event(ClpEventHandler::endOfFactorization);\n\t\t\t\tif (status>=0) {\n\t\t\t\t\tproblemStatus_=5;\n\t\t\t\t\tsecondaryStatus_=ClpEventHandler::endOfFactorization;\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// Iterate\n\t\t\twhileIterating(ifValuesPass ? 1 : 0);\n\t\t}\n\t}\n\t// if infeasible get real values\n\t//printf(\"XXXXY final cost %g\\n\",infeasibilityCost_);\n\tprogress_.initialWeight_=0.0;\n\tif (problemStatus_==1&&secondaryStatus_!=6) {\n\t\tinfeasibilityCost_=0.0;\n\t\tcreateRim(1+4);\n\t\tdelete nonLinearCost_;\n\t\tnonLinearCost_ = new ClpNonLinearCost(this);\n\t\tnonLinearCost_->checkInfeasibilities(0.0);\n\t\tsumPrimalInfeasibilities_=nonLinearCost_->sumInfeasibilities();\n\t\tnumberPrimalInfeasibilities_= nonLinearCost_->numberInfeasibilities();\n\t\t// and get good feasible duals\n\t\tcomputeDuals(NULL);\n\t}\n\t// clean up\n\tunflag();\n\tfinish(startFinishOptions);\n\trestoreData(data);\n\treturn problemStatus_;\n}\n/*\n Reasons to come out:\n -1 iterations etc\n -2 inaccuracy \n -3 slight inaccuracy (and done iterations)\n -4 end of values pass and done iterations\n +0 looks optimal (might be infeasible - but we will investigate)\n +2 looks unbounded\n +3 max iterations \n */\nint\nIClpSimplexPrimal_Wolfe::whileIterating(int valuesOption)\n{\n\t// Say if values pass\n\tint ifValuesPass=(firstFree_>=0) ? 1 : 0;\n\tint returnCode=-1;\n\tint superBasicType=1;\n\tif (valuesOption>1)\n\t\tsuperBasicType=3;\n\t// status stays at -1 while iterating, >=0 finished, -2 to invert\n\t// status -3 to go to top without an invert\n\twhile (problemStatus_==-1) {\n\t\t//#define CLP_DEBUG 1\n#ifdef CLP_DEBUG\n\t\t{\n\t\t\tint i;\n\t\t\t// not [1] as has information\n\t\t\tfor (i=0;i<4;i++) {\n\t\t\t\tif (i!=1)\n\t\t\t\t\trowArray_[i]->checkClear();\n\t\t\t} \n\t\t\tfor (i=0;i<2;i++) {\n\t\t\t\tcolumnArray_[i]->checkClear();\n\t\t\t}\n\t\t} \n#endif\n#if 0\n\t\t{\n\t\t\tint iPivot;\n\t\t\tdouble * array = rowArray_[3]->denseVector();\n\t\t\tint * index = rowArray_[3]->getIndices();\n\t\t\tint i;\n\t\t\tfor (iPivot=0;iPivotupdateColumn(rowArray_[2],rowArray_[3]);\n\t\t\t\tint number = rowArray_[3]->getNumElements();\n\t\t\t\tfor (i=0;iclear();\n\t\t\t}\n\t\t}\n#endif\n#if 0\n\t\tnonLinearCost_->checkInfeasibilities(primalTolerance_);\n\t\tprintf(\"suminf %g number %d\\n\",nonLinearCost_->sumInfeasibilities(),\n\t\t\t nonLinearCost_->numberInfeasibilities());\n#endif\n#if CLP_DEBUG>2\n\t\t// very expensive\n\t\tif (numberIterations_>0&&numberIterations_<100&&!ifValuesPass) {\n\t\t\thandler_->setLogLevel(63);\n\t\t\tdouble saveValue = objectiveValue_;\n\t\t\tdouble * saveRow1 = new double[numberRows_];\n\t\t\tdouble * saveRow2 = new double[numberRows_];\n\t\t\tCoinMemcpyN(rowReducedCost_,numberRows_,saveRow1);\n\t\t\tCoinMemcpyN(rowActivityWork_,numberRows_,saveRow2);\n\t\t\tdouble * saveColumn1 = new double[numberColumns_];\n\t\t\tdouble * saveColumn2 = new double[numberColumns_];\n\t\t\tCoinMemcpyN(reducedCostWork_,numberColumns_,saveColumn1);\n\t\t\tCoinMemcpyN(columnActivityWork_,numberColumns_,saveColumn2);\n\t\t\tgutsOfSolution(NULL,NULL,false);\n\t\t\tprintf(\"xxx %d old obj %g, recomputed %g, sum primal inf %g\\n\",\n\t\t\t\t numberIterations_,\n\t\t\t\t saveValue,objectiveValue_,sumPrimalInfeasibilities_);\n\t\t\tCoinMemcpyN(saveRow1,numberRows_,rowReducedCost_);\n\t\t\tCoinMemcpyN(saveRow2,numberRows_,rowActivityWork_);\n\t\t\tCoinMemcpyN(saveColumn1,numberColumns_,reducedCostWork_);\n\t\t\tCoinMemcpyN(saveColumn2,numberColumns_,columnActivityWork_);\n\t\t\tdelete [] saveRow1;\n\t\t\tdelete [] saveRow2;\n\t\t\tdelete [] saveColumn1;\n\t\t\tdelete [] saveColumn2;\n\t\t\tobjectiveValue_=saveValue;\n\t\t}\n#endif\n\t\tif (!ifValuesPass) {\n\t\t\t// choose column to come in\n\t\t\t// can use pivotRow_ to update weights\n\t\t\t// pass in list of cost changes so can do row updates (rowArray_[1])\n\t\t\t// NOTE rowArray_[0] is used by computeDuals which is a \n\t\t\t// slow way of getting duals but might be used \n\t\t\tprimalColumn(rowArray_[1],rowArray_[2],rowArray_[3],\n\t\t\t\t\t\t columnArray_[0],columnArray_[1]);\n\t\t} else {\n\t\t\t// in values pass\n\t\t\tint sequenceIn=nextSuperBasic(superBasicType,columnArray_[0]);\n\t\t\tif (valuesOption>1)\n\t\t\t\tsuperBasicType=2;\n\t\t\tif (sequenceIn<0) {\n\t\t\t\t// end of values pass - initialize weights etc\n\t\t\t\thandler_->message(CLP_END_VALUES_PASS,messages_)\n\t\t\t\t<saveWeights(this,5);\n\t\t\t\tproblemStatus_=-2; // factorize now\n\t\t\t\tpivotRow_=-1; // say no weights update\n\t\t\t\treturnCode=-4;\n\t\t\t\t// Clean up\n\t\t\t\tint i;\n\t\t\t\tfor (i=0;iclear();\n\t\tif (sequenceIn_>=0) {\n\t\t\t// we found a pivot column\n\t\t\tassert (!flagged(sequenceIn_));\n#ifdef CLP_DEBUG\n\t\t\tif ((handler_->logLevel()&32)) {\n\t\t\t\tchar x = isColumn(sequenceIn_) ? 'C' :'R';\n\t\t\t\tstd::cout<<\"pivot column \"<<\n\t\t\t\tx<=0&&checkSequencecheckClear();\n\t\t\t\t\trowArray_[3]->checkClear();\n\t\t\t\t\tdouble * array = rowArray_[3]->denseVector();\n\t\t\t\t\tint * index = rowArray_[3]->getIndices();\n\t\t\t\t\tunpackPacked(rowArray_[3],checkSequence);\n\t\t\t\t\tfactorization_->updateColumnForDebug(rowArray_[2],rowArray_[3]);\n\t\t\t\t\tint number = rowArray_[3]->getNumElements();\n\t\t\t\t\tdouble dualIn = cost_[checkSequence];\n\t\t\t\t\tint i;\n\t\t\t\t\tfor (i=0;iclear();\n\t\t\t\t\tif (numberIterations_>2000)\n\t\t\t\t\t\texit(1);\n\t\t\t\t}\n\t\t\t}\n#endif\n\t\t\t// do second half of iteration\n\t\t\treturnCode = pivotResult(ifValuesPass);\n\t\t\tif (returnCode<-1&&returnCode>-5) {\n\t\t\t\tproblemStatus_=-2; // \n\t\t\t} else if (returnCode==-5) {\n\t\t\t\tif ((moreSpecialOptions_&16)==0&&factorization_->pivots()) {\n\t\t\t\t\tmoreSpecialOptions_ |= 16;\n\t\t\t\t\tproblemStatus_=-2;\n\t\t\t\t}\n\t\t\t\t// otherwise something flagged - continue;\n\t\t\t} else if (returnCode==2) {\n\t\t\t\tproblemStatus_=-5; // looks unbounded\n\t\t\t} else if (returnCode==4) {\n\t\t\t\tproblemStatus_=-2; // looks unbounded but has iterated\n\t\t\t} else if (returnCode!=-1) {\n\t\t\t\tassert(returnCode==3);\n\t\t\t\tif (problemStatus_!=5)\n\t\t\t\t\tproblemStatus_=3;\n\t\t\t}\n\t\t} else {\n\t\t\t// no pivot column\n#ifdef CLP_DEBUG\n\t\t\tif (handler_->logLevel()&32)\n\t\t\t\tprintf(\"** no column pivot\\n\");\n#endif\n\t\t\tif (nonLinearCost_->numberInfeasibilities())\n\t\t\t\tproblemStatus_=-4; // might be infeasible \n\t\t\t// Force to re-factorize early next time\n\t\t\tint numberPivots = factorization_->pivots();\n\t\t\tforceFactorization_=std::min(forceFactorization_,(numberPivots+1)>>1);\n\t\t\treturnCode=0;\n\t\t\tbreak;\n\t\t}\n\t}\n\tif (valuesOption>1) \n\t\tcolumnArray_[0]->setNumElements(0);\n\treturn returnCode;\n}\n/* Checks if finished. Updates status */\nvoid \nIClpSimplexPrimal_Wolfe::statusOfProblemInPrimal(int & lastCleaned,int type,\n\t\t\t\t\t\t\t\t\t\t\t\t ClpSimplexProgress * progress,\n\t\t\t\t\t\t\t\t\t\t\t\t bool doFactorization,\n\t\t\t\t\t\t\t\t\t\t\t\t int ifValuesPass,\n\t\t\t\t\t\t\t\t\t\t\t\t IClpSimplex * originalModel)\n{\n\tint dummy; // for use in generalExpanded\n\tint saveFirstFree=firstFree_;\n\t// number of pivots done\n\tint numberPivots = factorization_->pivots();\n\tif (type==2) {\n\t\t// trouble - restore solution\n\t\tCoinMemcpyN(saveStatus_,numberColumns_+numberRows_,status_);\n\t\tCoinMemcpyN(savedSolution_+numberColumns_ ,\n\t\t\t\t\tnumberRows_,rowActivityWork_);\n\t\tCoinMemcpyN(savedSolution_ ,\n\t\t\t\t\tnumberColumns_,columnActivityWork_);\n\t\t// restore extra stuff\n\t\tmatrix_->generalExpanded(this,6,dummy);\n\t\tforceFactorization_=1; // a bit drastic but ..\n\t\tpivotRow_=-1; // say no weights update\n\t\tchangeMade_++; // say change made\n\t}\n\t\n\tint saveThreshold = factorization_->sparseThreshold();\n\tint tentativeStatus = problemStatus_;\n\tint numberThrownOut=1; // to loop round on bad factorization in values pass\n\tdouble lastSumInfeasibility=COIN_DBL_MAX;\n\tif (numberIterations_)\n\t\tlastSumInfeasibility=nonLinearCost_->sumInfeasibilities();\n\tint nPass=0;\n\twhile (numberThrownOut) {\n\t\n\t\tint nSlackBasic=0;\n\t\tif (nPass) {\n\t\t\tfor (int i=0;i-3||problemStatus_==-4) {\n\t\t\t// factorize\n\t\t\t// later on we will need to recover from singularities\n\t\t\t// also we could skip if first time\n\t\t\t// do weights\n\t\t\t// This may save pivotRow_ for use\n\t\t\tif (doFactorization)\n\t\t\t\tprimalColumnPivot_->saveWeights(this,1);\n\t\t\t\n\t\t\tif ((type&&doFactorization)||nSlackBasic==numberRows_) {\n\t\t\t\t// is factorization okay?\n\t\t\t\tint factorStatus = internalFactorize(1);\n\t\n\t\t\t\tif (factorStatus) {\n\t\t\t\t\tif (solveType_==2+8) {\n\t\t\t\t\t\t// say odd\n\t\t\t\t\t\tproblemStatus_=5;\n\t\t\t\t\t\treturn;\n\t\t\t\t\t}\n\t\t\t\t\tif (type!=1||largestPrimalError_>1.0e3\n\t\t\t\t\t\t||largestDualError_>1.0e3) {\n\t\t\t\t\t\t// switch off dense\n\t\t\t\t\t\tint saveDense = factorization_->denseThreshold();\n\t\n\t\t\t\t\t\tfactorization_->setDenseThreshold(0);\n\t\t\t\t\t\t// Go to safe\n\t\t\t\t\t\tfactorization_->pivotTolerance(0.99);\n\t\t\t\t\t\t// make sure will do safe factorization\n\t\t\t\t\t\tpivotVariable_[0]=-1;\n\t\t\t\t\t\tinternalFactorize(2);\n\t\t\t\t\t\tfactorization_->setDenseThreshold(saveDense);\n\t\t\t\t\t\t// restore extra stuff\n\t\t\t\t\t\tmatrix_->generalExpanded(this,6,dummy);\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// no - restore previous basis\n\t\t\t\t\t\t// Keep any flagged variables\n\t\n\t\t\t\t\t\tint i;\n\t\t\t\t\t\tfor (i=0;i=0&&getStatus(sequenceIn_)!=basic) {\n\t\t\t\t\t\t\t\tsetFlagged(sequenceIn_);\n\t\t\t\t\t\t\t} else if (sequenceOut_>=0&&getStatus(sequenceOut_)!=basic) {\n\t\t\t\t\t\t\t\tsetFlagged(sequenceOut_);\n\t\t\t\t\t\t\t}\n\t\n\t\t\t\t\t\t\tdouble newTolerance = std::max(0.5 + 0.499*randomNumberGenerator_.randomDouble(),factorization_->pivotTolerance());\n\t\t\t\t\t\t\tfactorization_->pivotTolerance(newTolerance);\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\t// Go to safe \n\t\t\t\t\t\t\tfactorization_->pivotTolerance(0.99);\n\t\t\t\t\t\t}\n\t\n\t\t\t\t\t\tCoinMemcpyN(savedSolution_+numberColumns_ ,\n\t\t\t\t\t\t\t\t\tnumberRows_,rowActivityWork_);\n\t\t\t\t\t\tCoinMemcpyN(savedSolution_ ,\n\t\t\t\t\t\t\t\t\tnumberColumns_,columnActivityWork_);\n\t\t\t\t\t\t// restore extra stuff\n\t\t\t\t\t\tmatrix_->generalExpanded(this,6,dummy);\n\t\t\t\t\t\tmatrix_->generalExpanded(this,5,dummy);\n\t\n\t\t\t\t\t\tforceFactorization_=1; // a bit drastic but ..\n\t\t\t\t\t\ttype = 2;\n\t\t\t\t\t\tif (internalFactorize(2)!=0) {\n\t\t\t\t\t\t\tlargestPrimalError_=1.0e4; // force other type\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tchangeMade_++; // say change made\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (problemStatus_!=-4)\n\t\t\t\tproblemStatus_=-3;\n\t\t}\n\t\n\t\t// at this stage status is -3 or -5 if looks unbounded\n\t\t// get primal and dual solutions\n\t\t// put back original costs and then check\n\t\t// createRim(4); // costs do not change \n\t\t// May need to do more if column generation\n\t\tdummy=4;\n\t\tmatrix_->generalExpanded(this,9,dummy);\n\t\tnumberThrownOut=gutsOfSolution(NULL,NULL,(firstFree_>=0));\n\t\tdouble sumInfeasibility = nonLinearCost_->sumInfeasibilities();\n\t\tif (numberThrownOut||\n\t\t\t(sumInfeasibility>1.0e7&&sumInfeasibility>100.0*lastSumInfeasibility\n\t\t\t &&factorization_->pivotTolerance()<0.11)||(largestPrimalError_>1.0e10&&largestDualError_>1.0e10)) {\n\t\t\t\tproblemStatus_=tentativeStatus;\n\t\t\t\tdoFactorization=true;\n\t\t\t\tif (numberPivots) {\n\t\t\t\t\t// go back\n\t\t\t\t\tnumberThrownOut=-1;\n\t\t\t\t\t// trouble - restore solution\n\t\t\t\t\tCoinMemcpyN(saveStatus_,numberColumns_+numberRows_,status_);\n\t\t\t\t\tCoinMemcpyN(savedSolution_+numberColumns_ ,\n\t\t\t\t\t\t\t\tnumberRows_,rowActivityWork_);\n\t\t\t\t\tCoinMemcpyN(savedSolution_ ,\n\t\t\t\t\t\t\t\tnumberColumns_,columnActivityWork_);\n\t\t\t\t\t// restore extra stuff\n\t\t\t\t\tmatrix_->generalExpanded(this,6,dummy);\n\t\t\t\t\tforceFactorization_=1; // a bit drastic but ..\n\t\t\t\t\t// Go to safe \n\t\t\t\t\tfactorization_->pivotTolerance(0.99);\n\t\t\t\t\tpivotRow_=-1; // say no weights update\n\t\t\t\t\tchangeMade_++; // say change made\n\t\t\t\t\tif (numberPivots==1) {\n\t\t\t\t\t\t// throw out something\n\t\t\t\t\t\tif (sequenceIn_>=0&&getStatus(sequenceIn_)!=basic) {\n\t\t\t\t\t\t\tsetFlagged(sequenceIn_);\n\t\t\t\t\t\t} else if (sequenceOut_>=0&&getStatus(sequenceOut_)!=basic) {\n\t\t\t\t\t\t\tsetFlagged(sequenceOut_);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\tnumberPivots=0;\n\t\t\t\t}\n\t\t\t}\n\t}\n\t// Double check reduced costs if no action\n\tif (progress->lastIterationNumber(0)==numberIterations_) {\n\t\tif (primalColumnPivot_->looksOptimal()) {\n\t\t\tnumberDualInfeasibilities_ = 0;\n\t\t\tsumDualInfeasibilities_ = 0.0;\n\t\t}\n\t}\n\t// If in primal and small dj give up\n\tif ((specialOptions_&1024)!=0&&!numberPrimalInfeasibilities_&&numberDualInfeasibilities_) {\n\t\tdouble average = sumDualInfeasibilities_/(static_cast (numberDualInfeasibilities_));\n\t\tif (numberIterations_>300&&average<1.0e-4) {\n\t\t\tnumberDualInfeasibilities_ = 0;\n\t\t\tsumDualInfeasibilities_ = 0.0;\n\t\t}\n\t}\n\t// Check if looping\n\tint loop;\n\tif (type!=2&&!ifValuesPass) \n\t\tloop = progress->looping();\n\telse\n\t\tloop=-1;\n\tif (loop>=0) {\n\t\tif (!problemStatus_) {\n\t\t\t// declaring victory\n\t\t\tnumberPrimalInfeasibilities_ = 0;\n\t\t\tsumPrimalInfeasibilities_ = 0.0;\n\t\t} else {\n\t\t\tproblemStatus_ = loop; //exit if in loop \n\t\t\tproblemStatus_ = 10; // instead - try other algorithm\n\t\t\tnumberPrimalInfeasibilities_ = nonLinearCost_->numberInfeasibilities();\n\t\t}\n\t\tproblemStatus_ = 10; // instead - try other algorithm\n\t\treturn ;\n\t} else if (loop<-1) {\n\t\t// Is it time for drastic measures\n\t\tif (nonLinearCost_->numberInfeasibilities()&&progress->badTimes()>5&&\n\t\t\tprogress->oddState()<10&&progress->oddState()>=0) {\n\t\t\tprogress->newOddState();\n\t\t\tnonLinearCost_->zapCosts();\n\t\t}\n\t\t// something may have changed\n\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t}\n\t// If progress then reset costs\n\tif (loop==-1&&!nonLinearCost_->numberInfeasibilities()&&progress->oddState()<0) {\n\t\tcreateRim(4,false); // costs back\n\t\tdelete nonLinearCost_;\n\t\tnonLinearCost_ = new ClpNonLinearCost(this);\n\t\tprogress->endOddState();\n\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t}\n\t// Flag to say whether to go to dual to clean up\n\tbool goToDual=false;\n\t// really for free variables in\n\t//if((progressFlag_&2)!=0)\n\t//problemStatus_=-1;;\n\tprogressFlag_ = 0; //reset progress flag\n\t\n\thandler_->message(CLP_SIMPLEX_STATUS,messages_)\n <feasibleReportCost();\n\thandler_->printing(nonLinearCost_->numberInfeasibilities()>0)\n <sumInfeasibilities()<numberInfeasibilities();\n\thandler_->printing(sumDualInfeasibilities_>0.0)\n <printing(numberDualInfeasibilitiesWithoutFree_\n\t\t\t\t\t message()<checkInfeasibilities(primalTolerance_);\n\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t\tnonLinearCost_->checkInfeasibilities(primalTolerance_);\n\t}\n\tif (nonLinearCost_->numberInfeasibilities()>0&&!progress->initialWeight_&&!ifValuesPass&&infeasibilityCost_==1.0e10) {\n\t\t// first time infeasible - start up weight computation\n\t\tdouble * oldDj = dj_;\n\t\tdouble * oldCost = cost_;\n\t\tint numberRows2 = numberRows_+numberExtraRows_;\n\t\tint numberTotal = numberRows2+numberColumns_;\n\t\tdj_ = new double[numberTotal];\n\t\tcost_ = new double[numberTotal];\n\t\treducedCostWork_ = dj_;\n\t\trowReducedCost_ = dj_+numberColumns_;\n\t\tobjectiveWork_ = cost_;\n\t\trowObjectiveWork_ = cost_+numberColumns_;\n\t\tdouble direction = optimizationDirection_*objectiveScale_;\n\t\tconst double * obj = objective();\n\t\tmemset(rowObjectiveWork_,0,numberRows_*sizeof(double));\n\t\tint iSequence;\n\t\tif (columnScale_)\n\t\t\tfor (iSequence=0;iSequenceprimalTolerance_) {\n\t\t\t\t\t// Check if \"free\"\n\t\t\t\t\tif (distanceDown>primalTolerance_) {\n\t\t\t\t\t\t// free\n\t\t\t\t\t\tif (value>dualTolerance_) {\n\t\t\t\t\t\t\tnumberFreeSame++;\n\t\t\t\t\t\t} else if(value<-dualTolerance_) {\n\t\t\t\t\t\t\tnumberFreeDifferent++;\n\t\t\t\t\t\t\tdj_[n++] = feasibleDj/infeasibleDj;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tnumberFreeZero++;\n\t\t\t\t\t\t}\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// should not be negative\n\t\t\t\t\t\tif (value>dualTolerance_) {\n\t\t\t\t\t\t\tnumberSame++;\n\t\t\t\t\t\t} else if(value<-dualTolerance_) {\n\t\t\t\t\t\t\tnumberDifferent++;\n\t\t\t\t\t\t\tdj_[n++] = feasibleDj/infeasibleDj;\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tnumberZero++;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t} else if (distanceDown>primalTolerance_) {\n\t\t\t\t\t// should not be positive\n\t\t\t\t\tif (value>dualTolerance_) {\n\t\t\t\t\t\tnumberSame++;\n\t\t\t\t\t} else if(value<-dualTolerance_) {\n\t\t\t\t\t\tnumberDifferent++;\n\t\t\t\t\t\tdj_[n++] = feasibleDj/infeasibleDj;\n\t\t\t\t\t} else {\n\t\t\t\t\t\tnumberZero++;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tprogress->initialWeight_=-1.0;\n\t\t}\n\t\t//printf(\"XXXX %d same, %d different, %d zero, -- free %d %d %d\\n\",\n\t\t// numberSame,numberDifferent,numberZero,\n\t\t// numberFreeSame,numberFreeDifferent,numberFreeZero);\n\t\t// we want most to be same\n\t\tif (n) {\n\t\t\tdouble most = 0.95;\n\t\t\tstd::sort(dj_,dj_+n);\n\t\t\tint which = static_cast ((1.0-most)*static_cast (n));\n\t\t\tdouble take = -dj_[which]*infeasibilityCost_;\n\t\t\t//printf(\"XXXXZ inf cost %g take %g (range %g %g)\\n\",infeasibilityCost_,take,-dj_[0]*infeasibilityCost_,-dj_[n-1]*infeasibilityCost_);\n\t\t\ttake = -dj_[0]*infeasibilityCost_;\n\t\t\tinfeasibilityCost_ = std::min(std::max(1000.0*take,1.0e8),1.0000001e10);;\n\t\t\t//printf(\"XXXX increasing weight to %g\\n\",infeasibilityCost_);\n\t\t}\n\t\tdelete [] dj_;\n\t\tdelete [] cost_;\n\t\tdj_= oldDj;\n\t\tcost_ = oldCost;\n\t\treducedCostWork_ = dj_;\n\t\trowReducedCost_ = dj_+numberColumns_;\n\t\tobjectiveWork_ = cost_;\n\t\trowObjectiveWork_ = cost_+numberColumns_;\n\t\tif (n)\n\t\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t}\n\tdouble trueInfeasibility =nonLinearCost_->sumInfeasibilities();\n\tif (!nonLinearCost_->numberInfeasibilities()&&infeasibilityCost_==1.0e10&&!ifValuesPass&&true) {\n\t\t// relax if default\n\t\tinfeasibilityCost_ = std::min(std::max(100.0*sumDualInfeasibilities_,1.0e8),1.00000001e10);\n\t\t// reset looping criterion\n\t\tprogress->reset();\n\t\ttrueInfeasibility = 1.123456e10;\n\t}\n\tif (trueInfeasibility>1.0) {\n\t\t// If infeasibility going up may change weights\n\t\tdouble testValue = trueInfeasibility-1.0e-4*(10.0+trueInfeasibility);\n\t\tdouble lastInf = progress->lastInfeasibility(1);\n\t\tdouble lastInf3 = progress->lastInfeasibility(3);\n\t\tdouble thisObj = progress->lastObjective(0);\n\t\tdouble thisInf = progress->lastInfeasibility(0);\n\t\tthisObj += infeasibilityCost_*2.0*thisInf;\n\t\tdouble lastObj = progress->lastObjective(1);\n\t\tlastObj += infeasibilityCost_*2.0*lastInf;\n\t\tdouble lastObj3 = progress->lastObjective(3);\n\t\tlastObj3 += infeasibilityCost_*2.0*lastInf3;\n\t\tif (lastObjlogLevel()==63)\n\t\t\t\tprintf(\"lastobj %g this %g force %d \",lastObj,thisObj,forceFactorization_);\n\t\t\tint maxFactor = factorization_->maximumPivots();\n\t\t\tif (maxFactor>10) {\n\t\t\t\tif (forceFactorization_<0)\n\t\t\t\t\tforceFactorization_= maxFactor;\n\t\t\t\tforceFactorization_ = std::max(1,(forceFactorization_>>2));\n\t\t\t\tif (handler_->logLevel()==63)\n\t\t\t\t\tprintf(\"Reducing factorization frequency to %d\\n\",forceFactorization_);\n\t\t\t}\n\t\t} else if (lastObj3logLevel()==63)\n\t\t\t\tprintf(\"lastobj3 %g this3 %g `force %d \",lastObj3,thisObj,forceFactorization_);\n\t\t\tint maxFactor = factorization_->maximumPivots();\n\t\t\tif (maxFactor>10) {\n\t\t\t\tif (forceFactorization_<0)\n\t\t\t\t\tforceFactorization_= maxFactor;\n\t\t\t\tforceFactorization_ = std::max(1,(forceFactorization_*2)/3);\n\t\t\t\tif (handler_->logLevel()==63)\n\t\t\t\t\tprintf(\"Reducing factorization frequency to %d\\n\",forceFactorization_);\n\t\t\t}\n\t\t} else if(lastInfreset();\n\t\t\t\tif (handler_->logLevel()==63)\n\t\t\t\t\tprintf(\"increasing weight to %g\\n\",infeasibilityCost_);\n\t\t\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t\t\t}\n\t\t}\n\t}\n\t// we may wish to say it is optimal even if infeasible\n\tbool alwaysOptimal = (specialOptions_&1)!=0;\n\t// give code benefit of doubt\n\tif (sumOfRelaxedDualInfeasibilities_ == 0.0&&\n\t\tsumOfRelaxedPrimalInfeasibilities_ == 0.0) {\n\t\t// say optimal (with these bounds etc)\n\t\tnumberDualInfeasibilities_ = 0;\n\t\tsumDualInfeasibilities_ = 0.0;\n\t\tnumberPrimalInfeasibilities_ = 0;\n\t\tsumPrimalInfeasibilities_ = 0.0;\n\t\t// But check if in sprint\n\t\tif (originalModel) {\n\t\t\t// Carry on and re-do\n\t\t\tnumberDualInfeasibilities_ = -776;\n\t\t}\n\t\t// But if real primal infeasibilities nonzero carry on\n\t\tif (nonLinearCost_->numberInfeasibilities()) {\n\t\t\t// most likely to happen if infeasible\n\t\t\tdouble relaxedToleranceP=primalTolerance_;\n\t\t\t// we can't really trust infeasibilities if there is primal error\n\t\t\tdouble error = std::min(1.0e-2,largestPrimalError_);\n\t\t\t// allow tolerance at least slightly bigger than standard\n\t\t\trelaxedToleranceP = relaxedToleranceP + error;\n\t\t\tint ninfeas = nonLinearCost_->numberInfeasibilities();\n\t\t\tdouble sum = nonLinearCost_->sumInfeasibilities();\n\t\t\tdouble average = sum/ static_cast (ninfeas);\n#ifdef COIN_DEVELOP\n\t\t\tif (handler_->logLevel()>0)\n\t\t\t\tprintf(\"nonLinearCost says infeasible %d summing to %g\\n\",\n\t\t\t\t\t ninfeas,sum);\n#endif\n\t\t\tif (average>relaxedToleranceP) {\n\t\t\t\tsumOfRelaxedPrimalInfeasibilities_ = sum;\n\t\t\t\tnumberPrimalInfeasibilities_ = ninfeas;\n\t\t\t\tsumPrimalInfeasibilities_ = sum;\n#ifdef COIN_DEVELOP\n\t\t\t\tbool unflagged = \n#endif\n\t\t\t\tunflag();\n#ifdef COIN_DEVELOP\n\t\t\t\tif (unflagged&&handler_->logLevel()>0)\n\t\t\t\t\tprintf(\" - but flagged variables\\n\");\n#endif\n\t\t\t}\n\t\t}\n\t} \n\t// had ||(type==3&&problemStatus_!=-5) -- ??? why ????\n\tif ((dualFeasible()||problemStatus_==-4)&&!ifValuesPass) {\n\t\t// see if extra helps\n\t\tif (nonLinearCost_->numberInfeasibilities()&&\n\t\t\t(nonLinearCost_->sumInfeasibilities()>1.0e-3||sumOfRelaxedPrimalInfeasibilities_)\n\t\t\t&&!alwaysOptimal) {\n\t\t\t//may need infeasiblity cost changed\n\t\t\t// we can see if we can construct a ray\n\t\t\t// make up a new objective\n\t\t\tdouble saveWeight = infeasibilityCost_;\n\t\t\t// save nonlinear cost as we are going to switch off costs\n\t\t\tClpNonLinearCost * nonLinear = nonLinearCost_;\n\t\t\t// do twice to make sure Primal solution has settled\n\t\t\t// put non-basics to bounds in case tolerance moved\n\t\t\t// put back original costs\n\t\t\tcreateRim(4);\n\t\t\tnonLinearCost_->checkInfeasibilities(0.0);\n\t\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t\t\t\n\t\t\tinfeasibilityCost_=1.0e100;\n\t\t\t// put back original costs\n\t\t\tcreateRim(4);\n\t\t\tnonLinearCost_->checkInfeasibilities(primalTolerance_);\n\t\t\t// may have fixed infeasibilities - double check\n\t\t\tif (nonLinearCost_->numberInfeasibilities()==0) {\n\t\t\t\t// carry on\n\t\t\t\tproblemStatus_ = -1;\n\t\t\t\tinfeasibilityCost_=saveWeight;\n\t\t\t\tnonLinearCost_->checkInfeasibilities(primalTolerance_);\n\t\t\t} else {\n\t\t\t\tnonLinearCost_=NULL;\n\t\t\t\t// scale\n\t\t\t\tint i;\n\t\t\t\tfor (i=0;i=1.0e18||\n\t\t\t\t\t numberDualInfeasibilities_==0)&&perturbation_==101) {\n\t\t\t\t\tgoToDual=unPerturb(); // stop any further perturbation\n\t\t\t\t\tif (nonLinearCost_->sumInfeasibilities()>1.0e-1)\n\t\t\t\t\t\tgoToDual=false;\n\t\t\t\t\tnonLinearCost_->checkInfeasibilities(primalTolerance_);\n\t\t\t\t\tnumberDualInfeasibilities_=1; // carry on\n\t\t\t\t\tproblemStatus_=-1;\n\t\t\t\t} else if (numberDualInfeasibilities_==0&&largestDualError_>1.0e-2) {\n\t\t\t\t\tgoToDual=true;\n\t\t\t\t\tfactorization_->pivotTolerance(std::max(0.9,factorization_->pivotTolerance()));\n\t\t\t\t}\n\t\t\t\tif (!goToDual) {\n\t\t\t\t\tif (infeasibilityCost_>=1.0e20||\n\t\t\t\t\t\tnumberDualInfeasibilities_==0) {\n\t\t\t\t\t\t// we are infeasible - use as ray\n\t\t\t\t\t\tdelete [] ray_;\n\t\t\t\t\t\tray_ = new double [numberRows_];\n\t\t\t\t\t\tCoinMemcpyN(dual_,numberRows_,ray_);\n\t\t\t\t\t\t// and get feasible duals\n\t\t\t\t\t\tinfeasibilityCost_=0.0;\n\t\t\t\t\t\tcreateRim(4);\n\t\t\t\t\t\tnonLinearCost_->checkInfeasibilities(primalTolerance_);\n\t\t\t\t\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t\t\t\t\t\t// so will exit\n\t\t\t\t\t\tinfeasibilityCost_=1.0e30;\n\t\t\t\t\t\t// reset infeasibilities\n\t\t\t\t\t\tsumPrimalInfeasibilities_=nonLinearCost_->sumInfeasibilities();;\n\t\t\t\t\t\tnumberPrimalInfeasibilities_=\n\t\t\t\t\t\tnonLinearCost_->numberInfeasibilities();\n\t\t\t\t\t}\n\t\t\t\t\tif (infeasibilityCost_<1.0e20) {\n\t\t\t\t\t\tinfeasibilityCost_ *= 5.0;\n\t\t\t\t\t\t// reset looping criterion\n\t\t\t\t\t\tprogress->reset();\n\t\t\t\t\t\tchangeMade_++; // say change made\n\t\t\t\t\t\thandler_->message(CLP_PRIMAL_WEIGHT,messages_)\n\t\t\t\t\t\t<checkInfeasibilities(0.0);\n\t\t\t\t\t\tgutsOfSolution(NULL,NULL,ifValuesPass!=0);\n\t\t\t\t\t\tproblemStatus_=-1; //continue\n\t\t\t\t\t\tgoToDual=false;\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// say infeasible\n\t\t\t\t\t\tproblemStatus_ = 1;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t} else {\n\t\t\t// may be optimal\n\t\t\tif (perturbation_==101) {\n\t\t\t\tgoToDual=unPerturb(); // stop any further perturbation\n\t\t\t\tif (numberRows_>20000&&!numberTimesOptimal_)\n\t\t\t\t\tgoToDual=0; // Better to carry on a bit longer\n\t\t\t\tlastCleaned=-1; // carry on\n\t\t\t}\n\t\t\tbool unflagged = (unflag()!=0);\n\t\t\tif ( lastCleaned!=numberIterations_||unflagged) {\n\t\t\t\thandler_->message(CLP_PRIMAL_OPTIMAL,messages_)\n\t\t\t\t<zeroTolerance(std::min(factorization_->zeroTolerance(),1.0e-15));\n\t\t\t\t\t}\n\t\t\t\t\tlastCleaned=numberIterations_;\n\t\t\t\t\tif (primalTolerance_!=dblParam_[ClpPrimalTolerance])\n\t\t\t\t\t\thandler_->message(CLP_PRIMAL_ORIGINAL,messages_)\n\t\t\t\t\t\t<checkInfeasibilities(oldTolerance);\n#if 0\n\t\t\t\t\tint i;\n\t\t\t\t\tfor (i=0;inumberInfeasibilities()&&lastCleaned>=0)\n\t\t\t\t\t\tproblemStatus_=0;\n\t\t\t\t\telse\n\t\t\t\t\t\tproblemStatus_ = -1;\n\t\t\t\t} else {\n\t\t\t\t\tproblemStatus_=0; // optimal\n\t\t\t\t\tif (lastCleanedmessage(CLP_SIMPLEX_GIVINGUP,messages_)\n\t\t\t\t\t\t<numberInfeasibilities()) {\n\t\t\t\tif (infeasibilityCost_>1.0e18&&perturbation_==101) {\n\t\t\t\t\t// back off weight\n\t\t\t\t\tinfeasibilityCost_ = 1.0e13;\n\t\t\t\t\t// reset looping criterion\n\t\t\t\t\tprogress->reset();\n\t\t\t\t\tunPerturb(); // stop any further perturbation\n\t\t\t\t}\n\t\t\t\t//we need infeasiblity cost changed\n\t\t\t\tif (infeasibilityCost_<1.0e20) {\n\t\t\t\t\tinfeasibilityCost_ *= 5.0;\n\t\t\t\t\t// reset looping criterion\n\t\t\t\t\tprogress->reset();\n\t\t\t\t\tchangeMade_++; // say change made\n\t\t\t\t\thandler_->message(CLP_PRIMAL_WEIGHT,messages_)\n\t\t\t\t\t< (numberDualInfeasibilities_))<1.0e-5||\n\t\t\t\t\tprogress->lastIterationNumber(0)==numberIterations_) {\n\t\t\t\t\tif (!numberPrimalInfeasibilities_) {\n\t\t\t\t\t\tif (numberTimesOptimal_<4) {\n\t\t\t\t\t\t\tnumberTimesOptimal_++;\n\t\t\t\t\t\t\tchangeMade_++; // say change made\n\t\t\t\t\t\t} else {\n\t\t\t\t\t\t\tproblemStatus_=0;\n\t\t\t\t\t\t\tsecondaryStatus_=5;\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\tif (problemStatus_==0) {\n\t\tdouble objVal = nonLinearCost_->feasibleCost();\n\t\tdouble tol = 1.0e-10*std::max(fabs(objVal),fabs(objectiveValue_))+1.0e-8;\n\t\tif (fabs(objVal-objectiveValue_)>tol) {\n#ifdef COIN_DEVELOP\n\t\t\tif (handler_->logLevel()>0)\n\t\t\t\tprintf(\"nonLinearCost has feasible obj of %g, objectiveValue_ is %g\\n\",\n\t\t\t\t\t objVal,objectiveValue_);\n#endif\n\t\t\tobjectiveValue_ = objVal;\n\t\t}\n\t}\n\t// save extra stuff\n\tmatrix_->generalExpanded(this,5,dummy);\n\tif (type==0||type==1) {\n\t\tif (type!=1||!saveStatus_) {\n\t\t\t// create save arrays\n\t\t\tdelete [] saveStatus_;\n\t\t\tdelete [] savedSolution_;\n\t\t\tsaveStatus_ = new unsigned char [numberRows_+numberColumns_];\n\t\t\tsavedSolution_ = new double [numberRows_+numberColumns_];\n\t\t}\n\t\t// save arrays\n\t\tCoinMemcpyN(status_,numberColumns_+numberRows_,saveStatus_);\n\t\tCoinMemcpyN(rowActivityWork_,\n\t\t\t\t\tnumberRows_,savedSolution_+numberColumns_);\n\t\tCoinMemcpyN(columnActivityWork_,numberColumns_,savedSolution_);\n\t}\n\t// see if in Cbc etc\n\tbool inCbcOrOther = (specialOptions_&0x03000000)!=0;\n\tbool disaster=false;\n\tif (disasterArea_&&inCbcOrOther&&disasterArea_->check()) {\n\t\tdisasterArea_->saveInfo();\n\t\tdisaster=true;\n\t}\n\tif (disaster)\n\t\tproblemStatus_=3;\n\tif (problemStatus_<0&&!changeMade_) {\n\t\tproblemStatus_=4; // unknown\n\t}\n\tlastGoodIteration_ = numberIterations_;\n\tif (numberIterations_>lastBadIteration_+100)\n\t\tmoreSpecialOptions_ &= ~16; // clear check accuracy flag\n\tif (goToDual) \n\t\tproblemStatus_=10; // try dual\n\t// make sure first free monotonic\n\tif (firstFree_>=0&&saveFirstFree>=0) {\n\t\tfirstFree_=saveFirstFree;\n\t\tnextSuperBasic(1,NULL);\n\t}\n\tif (doFactorization) {\n\t\t// restore weights (if saved) - also recompute infeasibility list\n\t\tif (tentativeStatus>-3) \n\t\t\tprimalColumnPivot_->saveWeights(this,(type <2) ? 2 : 4);\n\t\telse\n\t\t\tprimalColumnPivot_->saveWeights(this,3);\n\t\tif (saveThreshold) {\n\t\t\t// use default at present\n\t\t\tfactorization_->sparseThreshold(0);\n\t\t\tfactorization_->goSparse();\n\t\t}\n\t}\n\t// Allow matrices to be sorted etc\n\tint fake=-999; // signal sort\n\tmatrix_->correctSequence(this,fake,fake);\n}\n/* \n Row array has pivot column\n This chooses pivot row.\n For speed, we may need to go to a bucket approach when many\n variables go through bounds\n On exit rhsArray will have changes in costs of basic variables\n */\nvoid \nIClpSimplexPrimal_Wolfe::primalRow(CoinIndexedVector * rowArray,\n\t\t\t\t\t\t\t\t CoinIndexedVector * rhsArray,\n\t\t\t\t\t\t\t\t CoinIndexedVector * spareArray,\n\t\t\t\t\t\t\t\t CoinIndexedVector * spareArray2,\n\t\t\t\t\t\t\t\t int valuesPass)\n{\n\tdouble saveDj = dualIn_;\n\tif (valuesPass&&objective_->type()<2) {\n\t\tdualIn_ = cost_[sequenceIn_];\n\t\t\n\t\tdouble * work=rowArray->denseVector();\n\t\tint number=rowArray->getNumElements();\n\t\tint * which=rowArray->getIndices();\n\t\t\n\t\tint iIndex;\n\t\tfor (iIndex=0;iIndexdualTolerance_) {\n\t\t\tdirectionIn_=-1;\n\t\t} else {\n\t\t\t// towards nearest bound\n\t\t\tif (valueIn_-lowerIn_100)\n\t\tacceptablePivot=acceptablePivot_;\n\tif (factorization_->pivots()>10)\n\t\tacceptablePivot=1.0e+3*acceptablePivot_; // if we have iterated be more strict\n\telse if (factorization_->pivots()>5)\n\t\tacceptablePivot=1.0e+2*acceptablePivot_; // if we have iterated be slightly more strict\n\telse if (factorization_->pivots())\n\t\tacceptablePivot=acceptablePivot_; // relax\n\tdouble bestEverPivot=acceptablePivot;\n\tint lastPivotRow = -1;\n\tdouble lastPivot=0.0;\n\tdouble lastTheta=1.0e50;\n\t\n\t// use spareArrays to put ones looked at in\n\t// First one is list of candidates\n\t// We could compress if we really know we won't need any more\n\t// Second array has current set of pivot candidates\n\t// with a backup list saved in double * part of indexed vector\n\t\n\t// pivot elements\n\tdouble * spare;\n\t// indices\n\tint * index;\n\tspareArray->clear();\n\tspare = spareArray->denseVector();\n\tindex = spareArray->getIndices();\n\t\n\t// we also need somewhere for effective rhs\n\tdouble * rhs=rhsArray->denseVector();\n\t// and we can use indices to point to alpha\n\t// that way we can store fabs(alpha)\n\tint * indexPoint = rhsArray->getIndices();\n\t//int numberFlip=0; // Those which may change if flips\n\t\n\t/*\n\t First we get a list of possible pivots. We can also see if the\n\t problem looks unbounded.\n\t \n\t At first we increase theta and see what happens. We start\n\t theta at a reasonable guess. If in right area then we do bit by bit.\n\t We save possible pivot candidates\n\t \n\t */\n\t\n\t// do first pass to get possibles \n\t// We can also see if unbounded\n\t\n\tdouble * work=rowArray->denseVector();\n\tint number=rowArray->getNumElements();\n\tint * which=rowArray->getIndices();\n\t\n\t// we need to swap sign if coming in from ub\n\tdouble way = directionIn_;\n\tdouble maximumMovement;\n\tif (way>0.0) \n\t\tmaximumMovement = std::min(1.0e30,upperIn_-valueIn_);\n\telse\n\t\tmaximumMovement = std::min(1.0e30,valueIn_-lowerIn_);\n\t\n\tdouble averageTheta = nonLinearCost_->averageTheta();\n\tdouble tentativeTheta = std::min(10.0*averageTheta,maximumMovement);\n\tdouble upperTheta = maximumMovement;\n\tif (tentativeTheta>0.5*maximumMovement)\n\t\ttentativeTheta=maximumMovement;\n\tbool thetaAtMaximum=tentativeTheta==maximumMovement;\n\t// In case tiny bounds increase\n\tif (maximumMovement<1.0)\n\t\ttentativeTheta *= 1.1;\n\tdouble dualCheck = fabs(dualIn_);\n\t// but make a bit more pessimistic\n\tdualCheck=std::max(dualCheck-100.0*dualTolerance_,0.99*dualCheck);\n\t\n\tint iIndex;\n\tint pivotOne=-1;\n\t//#define CLP_DEBUG\n#ifdef CLP_DEBUG\n\tif (numberIterations_==-3839||numberIterations_==-3840) {\n\t\tdouble dj=cost_[sequenceIn_];\n\t\tprintf(\"cost in on %d is %g, dual in %g\\n\",sequenceIn_,dj,dualIn_);\n\t\tfor (iIndex=0;iIndex %g (cost %g, dj %g)\\n\",\n\t\t\t\t iRow,iPivot,lower_[iPivot],solution_[iPivot],upper_[iPivot],\n\t\t\t\t alpha, solution_[iPivot]-1.0e9*alpha,cost_[iPivot],dj);\n\t\t}\n\t}\n#endif\n\twhile (true) {\n\t\tpivotOne=-1;\n\t\ttotalThru=0.0;\n\t\t// We also re-compute reduced cost\n\t\tnumberRemaining=0;\n\t\tdualIn_ = cost_[sequenceIn_];\n#ifndef NDEBUG\n\t\tdouble tolerance = primalTolerance_*1.002;\n#endif\n\t\tfor (iIndex=0;iIndex0.0) {\n\t\t\t\t// basic variable going towards lower bound\n\t\t\t\tdouble bound = lower_[iPivot];\n\t\t\t\t// must be exactly same as when used\n\t\t\t\tdouble change = tentativeTheta*alpha;\n\t\t\t\tpossible = (oldValue-change)<=bound+primalTolerance_;\n\t\t\t\toldValue -= bound;\n\t\t\t} else {\n\t\t\t\t// basic variable going towards upper bound\n\t\t\t\tdouble bound = upper_[iPivot];\n\t\t\t\t// must be exactly same as when used\n\t\t\t\tdouble change = tentativeTheta*alpha;\n\t\t\t\tpossible = (oldValue-change)>=bound-primalTolerance_;\n\t\t\t\toldValue = bound-oldValue;\n\t\t\t\talpha = - alpha;\n\t\t\t}\n\t\t\tdouble value;\n\t\t\tassert (oldValue>=-tolerance);\n\t\t\tif (possible) {\n\t\t\t\tvalue=oldValue-upperTheta*alpha;\n\t\t\t\tif (value<-primalTolerance_&&alpha>=acceptablePivot) {\n\t\t\t\t\tupperTheta = (oldValue+primalTolerance_)/alpha;\n\t\t\t\t\tpivotOne=numberRemaining;\n\t\t\t\t}\n\t\t\t\t// add to list\n\t\t\t\tspare[numberRemaining]=alpha;\n\t\t\t\trhs[numberRemaining]=oldValue;\n\t\t\t\tindexPoint[numberRemaining]=iIndex;\n\t\t\t\tindex[numberRemaining++]=iRow;\n\t\t\t\ttotalThru += alpha;\n\t\t\t\tsetActive(iRow);\n\t\t\t\t//} else if (value=1.0001*dualCheck) {\n\t\t\t// Can pivot here\n\t\t\tbreak;\n\t\t} else if (!thetaAtMaximum) {\n\t\t\t//printf(\"Going round with average theta of %g\\n\",averageTheta);\n\t\t\ttentativeTheta=maximumMovement;\n\t\t\tthetaAtMaximum=true; // seems to be odd compiler error\n\t\t} else {\n\t\t\tbreak;\n\t\t}\n\t}\n\ttotalThru=0.0;\n\t\n\ttheta_=maximumMovement;\n\t\n\tbool goBackOne = false;\n\tif (objective_->type()>1) \n\t\tdualIn_=saveDj;\n\t\n\t//printf(\"%d remain out of %d\\n\",numberRemaining,number);\n\tint iTry=0;\n#define MAXTRY 1000\n\tif (numberRemaining&&upperTheta=0&&0) {\n\t\t\tdouble thruCost = infeasibilityCost_*spare[pivotOne];\n\t\t\tif (thruCost>=0.99*fabs(dualIn_))\n\t\t\t\tprintf(\"Could pivot on %d as change %g dj %g\\n\",\n\t\t\t\t\t index[pivotOne],thruCost,dualIn_);\n\t\t\tdouble alpha = spare[pivotOne];\n\t\t\tdouble oldValue = rhs[pivotOne];\n\t\t\ttheta_ = oldValue/alpha;\n\t\t\tpivotRow_=pivotOne;\n\t\t\t// Stop loop\n\t\t\tiTry=MAXTRY;\n\t\t}\n\t\t\n\t\t// first get ratio with tolerance\n\t\tfor ( ;iTry=acceptablePivot) {\n\t\t\t\t\tupperTheta = (oldValue+primalTolerance_)/alpha;\n\t\t\t\t\tiBest=iIndex; // just in case weird numbers\n\t\t\t\t}\n\t\t\t}\n\t\t\t\n\t\t\t// now look at best in this lot\n\t\t\t// But also see how infeasible small pivots will make\n\t\t\tdouble sumInfeasibilities=0.0;\n\t\t\tdouble bestPivot=acceptablePivot;\n\t\t\tpivotRow_=-1;\n\t\t\tfor (iIndex=0;iIndexchangeInCost(pivotVariable_[iRow],trueAlpha,rhs[iIndex]);\n\t\t\t\t\tsetActive(iRow);\n\t\t\t\t\tif (alpha>bestPivot) {\n\t\t\t\t\t\tbestPivot=alpha;\n\t\t\t\t\t\ttheta_ = oldValue/bestPivot;\n\t\t\t\t\t\tpivotRow_=iIndex;\n\t\t\t\t\t} else if (alpha1.0e-6&& bestPivot<1.0e-3) {\n\t\t\t\t// back to previous one\n\t\t\t\tgoBackOne = true;\n\t\t\t\tbreak;\n\t\t\t} else if (pivotRow_==-1&&upperTheta>largeValue_) {\n\t\t\t\tif (lastPivot>acceptablePivot) {\n\t\t\t\t\t// back to previous one\n\t\t\t\t\tgoBackOne = true;\n\t\t\t\t} else {\n\t\t\t\t\t// can only get here if all pivots so far too small\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t} else if (totalThru>=dualCheck) {\n\t\t\t\tif (sumInfeasibilities>primalTolerance_&&!nonLinearCost_->numberInfeasibilities()) {\n\t\t\t\t\t// Looks a bad choice\n\t\t\t\t\tif (lastPivot>acceptablePivot) {\n\t\t\t\t\t\tgoBackOne=true;\n\t\t\t\t\t} else {\n\t\t\t\t\t\t// say no good\n\t\t\t\t\t\tdualIn_=0.0;\n\t\t\t\t\t}\n\t\t\t\t} \n\t\t\t\tbreak; // no point trying another loop\n\t\t\t} else {\n\t\t\t\tlastPivotRow=pivotRow_;\n\t\t\t\tlastTheta = theta_;\n\t\t\t\tif (bestPivot>bestEverPivot)\n\t\t\t\t\tbestEverPivot=bestPivot;\n\t\t\t} \n\t\t}\n\t\t// can get here without pivotRow_ set but with lastPivotRow\n\t\tif (goBackOne||(pivotRow_<0&&lastPivotRow>=0)) {\n\t\t\t// back to previous one\n\t\t\tpivotRow_=lastPivotRow;\n\t\t\ttheta_ = lastTheta;\n\t\t}\n\t} else if (pivotRow_<0&&maximumMovement>1.0e20) {\n\t\t// looks unbounded\n\t\tvalueOut_=COIN_DBL_MAX; // say odd\n\t\tif (nonLinearCost_->numberInfeasibilities()) {\n\t\t\t// but infeasible??\n\t\t\t// move variable but don't pivot\n\t\t\ttentativeTheta=1.0e50;\n\t\t\tfor (iIndex=0;iIndex0.0) {\n\t\t\t\t\t// basic variable going towards lower bound\n\t\t\t\t\tdouble bound = lower_[iPivot];\n\t\t\t\t\toldValue -= bound;\n\t\t\t\t} else {\n\t\t\t\t\t// basic variable going towards upper bound\n\t\t\t\t\tdouble bound = upper_[iPivot];\n\t\t\t\t\toldValue = bound-oldValue;\n\t\t\t\t\talpha = - alpha;\n\t\t\t\t}\n\t\t\t\tif (oldValue-tentativeTheta*alpha<0.0) {\n\t\t\t\t\ttentativeTheta = oldValue/alpha;\n\t\t\t\t}\n\t\t\t}\n\t\t\t// If free in then see if we can get to 0.0\n\t\t\tif (lowerIn_<-1.0e20&&upperIn_>1.0e20) {\n\t\t\t\tif (dualIn_*valueIn_>0.0) {\n\t\t\t\t\tif (fabs(valueIn_)<1.0e-2&&(tentativeTheta1.0e20)) {\n\t\t\t\t\t\ttentativeTheta = fabs(valueIn_);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tif (tentativeTheta<1.0e10)\n\t\t\t\tvalueOut_=valueIn_+way*tentativeTheta;\n\t\t}\n\t}\n\t//if (iTry>50)\n\t//printf(\"** %d tries\\n\",iTry);\n\tif (pivotRow_>=0) {\n\t\tint position=pivotRow_; // position in list\n\t\tpivotRow_=index[position];\n\t\talpha_=work[indexPoint[position]];\n\t\t// translate to sequence\n\t\tsequenceOut_ = pivotVariable_[pivotRow_];\n\t\tvalueOut_ = solution(sequenceOut_);\n\t\tlowerOut_=lower_[sequenceOut_];\n\t\tupperOut_=upper_[sequenceOut_];\n#define MINIMUMTHETA 1.0e-12\n\t\t// Movement should be minimum for anti-degeneracy - unless\n\t\t// fixed variable out\n\t\tdouble minimumTheta;\n\t\tif (upperOut_>lowerOut_)\n\t\t\tminimumTheta=MINIMUMTHETA;\n\t\telse\n\t\t\tminimumTheta=0.0;\n\t\t// But can't go infeasible\n\t\tdouble distance;\n\t\tif (alpha_*way>0.0) \n\t\t\tdistance=valueOut_-lowerOut_;\n\t\telse\n\t\t\tdistance=upperOut_-valueOut_;\n\t\tif (distance-minimumTheta*fabs(alpha_)<-primalTolerance_)\n\t\t\tminimumTheta = std::max(0.0,(distance+0.5*primalTolerance_)/fabs(alpha_));\n\t\t// will we need to increase tolerance\n\t\t//#define CLP_DEBUG\n\t\tdouble largestInfeasibility = primalTolerance_;\n\t\tif (theta_primalTolerance_&&(handler_->logLevel()&32)>-1)\n\t\t\t\tprintf(\"Primal tolerance increased from %g to %g\\n\",\n\t\t\t\t\t primalTolerance_,largestInfeasibility);\n#endif\n\t\t\t//#undef CLP_DEBUG\n\t\t\tprimalTolerance_ = std::max(primalTolerance_,largestInfeasibility);\n\t\t}\n\t\t// Need to look at all in some cases\n\t\tif (theta_>tentativeTheta) {\n\t\t\tfor (iIndex=0;iIndex1.0e-6||(specialOptions_&4)!=0) {\n\t\t\t\tupperOut_ = nonLinearCost_->nearest(sequenceOut_,newValue);\n\t\t\t} else {\n\t\t\t\tupperOut_ = newValue;\n\t\t\t}\n\t\t} else {\n\t\t\tdirectionOut_=1; // to lower bound\n\t\t\tif (fabs(theta_)>1.0e-6||(specialOptions_&4)!=0) {\n\t\t\t\tlowerOut_ = nonLinearCost_->nearest(sequenceOut_,newValue);\n\t\t\t} else {\n\t\t\t\tlowerOut_ = newValue;\n\t\t\t}\n\t\t}\n\t\tdualOut_ = reducedCost(sequenceOut_);\n\t} else if (maximumMovement<1.0e20) {\n\t\t// flip\n\t\tpivotRow_ = -2; // so we can tell its a flip\n\t\tsequenceOut_ = sequenceIn_;\n\t\tvalueOut_ = valueIn_;\n\t\tdualOut_ = dualIn_;\n\t\tlowerOut_ = lowerIn_;\n\t\tupperOut_ = upperIn_;\n\t\talpha_ = 0.0;\n\t\tif (way<0.0) {\n\t\t\tdirectionOut_=1; // to lower bound\n\t\t\ttheta_ = lowerOut_ - valueOut_;\n\t\t} else {\n\t\t\tdirectionOut_=-1; // to upper bound\n\t\t\ttheta_ = upperOut_ - valueOut_;\n\t\t}\n\t}\n\t\n\tdouble theta1 = std::max(theta_,1.0e-12);\n\tdouble theta2 = numberIterations_*nonLinearCost_->averageTheta();\n\t// Set average theta\n\tnonLinearCost_->setAverageTheta((theta1+theta2)/(static_cast (numberIterations_+1)));\n\t//if (numberIterations_%1000==0)\n\t//printf(\"average theta is %g\\n\",nonLinearCost_->averageTheta());\n\t\n\t// clear arrays\n\t\n\tCoinZeroN(spare,numberRemaining);\n\t\n\t// put back original bounds etc\n\tCoinMemcpyN(index,numberRemaining,rhsArray->getIndices());\n\trhsArray->setNumElements(numberRemaining);\n\trhsArray->setPacked();\n\tnonLinearCost_->goBackAll(rhsArray);\n\trhsArray->clear();\n\t\n}\n/* \n Chooses primal pivot column\n updateArray has cost updates (also use pivotRow_ from last iteration)\n Would be faster with separate region to scan\n and will have this (with square of infeasibility) when steepest\n For easy problems we can just choose one of the first columns we look at\n */\nvoid \nIClpSimplexPrimal_Wolfe::primalColumn(CoinIndexedVector * updates,\n\t\t\t\t\t\t\t\t\t CoinIndexedVector * spareRow1,\n\t\t\t\t\t\t\t\t\t CoinIndexedVector * spareRow2,\n\t\t\t\t\t\t\t\t\t CoinIndexedVector * spareColumn1,\n\t\t\t\t\t\t\t\t\t CoinIndexedVector * spareColumn2)\n{\n\t\n\tClpMatrixBase * saveMatrix = matrix_;\n\tdouble * saveRowScale = rowScale_;\n\tif (scaledMatrix_) {\n\t\trowScale_=NULL;\n\t\tmatrix_ = scaledMatrix_;\n\t}\n\tsequenceIn_ = primalColumnPivot_->pivotColumn(updates,spareRow1,\n\t\t\t\t\t\t\t\t\t\t\t\t spareRow2,spareColumn1,\n\t\t\t\t\t\t\t\t\t\t\t\t spareColumn2);\n\tif (scaledMatrix_) {\n\t\tmatrix_ = saveMatrix;\n\t\trowScale_ = saveRowScale;\n\t}\n\tif (sequenceIn_>=0) {\n\t\tvalueIn_=solution_[sequenceIn_];\n\t\tdualIn_=dj_[sequenceIn_];\n\t\tif (nonLinearCost_->lookBothWays()) {\n\t\t\t// double check \n\t\t\tIClpSimplex::Status status = getStatus(sequenceIn_);\n\t\t\t\n\t\t\tswitch(status) {\n\t\t\t\tcase IClpSimplex::atUpperBound:\n\t\t\t\t\tif (dualIn_<0.0) {\n\t\t\t\t\t\t// move to other side\n\t\t\t\t\t\tprintf(\"For %d U (%g, %g, %g) dj changed from %g\",\n\t\t\t\t\t\t\t sequenceIn_,lower_[sequenceIn_],solution_[sequenceIn_],\n\t\t\t\t\t\t\t upper_[sequenceIn_],dualIn_);\n\t\t\t\t\t\tdualIn_ -= nonLinearCost_->changeUpInCost(sequenceIn_);\n\t\t\t\t\t\tprintf(\" to %g\\n\",dualIn_);\n\t\t\t\t\t\tnonLinearCost_->setOne(sequenceIn_,upper_[sequenceIn_]+2.0*currentPrimalTolerance());\n\t\t\t\t\t\tsetStatus(sequenceIn_,IClpSimplex::atLowerBound);\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tcase IClpSimplex::atLowerBound:\n\t\t\t\t\tif (dualIn_>0.0) {\n\t\t\t\t\t\t// move to other side\n\t\t\t\t\t\tprintf(\"For %d L (%g, %g, %g) dj changed from %g\",\n\t\t\t\t\t\t\t sequenceIn_,lower_[sequenceIn_],solution_[sequenceIn_],\n\t\t\t\t\t\t\t upper_[sequenceIn_],dualIn_);\n\t\t\t\t\t\tdualIn_ -= nonLinearCost_->changeDownInCost(sequenceIn_);\n\t\t\t\t\t\tprintf(\" to %g\\n\",dualIn_);\n\t\t\t\t\t\tnonLinearCost_->setOne(sequenceIn_,lower_[sequenceIn_]-2.0*currentPrimalTolerance());\n\t\t\t\t\t\tsetStatus(sequenceIn_,IClpSimplex::atUpperBound);\n\t\t\t\t\t}\n\t\t\t\t\tbreak;\n\t\t\t\tdefault:\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tlowerIn_=lower_[sequenceIn_];\n\t\tupperIn_=upper_[sequenceIn_];\n\t\tif (dualIn_>0.0)\n\t\t\tdirectionIn_ = -1;\n\t\telse \n\t\t\tdirectionIn_ = 1;\n\t} else {\n\t\tsequenceIn_ = -1;\n\t}\n}\n/* The primals are updated by the given array.\n Returns number of infeasibilities.\n After rowArray will have list of cost changes\n */\nint \nIClpSimplexPrimal_Wolfe::updatePrimalsInPrimal(CoinIndexedVector * rowArray,\n\t\t\t\t\t\t\t\t\t\t\t double theta,\n\t\t\t\t\t\t\t\t\t\t\t double & objectiveChange,\n\t\t\t\t\t\t\t\t\t\t\t int valuesPass)\n{\n\t// Cost on pivot row may change - may need to change dualIn\n\tdouble oldCost=0.0;\n\tif (pivotRow_>=0)\n\t\toldCost = cost_[sequenceOut_];\n\t//rowArray->scanAndPack();\n\tdouble * work=rowArray->denseVector();\n\tint number=rowArray->getNumElements();\n\tint * which=rowArray->getIndices();\n\t\n\tint newNumber = 0;\n\tint pivotPosition = -1;\n\tnonLinearCost_->setChangeInCost(0.0);\n\t//printf(\"XX 4138 sol %g lower %g upper %g cost %g status %d\\n\",\n\t// solution_[4138],lower_[4138],upper_[4138],cost_[4138],status_[4138]);\n\t// allow for case where bound+tolerance == bound\n\t//double tolerance = 0.999999*primalTolerance_;\n\tdouble relaxedTolerance = 1.001*primalTolerance_;\n\tint iIndex;\n\tif (!valuesPass) {\n\t\tfor (iIndex=0;iIndex0.0) {\n\t\t\t\t\t// going down\n\t\t\t\t\tif (value<=lower_[iPivot]+primalTolerance_) {\n\t\t\t\t\t\tif (iPivot==sequenceOut_&&value>lower_[iPivot]-relaxedTolerance)\n\t\t\t\t\t\t\tvalue=lower_[iPivot];\n\t\t\t\t\t\tdouble difference = nonLinearCost_->setOne(iPivot,value);\n\t\t\t\t\t\tassert (!difference||fabs(change)>1.0e9);\n\t\t\t\t\t}\n\t\t\t\t} else {\n\t\t\t\t\t// going up\n\t\t\t\t\tif (value>=upper_[iPivot]-primalTolerance_) {\n\t\t\t\t\t\tif (iPivot==sequenceOut_&&value