$(LPSOLVELIB)

                CoinMP.lib

#undef LANGUAGE_NONE

#include <coinmp/CoinMP.h>

#define WINAPI __stdcall

#define LoadInverseLib FALSE

#define LoadLanguageLib FALSE

#include <lpsolve/lp_lib.h>

#undef LANGUAGE_NONE

    // build lp_solve model

    // build parameter arrays for CoinMP

    REAL* pObjVal = new REAL[nVariables+1];

    double* pObjectCoeffs = new double[nVariables];

    pObjVal[0] = 0.0;                           // ignored

        pObjVal[nVar+1] = rObjCoeff[nVar+1];

        pObjectCoeffs[nVar] = rObjCoeff[nVar+1];

    set_obj_fn( lp, pObjVal );

    double nObjectConst = rObjCoeff[0];             // constant term of objective

    delete[] pObjVal;

    set_rh( lp, 0, rObjCoeff[0] );              // constant term of objective

    set_add_rowmode(lp, TRUE);

    size_t nRows = maConstraints.getLength();

    size_t nCompSize = nVariables * nRows;

    double* pCompMatrix = new double[nCompSize];    // first collect all coefficients, row-wise

    for (size_t i=0; i<nCompSize; i++)

        pCompMatrix[i] = 0.0;

    double* pRHS = new double[nRows];

    char* pRowType = new char[nRows];

    for (size_t i=0; i<nRows; i++)

    {

        pRHS[i] = 0.0;

        pRowType[i] = 'N';

    }

            REAL* pValues = new REAL[nVariables+1];

            double* pValues = &pCompMatrix[nConstrPos * nVariables];

            pValues[0] = 0.0;                               // ignored?

                pValues[nVar+1] = rLeftCoeff[nVar+1];

                pValues[nVar] = rLeftCoeff[nVar+1];

                    pValues[nVar+1] -= rRightCoeff[nVar+1];

                    pValues[nVar] -= rRightCoeff[nVar+1];

                case sheet::SolverConstraintOperator_LESS_EQUAL:    nConstrType = LE; break;

                case sheet::SolverConstraintOperator_LESS_EQUAL:    pRowType[nConstrPos] = 'L'; break;

                case sheet::SolverConstraintOperator_GREATER_EQUAL: nConstrType = GE; break;

                case sheet::SolverConstraintOperator_GREATER_EQUAL: pRowType[nConstrPos] = 'G'; break;

                case sheet::SolverConstraintOperator_EQUAL:         nConstrType = EQ; break;

                case sheet::SolverConstraintOperator_EQUAL:         pRowType[nConstrPos] = 'E'; break;

            add_constraint( lp, pValues, nConstrType, fRightValue );

            pRHS[nConstrPos] = fRightValue;

            delete[] pValues;

    set_add_rowmode(lp, FALSE);

    // Find non-zero coefficients, column-wise

    int* pMatrixBegin = new int[nVariables+1];

    int* pMatrixCount = new int[nVariables];

    double* pMatrix = new double[nCompSize];    // not always completely used

    int* pMatrixIndex = new int[nCompSize];

    int nMatrixPos = 0;

    for (nVar=0; nVar<nVariables; nVar++)

    {

        int nBegin = nMatrixPos;

        for (size_t nRow=0; nRow<nRows; nRow++)

        {

            double fCoeff = pCompMatrix[ nRow * nVariables + nVar ];    // row-wise

            if ( fCoeff != 0.0 )

            {

                pMatrix[nMatrixPos] = fCoeff;

                pMatrixIndex[nMatrixPos] = nRow;

                ++nMatrixPos;

            }

        }

        pMatrixBegin[nVar] = nBegin;

        pMatrixCount[nVar] = nMatrixPos - nBegin;

    }

    pMatrixBegin[nVariables] = nMatrixPos;

    delete[] pCompMatrix;

    pCompMatrix = NULL;

        if ( !mbNonNegative )

        pLowerBounds[nVar] = mbNonNegative ? 0.0 : -DBL_MAX;

            set_unbounded(lp, nVar+1);          // allow negative (default is non-negative)

        pUpperBounds[nVar] = DBL_MAX;

                                                //! collect bounds from constraints?

        if ( mbInteger )

        // bounds could possibly be further restricted from single-cell constraints

            set_int(lp, nVar+1, TRUE);

                        set_int(lp, nVar+1, TRUE);

                        pColType[nVar] = 'I';

                        set_binary(lp, nVar+1, TRUE);

                    {

                        pColType[nVar] = 'B';

                        pLowerBounds[nVar] = 0.0;

                        pUpperBounds[nVar] = 1.0;

                    }

    if ( mbMaximize )

    int nObjectSense = mbMaximize ? SOLV_OBJSENS_MAX : SOLV_OBJSENS_MIN;

        set_maxim(lp);

    else

        set_minim(lp);

    if ( !mbLimitBBDepth )

    HPROB hProb = CoinCreateProblem("");

        set_bb_depthlimit( lp, 0 );

    int nResult = CoinLoadProblem( hProb, nVariables, nRows, nMatrixPos, 0,

                    nObjectSense, nObjectConst, pObjectCoeffs,

                    pLowerBounds, pUpperBounds, pRowType, pRHS, NULL,

                    pMatrixBegin, pMatrixCount, pMatrixIndex, pMatrix,

                    NULL, NULL, NULL );

    nResult = CoinLoadInteger( hProb, pColType );

    set_epslevel( lp, mnEpsilonLevel );

    delete[] pColType;

    set_timeout( lp, mnTimeout );

    delete[] pMatrixIndex;

    delete[] pMatrix;

    delete[] pMatrixCount;

    delete[] pMatrixBegin;

    delete[] pUpperBounds;

    delete[] pLowerBounds;

    delete[] pRowType;

    delete[] pRHS;

    delete[] pObjectCoeffs;

    CoinSetRealOption( hProb, COIN_REAL_MAXSECONDS, mnTimeout );

    CoinSetRealOption( hProb, COIN_REAL_MIPMAXSEC, mnTimeout );

    // TODO: handle (or remove) settings: epsilon, B&B depth

    int nResult = ::solve( lp );

    nResult = CoinCheckProblem( hProb );

    nResult = CoinOptimizeProblem( hProb, 0 );

    mbSuccess = ( nResult == OPTIMAL );

    mbSuccess = ( nResult == SOLV_CALL_SUCCESS );

        REAL* pResultVar = NULL;

    CoinUnloadProblem( hProb );

        get_ptr_variables( lp, &pResultVar );

        for (nVar=0; nVar<nVariables; nVar++)

            maSolution[nVar] = pResultVar[nVar];

        mfResultValue = get_objective( lp );

    }

    else if ( nResult == INFEASIBLE )

        maStatus = lcl_GetResourceString( RID_ERROR_INFEASIBLE );

    else if ( nResult == UNBOUNDED )

        maStatus = lcl_GetResourceString( RID_ERROR_UNBOUNDED );

    else if ( nResult == TIMEOUT || nResult == SUBOPTIMAL )

        maStatus = lcl_GetResourceString( RID_ERROR_TIMEOUT );

    // SUBOPTIMAL is assumed to be caused by a timeout, and reported as an error

    delete_lp( lp );