Ejemplo n.º 1
0
void mexFunction
(
    int nargout,
    mxArray *pargout [ ],
    int nargin,
    const mxArray *pargin [ ]
)
{
    Int *Ap, *Ai, *E, *Bp, *Bi, *HPinv ;
    double *Ax, *Bx, dummy, tol ;
    Int m, n, anz, bnz, is_complex, econ, A_complex, B_complex ;
    spqr_mx_options opts ;
    cholmod_sparse *A, Amatrix, *R, *Q, *Csparse, Bsmatrix, *Bsparse, *H ;
    cholmod_dense *Cdense, Bdmatrix, *Bdense, *HTau ;
    cholmod_common Common, *cc ;

#ifdef TIMING
    double t0 = (nargout > 3) ? spqr_time ( ) : 0 ;
#endif

    // -------------------------------------------------------------------------
    // start CHOLMOD and set parameters
    // -------------------------------------------------------------------------

    cc = &Common ;
    cholmod_l_start (cc) ;
    spqr_mx_config (SPUMONI, cc) ;

    // -------------------------------------------------------------------------
    // check inputs
    // -------------------------------------------------------------------------

    // nargin can be 1, 2, or 3
    // nargout can be 0, 1, 2, 3, or 4

    if (nargout > 4)
    {
        mexErrMsgIdAndTxt ("MATLAB:maxlhs", "Too many output arguments") ;
    }
    if (nargin < 1)
    {
        mexErrMsgIdAndTxt ("MATLAB:minrhs", "Not enough input arguments") ;
    }
    if (nargin > 3)
    {
        mexErrMsgIdAndTxt ("MATLAB:maxrhs", "Too many input arguments") ;
    }

    // -------------------------------------------------------------------------
    // get the input matrix A
    // -------------------------------------------------------------------------

    if (!mxIsSparse (pargin [0]))
    {
        mexErrMsgIdAndTxt ("QR:invalidInput", "A must be sparse") ;
    }

    A = spqr_mx_get_sparse (pargin [0], &Amatrix, &dummy) ;
    Ap = (Int *) A->p ;
    Ai = (Int *) A->i ;
    m = A->nrow ;
    n = A->ncol ;
    A_complex = mxIsComplex (pargin [0]) ;

    // -------------------------------------------------------------------------
    // determine usage and parameters
    // -------------------------------------------------------------------------

    if (nargin == 1)
    {

        // ---------------------------------------------------------------------
        // [ ] = qr (A)
        // ---------------------------------------------------------------------

        spqr_mx_get_options (NULL, &opts, m, nargout, cc) ;
        // R = qr (A)
        // [Q,R] = qr (A)
        // [Q,R,E] = qr (A)

    }
    else if (nargin == 2)
    {

        // ---------------------------------------------------------------------
        // [ ] = qr (A,0), [ ] = qr (A,opts), or [ ] = qr (A,B)
        // ---------------------------------------------------------------------

        if (is_zero (pargin [1]))
        {

            // -----------------------------------------------------------------
            // [ ... ] = qr (A,0)
            // -----------------------------------------------------------------

            spqr_mx_get_options (NULL, &opts, m, nargout, cc) ;
            opts.econ = n ;
            opts.permvector = TRUE ;
            // R = qr (A,0)
            // [Q,R] = qr (A,0)
            // [Q,R,E] = qr (A,0)

        }
        else if (mxIsEmpty (pargin [1]) || mxIsStruct (pargin [1]))
        {

            // -----------------------------------------------------------------
            // [ ] = qr (A,opts)
            // -----------------------------------------------------------------

            spqr_mx_get_options (pargin [1], &opts, m, nargout, cc) ;
            // R = qr (A,opts)
            // [Q,R] = qr (A,opts)
            // [Q,R,E] = qr (A,opts)

        }
        else
        {

            // -----------------------------------------------------------------
            // [ ] = qr (A,B)
            // -----------------------------------------------------------------

            spqr_mx_get_options (NULL, &opts, m, nargout, cc) ;
            opts.haveB = TRUE ;
            opts.Qformat = SPQR_Q_DISCARD ;
            if (nargout <= 1)
            {
                mexErrMsgIdAndTxt ("MATLAB:minlhs",
                    "Not enough output arguments") ;
            }
            // [C,R] = qr (A,B)
            // [C,R,E] = qr (A,B)

        }

    }
    else // if (nargin == 3)
    {

        // ---------------------------------------------------------------------
        // [ ] = qr (A,B,opts)
        // ---------------------------------------------------------------------

        if (is_zero (pargin [2]))
        {

            // -----------------------------------------------------------------
            // [ ] = qr (A,B,0)
            // -----------------------------------------------------------------

            spqr_mx_get_options (NULL, &opts, m, nargout, cc) ;
            opts.econ = n ;
            opts.permvector = TRUE ;
            opts.haveB = TRUE ;
            opts.Qformat = SPQR_Q_DISCARD ;
            if (nargout <= 1)
            {
                mexErrMsgIdAndTxt ("MATLAB:minlhs",
                    "Not enough output arguments") ;
            }
            // [C,R] = qr (A,B,0)
            // [C,R,E] = qr (A,B,0)

        }
        else if (mxIsEmpty (pargin [2]) || mxIsStruct (pargin [2]))
        {

            // -----------------------------------------------------------------
            // [ ] = qr (A,B,opts)
            // -----------------------------------------------------------------

            spqr_mx_get_options (pargin [2], &opts, m, nargout, cc) ;
            opts.haveB = TRUE ;
            opts.Qformat = SPQR_Q_DISCARD ;
            if (nargout <= 1)
            {
                mexErrMsgIdAndTxt ("MATLAB:minlhs",
                    "Not enough output arguments") ;
            }
            // [C,R] = qr (A,B,opts)
            // [C,R,E] = qr (A,B,opts)

        }
        else
        {
            mexErrMsgIdAndTxt ("QR:invalidInput", "Invalid opts argument") ;
        }
    }

    int order = opts.ordering ;
    tol = opts.tol ;
    econ = opts.econ ;

    // -------------------------------------------------------------------------
    // get A and convert to merged-complex if needed
    // -------------------------------------------------------------------------

    if (opts.haveB)
    {
        B_complex = mxIsComplex (pargin [1]) ;
    }
    else
    {
        B_complex = FALSE ;
    }

    is_complex = (A_complex || B_complex) ;
    Ax = spqr_mx_merge_if_complex (pargin [0], is_complex, &anz, cc) ; 
    if (is_complex)
    {
        // A has been converted from real or zomplex to complex
        A->x = Ax ;
        A->z = NULL ;
        A->xtype = CHOLMOD_COMPLEX ;
    }

    // -------------------------------------------------------------------------
    // analyze, factorize, and get the results
    // -------------------------------------------------------------------------

    if (opts.haveB)
    {

        // ---------------------------------------------------------------------
        // get B, and convert to complex if necessary
        // ---------------------------------------------------------------------

        if (!mxIsNumeric (pargin [1]))
        {
            mexErrMsgIdAndTxt ("QR:invalidInput", "invalid non-numeric B") ;
        }
        if (mxGetM (pargin [1]) != m)
        {
            mexErrMsgIdAndTxt ("QR:invalidInput",
                "A and B must have the same number of rows") ;
        }

        // convert from real or zomplex to complex
        Bx = spqr_mx_merge_if_complex (pargin [1], is_complex, &bnz, cc) ;

        int B_is_sparse = mxIsSparse (pargin [1]) ;
        if (B_is_sparse)
        {
            Bsparse = spqr_mx_get_sparse (pargin [1], &Bsmatrix, &dummy) ;
            Bdense = NULL ;
            if (is_complex)
            {
                // Bsparse has been converted from real or zomplex to complex
                Bsparse->x = Bx ;
                Bsparse->z = NULL ;
                Bsparse->xtype = CHOLMOD_COMPLEX ;
            }
        }
        else
        {
            Bsparse = NULL ;
            Bdense = spqr_mx_get_dense (pargin [1], &Bdmatrix, &dummy) ;
            if (is_complex)
            {
                // Bdense has been converted from real or zomplex to complex
                Bdense->x = Bx ;
                Bdense->z = NULL ;
                Bdense->xtype = CHOLMOD_COMPLEX ;
            }
        }

        // ---------------------------------------------------------------------
        // [C,R,E] = qr (A,B,...) or [C,R] = qr (A,B,...)
        // ---------------------------------------------------------------------

        if (is_complex)
        {

            // -----------------------------------------------------------------
            // [C,R,E] = qr (A,B): complex case
            // -----------------------------------------------------------------

            if (B_is_sparse)
            {
                // B and C are both sparse and complex
                SuiteSparseQR <Complex> (order, tol, econ, A, Bsparse,
                    &Csparse, &R, &E, cc) ;
                pargout [0] = spqr_mx_put_sparse (&Csparse, cc) ;
            }
            else
            {
                // B and C are both dense and complex
                SuiteSparseQR <Complex> (order, tol, econ, A, Bdense,
                    &Cdense, &R, &E, cc) ;
                pargout [0] = spqr_mx_put_dense (&Cdense, cc) ;
            }

        }
        else
        {

            // -----------------------------------------------------------------
            // [C,R,E] = qr (A,B): real case
            // -----------------------------------------------------------------

            if (B_is_sparse)
            {
                // B and C are both sparse and real
                SuiteSparseQR <double> (order, tol, econ, A, Bsparse,
                    &Csparse, &R, &E, cc) ;
                pargout [0] = spqr_mx_put_sparse (&Csparse, cc) ;
            }
            else
            {
                // B and C are both dense and real
                SuiteSparseQR <double> (order, tol, econ, A, Bdense,
                    &Cdense, &R, &E, cc) ;
                pargout [0] = spqr_mx_put_dense (&Cdense, cc) ;
            }
        }

        pargout [1] = spqr_mx_put_sparse (&R, cc) ;

    }
    else if (nargout <= 1)
    {

        // ---------------------------------------------------------------------
        // R = qr (A) or R = qr (A,opts)
        // ---------------------------------------------------------------------

        if (is_complex)
        {
            SuiteSparseQR <Complex> (0, tol, econ, A, &R, NULL, cc) ;
        }
        else
        {
            SuiteSparseQR <double> (0, tol, econ, A, &R, NULL, cc) ;
        }
        pargout [0] = spqr_mx_put_sparse (&R, cc) ;

    }
    else
    {

        // ---------------------------------------------------------------------
        // [Q,R,E] = qr (A,...) or [Q,R] = qr (A,...)
        // ---------------------------------------------------------------------

        if (opts.Qformat == SPQR_Q_DISCARD)
        {

            // -----------------------------------------------------------------
            // Q is discarded, and Q = [ ] is returned as a placeholder
            // -----------------------------------------------------------------

            if (is_complex)
            {
                SuiteSparseQR <Complex> (order, tol, econ, A, &R, &E, cc);
            }
            else
            {
                SuiteSparseQR <double> (order, tol, econ, A, &R, &E, cc) ;
            }
            pargout [0] = mxCreateDoubleMatrix (0, 0, mxREAL) ;

        }
        else if (opts.Qformat == SPQR_Q_MATRIX)
        {

            // -----------------------------------------------------------------
            // Q is a sparse matrix
            // -----------------------------------------------------------------

            if (is_complex)
            {
                SuiteSparseQR <Complex> (order, tol, econ, A, &Q, &R, &E, cc) ;
            }
            else
            {
                SuiteSparseQR <double> (order, tol, econ, A, &Q, &R, &E, cc) ;
            }
            pargout [0] = spqr_mx_put_sparse (&Q, cc) ;

        }
        else
        {

            // -----------------------------------------------------------------
            // H is kept, and Q is a struct containing H, Tau, and P
            // -----------------------------------------------------------------

            mxArray *Tau, *P, *Hmatlab ;
            if (is_complex)
            {
                SuiteSparseQR <Complex> (order, tol, econ, A,
                    &R, &E, &H, &HPinv, &HTau, cc) ;
            }
            else
            {
                SuiteSparseQR <double> (order, tol, econ, A,
                    &R, &E, &H, &HPinv, &HTau, cc) ;
            }

            Tau = spqr_mx_put_dense (&HTau, cc) ;
            Hmatlab = spqr_mx_put_sparse (&H, cc) ;

            // Q.P contains the inverse row permutation
            P = mxCreateDoubleMatrix (1, m, mxREAL) ;
            double *Tx = mxGetPr (P) ;
            for (Int i = 0 ; i < m ; i++)
            {
                Tx [i] = HPinv [i] + 1 ;
            }

            // return Q
            const char *Qstruct [ ] = { "H", "Tau", "P" } ;
            pargout [0] = mxCreateStructMatrix (1, 1, 3, Qstruct) ;
            mxSetFieldByNumber (pargout [0], 0, 0, Hmatlab) ;
            mxSetFieldByNumber (pargout [0], 0, 1, Tau) ;
            mxSetFieldByNumber (pargout [0], 0, 2, P) ;

        }
        pargout [1] = spqr_mx_put_sparse (&R, cc) ;
    }

    // -------------------------------------------------------------------------
    // return E
    // -------------------------------------------------------------------------

    if (nargout > 2)
    {
        pargout [2] = spqr_mx_put_permutation (E, n, opts.permvector, cc) ;
    }

    // -------------------------------------------------------------------------
    // free copy of merged-complex, if needed
    // -------------------------------------------------------------------------

    if (is_complex)
    {
        // this was allocated by merge_if_complex
        cholmod_l_free (anz, sizeof (Complex), Ax, cc) ;
        if (opts.haveB)
        {
            cholmod_l_free (bnz, sizeof (Complex), Bx, cc) ;
        }
    }

    // -------------------------------------------------------------------------
    // info output
    // -------------------------------------------------------------------------

    if (nargout > 3)
    {
#ifdef TIMING
        double flops = cc->other1 [0] ;
        double t = spqr_time ( ) - t0 ;
#else
        double flops = -1 ;
        double t = -1 ;
#endif
        pargout [3] = spqr_mx_info (cc, t, flops) ;
    }

    cholmod_l_finish (cc) ;
    if (opts.spumoni > 0) spqr_mx_spumoni (&opts, is_complex, cc) ;
}
Ejemplo n.º 2
0
void mexFunction
(
    int nargout,
    mxArray *pargout [ ],
    int nargin,
    const mxArray *pargin [ ]
)
{
    Int *Bp, *Bi ;
    double *Ax, *Bx, dummy ;
    Int m, n, k, bncols, p, i, rank, A_complex, B_complex, is_complex,
        anz, bnz ;
    spqr_mx_options opts ;
    cholmod_sparse *A, Amatrix, *Xsparse ; 
    cholmod_dense *Xdense ;
    cholmod_common Common, *cc ;
    char msg [LEN+1] ;

#ifdef TIMING
    double t0 = (nargout > 1) ? spqr_time ( ) : 0 ;
#endif

    // -------------------------------------------------------------------------
    // start CHOLMOD and set parameters
    // -------------------------------------------------------------------------

    cc = &Common ;
    cholmod_l_start (cc) ;
    spqr_mx_config (SPUMONI, cc) ;

    // -------------------------------------------------------------------------
    // check inputs
    // -------------------------------------------------------------------------

    if (nargout > 2)
    {
        mexErrMsgIdAndTxt ("MATLAB:maxlhs", "Too many output arguments") ;
    }
    if (nargin < 2)
    {
        mexErrMsgIdAndTxt ("MATLAB:minrhs", "Not enough input arguments") ;
    }
    if (nargin > 3)
    {
        mexErrMsgIdAndTxt ("MATLAB:maxrhs", "Too many input arguments") ;
    }

    // -------------------------------------------------------------------------
    // get the input matrix A (must be sparse)
    // -------------------------------------------------------------------------

    if (!mxIsSparse (pargin [0]))
    {
        mexErrMsgIdAndTxt ("QR:invalidInput", "A must be sparse") ;
    }

    A = spqr_mx_get_sparse (pargin [0], &Amatrix, &dummy) ;
    m = A->nrow ;
    n = A->ncol ;
    A_complex = mxIsComplex (pargin [0]) ;

    B_complex = mxIsComplex (pargin [1]) ;
    is_complex = (A_complex || B_complex) ;
    Ax = spqr_mx_merge_if_complex (pargin [0], is_complex, &anz, cc) ; 
    if (is_complex)
    {
        // A has been converted from real or zomplex to complex
        A->x = Ax ;
        A->z = NULL ;
        A->xtype = CHOLMOD_COMPLEX ;
    }

    // -------------------------------------------------------------------------
    // determine usage and parameters
    // -------------------------------------------------------------------------

    spqr_mx_get_options ((nargin < 3) ? NULL : pargin [2], &opts, m, 3, cc) ;

    opts.Qformat = SPQR_Q_DISCARD ;
    opts.econ = 0 ;
    opts.permvector = TRUE ;
    opts.haveB = TRUE ;

    // -------------------------------------------------------------------------
    // get the input matrix B (sparse or dense)
    // -------------------------------------------------------------------------

    if (!mxIsNumeric (pargin [1]))
    {
        mexErrMsgIdAndTxt ("QR:invalidInput", "invalid non-numeric B") ;
    }
    if (mxGetM (pargin [1]) != m)
    {
        mexErrMsgIdAndTxt ("QR:invalidInput",
            "A and B must have the same number of rows") ;
    }

    cholmod_sparse Bsmatrix, *Bsparse ;
    cholmod_dense  Bdmatrix, *Bdense ;

    // convert from real or zomplex to complex
    Bx = spqr_mx_merge_if_complex (pargin [1], is_complex, &bnz, cc) ;

    int B_is_sparse = mxIsSparse (pargin [1]) ;
    if (B_is_sparse)
    {
        Bsparse = spqr_mx_get_sparse (pargin [1], &Bsmatrix, &dummy) ;
        Bdense = NULL ;
        if (is_complex)
        {
            // Bsparse has been converted from real or zomplex to complex
            Bsparse->x = Bx ;
            Bsparse->z = NULL ;
            Bsparse->xtype = CHOLMOD_COMPLEX ;
        }
    }
    else
    {
        Bsparse = NULL ;
        Bdense = spqr_mx_get_dense (pargin [1], &Bdmatrix, &dummy) ;
        if (is_complex)
        {
            // Bdense has been converted from real or zomplex to complex
            Bdense->x = Bx ;
            Bdense->z = NULL ;
            Bdense->xtype = CHOLMOD_COMPLEX ;
        }
    }

    // -------------------------------------------------------------------------
    // X = A\B
    // -------------------------------------------------------------------------

    if (opts.min2norm && m < n)
    {
#ifndef NEXPERT
        // This requires SuiteSparseQR_expert.cpp
        if (is_complex)
        {
            if (B_is_sparse)
            {
                // X and B are both sparse and complex
                Xsparse = SuiteSparseQR_min2norm <Complex> (opts.ordering,
                    opts.tol, A, Bsparse, cc) ;
                pargout [0] = spqr_mx_put_sparse (&Xsparse, cc) ;
            }
            else
            {
                // X and B are both dense and complex
                Xdense = SuiteSparseQR_min2norm <Complex> (opts.ordering,
                    opts.tol, A, Bdense, cc) ;
                pargout [0] = spqr_mx_put_dense (&Xdense, cc) ;
            }
        }
        else
        {
            if (B_is_sparse)
            {
                // X and B are both sparse and real
                Xsparse = SuiteSparseQR_min2norm <double> (opts.ordering,
                    opts.tol, A, Bsparse, cc) ;
                pargout [0] = spqr_mx_put_sparse (&Xsparse, cc) ;
            }
            else
            {
                // X and B are both dense and real
                Xdense = SuiteSparseQR_min2norm <double> (opts.ordering,
                    opts.tol, A, Bdense, cc) ;
                pargout [0] = spqr_mx_put_dense (&Xdense, cc) ;
            }
        }
#else
        mexErrMsgIdAndTxt ("QR:notInstalled", "min2norm method not installed") ;
#endif

    }
    else
    {

        if (is_complex)
        {
            if (B_is_sparse)
            {
                // X and B are both sparse and complex
                Xsparse = SuiteSparseQR <Complex> (opts.ordering, opts.tol,
                    A, Bsparse, cc) ;
                pargout [0] = spqr_mx_put_sparse (&Xsparse, cc) ;
            }
            else
            {
                // X and B are both dense and complex
                Xdense = SuiteSparseQR <Complex> (opts.ordering, opts.tol,
                    A, Bdense, cc) ;
                pargout [0] = spqr_mx_put_dense (&Xdense, cc) ;
            }
        }
        else
        {
            if (B_is_sparse)
            {
                // X and B are both sparse and real
                Xsparse = SuiteSparseQR <double> (opts.ordering, opts.tol,
                    A, Bsparse, cc) ;
                pargout [0] = spqr_mx_put_sparse (&Xsparse, cc) ;
            }
            else
            {
                // X and B are both dense and real
                Xdense = SuiteSparseQR <double> (opts.ordering, opts.tol,
                    A, Bdense, cc) ;
                pargout [0] = spqr_mx_put_dense (&Xdense, cc) ;
            }
        }
    }

    // -------------------------------------------------------------------------
    // info output
    // -------------------------------------------------------------------------

    if (nargout > 1)
    {
#ifdef TIMING
        double flops = cc->other1 [0] ;
        double t = spqr_time ( ) - t0 ;
#else
        double flops = -1 ;
        double t = -1 ;
#endif
        pargout [1] = spqr_mx_info (cc, t, flops) ;
    }

    // -------------------------------------------------------------------------
    // warn if rank deficient
    // -------------------------------------------------------------------------

    rank = cc->SPQR_istat [4] ;
    if (rank < MIN (m,n))
    {
        // snprintf would be safer, but Windows is oblivious to safety ...
        // (Visual Studio C++ 2008 does not recognize snprintf!)
        sprintf (msg, "rank deficient. rank = %ld tol = %g\n", rank,
            cc->SPQR_xstat [1]) ;
        mexWarnMsgIdAndTxt ("MATLAB:rankDeficientMatrix", msg) ;
    }

    if (is_complex)
    {
        // free the merged complex copies of A and B
        cholmod_l_free (anz, sizeof (Complex), Ax, cc) ;
        cholmod_l_free (bnz, sizeof (Complex), Bx, cc) ;
    }

    cholmod_l_finish (cc) ;
    if (opts.spumoni > 0) spqr_mx_spumoni (&opts, is_complex, cc) ;
}
void mexFunction
(
    int nargout,
    mxArray *pargout [ ],
    int nargin,
    const mxArray *pargin [ ]
)
{
    mxArray *Hmatlab, *Tau, *P ;
    Long *HPinv, *Yp, *Yi ;
    double *Hx, *Xx, *Tx, *Px, dummy ;
    Long m, n, k, nh, nb, p, i, method, mh, gotP, X_is_sparse, is_complex, hnz,
        tnz, xnz, inuse, count ;
    cholmod_sparse *Ysparse, *H, Hmatrix, *Xsparse, Xsmatrix ;
    cholmod_dense *Ydense, *Xdense, Xdmatrix, *HTau, HTau_matrix ;
    cholmod_common Common, *cc ;

    // -------------------------------------------------------------------------
    // start CHOLMOD and set parameters
    // -------------------------------------------------------------------------

    cc = &Common ;
    cholmod_l_start (cc) ;
    spqr_mx_config (SPUMONI, cc) ;

    // -------------------------------------------------------------------------
    // check inputs
    // -------------------------------------------------------------------------

    // nargin can be 2 or 3
    // nargout can be 0 or 1

    if (nargout > 1)
    {
        mexErrMsgIdAndTxt ("MATLAB:maxlhs", "Too many output arguments") ;
    }
    if (nargin < 2)
    {
        mexErrMsgIdAndTxt ("MATLAB:minrhs", "Not enough input arguments") ;
    }
    if (nargin > 3)
    {
        mexErrMsgIdAndTxt ("MATLAB:maxrhs", "Too many input arguments") ;
    }

    if (!mxIsStruct (pargin [0]))
    {
        mexErrMsgIdAndTxt ("QR:invalidInput", "invalid Q (must be a struct)") ;
    }

    // -------------------------------------------------------------------------
    // get H, Tau, and P from the Q struct
    // -------------------------------------------------------------------------

    i = mxGetFieldNumber (pargin [0], "H") ;
    if (i < 0)
    {
        mexErrMsgIdAndTxt ("QR:invalidInput", "invalid Q struct") ;
    }
    Hmatlab = mxGetFieldByNumber (pargin [0], 0, i) ;
    nh = mxGetN (Hmatlab) ;
    if (!mxIsSparse (Hmatlab))
    {
        mexErrMsgIdAndTxt ("QR:invalidInput", "H must be sparse") ;
    }
    i = mxGetFieldNumber (pargin [0], "Tau") ;
    if (i < 0)
    {
        mexErrMsgIdAndTxt ("QR:invalidInput", "invalid Q struct") ;
    }
    Tau = mxGetFieldByNumber (pargin [0], 0, i) ;
    if (nh != mxGetNumberOfElements (Tau))
    {
        mexErrMsgIdAndTxt ("QR:invalidInput",
            "H and Tau must have the same number of columns") ;
    }

    is_complex = mxIsComplex (Tau) || mxIsComplex (Hmatlab) ||
        mxIsComplex (pargin [1]) ;

    // -------------------------------------------------------------------------
    // get the Householder vectors
    // -------------------------------------------------------------------------

    H = spqr_mx_get_sparse (Hmatlab, &Hmatrix, &dummy) ;
    mh = H->nrow ;
    Hx = spqr_mx_merge_if_complex (Hmatlab, is_complex, &hnz, cc) ;
    if (is_complex)
    {
        // H has been converted from real or zomplex to complex
        H->x = Hx ;
        H->z = NULL ;
        H->xtype = CHOLMOD_COMPLEX ;
    }

    // -------------------------------------------------------------------------
    // get Tau
    // -------------------------------------------------------------------------

    HTau = spqr_mx_get_dense (Tau, &HTau_matrix, &dummy) ;
    Tx = spqr_mx_merge_if_complex (Tau, is_complex, &tnz, cc) ;
    if (is_complex)
    {
        // HTau has been converted from real or zomplex to complex
        HTau->x = Tx ;
        HTau->z = NULL ;
        HTau->xtype = CHOLMOD_COMPLEX ;
    }

    // -------------------------------------------------------------------------
    // get method
    // -------------------------------------------------------------------------

    if (nargin < 3)
    {
        method = 0 ;
    }
    else
    {
        method = (Long) mxGetScalar (pargin [2]) ;
        if (method < 0 || method > 3)
        {
            mexErrMsgIdAndTxt ("QR:invalidInput", "invalid method") ;
        }
    }

    // -------------------------------------------------------------------------
    // get X
    // -------------------------------------------------------------------------

    m = mxGetM (pargin [1]) ;
    n = mxGetN (pargin [1]) ;
    X_is_sparse = mxIsSparse (pargin [1]) ;
    Xsparse = NULL ;
    if (X_is_sparse)
    {
        Xsparse = spqr_mx_get_sparse (pargin [1], &Xsmatrix, &dummy) ;
    }
    else
    {
        Xdense = spqr_mx_get_dense (pargin [1], &Xdmatrix, &dummy) ;
    }
    Xx = spqr_mx_merge_if_complex (pargin [1], is_complex, &xnz, cc) ;
    if (is_complex)
    {
        // X has been converted from real or zomplex to complex
        if (X_is_sparse)
        {
            Xsparse->x = Xx ;
            Xsparse->xtype = CHOLMOD_COMPLEX ;
        }
        else
        {
            Xdense->x = Xx ;
            Xdense->xtype = CHOLMOD_COMPLEX ;
        }
    }

    if (method == 0 || method == 1)
    {
        if (mh != m)
        {
            mexErrMsgIdAndTxt ("QR:invalidInput",
                "H and X must have same number of rows") ;
        }
    }
    else
    {
        if (mh != n)
        {
            mexErrMsgIdAndTxt ("QR:invalidInput",
                "# of cols of X must equal # of rows of H") ;
        }
    }

    // -------------------------------------------------------------------------
    // get P
    // -------------------------------------------------------------------------

    i = mxGetFieldNumber (pargin [0], "P") ;
    gotP = (i >= 0) ;
    HPinv = NULL ;

    if (gotP)
    {
        // get P from the H struct
        P = mxGetFieldByNumber (pargin [0], 0, i) ;
        if (mxGetNumberOfElements (P) != mh)
        {
            mexErrMsgIdAndTxt ("QR:invalidInput",
                "P must be a vector of length equal to # rows of H") ;
        }
        HPinv = (Long *) cholmod_l_malloc (mh, sizeof (Long), cc) ;
        Px = mxGetPr (P) ;
        for (i = 0 ; i < mh ; i++)
        {
            HPinv [i] = (Long) (Px [i] - 1) ;
            if (HPinv [i] < 0 || HPinv [i] >= mh)
            {
                mexErrMsgIdAndTxt ("QR:invalidInput", "invalid permutation") ;
            }
        }
    }

    // -------------------------------------------------------------------------
    // Y = Q'*X, Q*X, X*Q or X*Q'
    // -------------------------------------------------------------------------

    if (is_complex)
    {
        if (X_is_sparse)
        {
            Ysparse = SuiteSparseQR_qmult <Complex> (method, H,
                HTau, HPinv, Xsparse, cc) ;
            pargout [0] = spqr_mx_put_sparse (&Ysparse, cc) ;
        }
        else
        {
            Ydense = SuiteSparseQR_qmult <Complex> (method, H,
                HTau, HPinv, Xdense, cc) ;
            pargout [0] = spqr_mx_put_dense (&Ydense, cc) ;
        }
    }
    else
    {
        if (X_is_sparse)
        {
            Ysparse = SuiteSparseQR_qmult <double> (method, H,
                HTau, HPinv, Xsparse, cc) ;
            pargout [0] = spqr_mx_put_sparse (&Ysparse, cc) ;
        }
        else
        {
            Ydense = SuiteSparseQR_qmult <double> (method, H,
                HTau, HPinv, Xdense, cc) ;
            pargout [0] = spqr_mx_put_dense (&Ydense, cc) ;
        }
    }

    // -------------------------------------------------------------------------
    // free workspace
    // -------------------------------------------------------------------------

    cholmod_l_free (mh, sizeof (Long), HPinv, cc) ;

    if (is_complex)
    {
        // free the merged copies of the real parts of the H and Tau matrices
        cholmod_l_free (hnz, sizeof (Complex), Hx, cc) ;
        cholmod_l_free (tnz, sizeof (Complex), Tx, cc) ;
        cholmod_l_free (xnz, sizeof (Complex), Xx, cc) ;
    }
    cholmod_l_finish (cc) ;

#if 0
    // malloc count for testing only ...
    spqr_mx_get_usage (pargout [0], 1, &inuse, &count, cc) ;
    if (inuse != cc->memory_inuse || count != cc->malloc_count)
    {
        mexErrMsgIdAndTxt ("QR:internalError", "memory leak!") ;
    }
#endif
}