/**
  * C++ version of gsl_linalg_SV_solve().
  * @param U An orthogonal matrix
  * @param Q A matrix
  * @param S A vector
  * @param b A vector
  * @param x A vector
  * @return Error code on failure
  */
 inline int SV_solve( matrix const& U, matrix const& Q, vector const& S, vector const& b, vector& x ){
   return gsl_linalg_SV_solve( U.get(), Q.get(), S.get(), b.get(), x.get() ); } 

 /**
  * C++ version of gsl_linalg_LQ_decomp().
  * @param A A matrix
  * @param tau A vector
  * @return Error code on failure
  */
 inline int LQ_decomp( matrix& A, vector& tau ){
   return gsl_linalg_LQ_decomp( A.get(), tau.get() ); } 

    /**
     * C++ version of gsl_linalg_LQ_lssolve_T().
     * @param LQ A matrix
     * @param tau A vector
     * @param b A vector
     * @param x A vector
     * @param residual A residual vector
     * @return Error code on failure
     */
    inline int LQ_lssolve_T( matrix const& LQ, vector const& tau, vector const& b,
			     vector& x, vector& residual ){
      return gsl_linalg_LQ_lssolve_T( LQ.get(), tau.get(), b.get(), x.get(), residual.get() ); } 

    /**
     * C++ version of gsl_linalg_QRPT_QRsolve().
     * @param Q A matrix
     * @param R A matrix
     * @param p A permutation
     * @param b A vector
     * @param x A vector
     * @return Error code on failure
     */
    inline int QRPT_QRsolve( matrix const& Q, matrix const& R, permutation const& p,
			     vector const& b, vector& x ){
      return gsl_linalg_QRPT_QRsolve( Q.get(), R.get(), p.get(), b.get(), x.get() ); } 

 /**
  * C++ version of gsl_linalg_householder_hm().
  * @param tau A scalar
  * @param v A vector
  * @param A A matrix
  * @return Error code on failure
  */
 inline int householder_hm( double tau, vector const& v, matrix& A ){
   return gsl_linalg_householder_hm( tau, v.get(), A.get() ); } 

 /**
  * C++ version of gsl_linalg_R_svx().
  * @param R A matrix
  * @param x A vector
  * @return Error code on failure
  */
 inline int R_svx( matrix const& R, vector& x ){ return gsl_linalg_R_svx( R.get(), x.get() ); }

    /**
     * C++ version of gsl_linalg_QRPT_decomp2().
     * @param A A matrix
     * @param q A matrix
     * @param r A matrix
     * @param tau A vector
     * @param p A permutation
     * @param signum The sign of the permutation
     * @param norm A vector used for column pivoting
     * @return Error code on failure
     */
    inline int QRPT_decomp2( matrix const& A, matrix& q, matrix& r, vector& tau,
			     permutation& p, int* signum, vector& norm ){
      return gsl_linalg_QRPT_decomp2( A.get(), q.get(), r.get(), tau.get(), p.get(), signum, norm.get() ); } 

 /**
  * C++ version of gsl_linalg_LU_lndet().
  * @param LU An LU decomposition matrix
  * @return The logarithm of the absolute value of
  * the determinant of the matrix with LU decomposition @c LU
  */
 inline double LU_lndet( matrix& LU ){ return gsl_linalg_LU_lndet( LU.get() ); } 

 /**
  * C++ version of gsl_linalg_LU_sgndet().
  * @param lu An LU decomposition marix
  * @param signum The sign of the permutation
  * @return The sign of the determinant of the matrix with LU decomposition @c LU
  */
 inline int LU_sgndet( matrix& lu, int signum ){ return gsl_linalg_LU_sgndet( lu.get(), signum ); } 

 /**
  * C++ version of gsl_linalg_LU_invert().
  * @param LU An LU decomposition matrix
  * @param p A permutation
  * @param inverse The inverse matrix
  * @return Error code on failure
  */
 inline int LU_invert( matrix const& LU, permutation const& p, matrix& inverse ){
   return gsl_linalg_LU_invert( LU.get(), p.get(), inverse.get() ); } 

 /**
  * C++ version of gsl_linalg_LU_det().
  * @param LU An LU decomposition matrix
  * @param signum The sign of the permutation
  * @return The determinant of the matrix with LU decomposition @c LU
  */
 inline double LU_det( matrix& LU, int signum ){ return gsl_linalg_LU_det( LU.get(), signum ); } 

    /**
     * C++ version of gsl_linalg_LU_refine().
     * @param A A matrix
     * @param LU An LU decomposition matrix
     * @param p A permutation
     * @param b A vector
     * @param x A vector
     * @param residual A residual vector
     * @return Error code on failure
     */
    inline int LU_refine( matrix const& A, matrix const& LU, permutation const& p, vector const& b,
		   vector& x, vector& residual ){
      return gsl_linalg_LU_refine( A.get(), LU.get(), p.get(), b.get(), x.get(), residual.get() ); } 

 /**
  * C++ version of gsl_linalg_LU_svx().
  * @param LU An LU decomposition matrix
  * @param p A permutation
  * @param x A vector
  * @return Error code on failure
  */
 inline int LU_svx( matrix const& LU, permutation const& p, vector& x ){
   return gsl_linalg_LU_svx( LU.get(), p.get(), x.get() ); } 

 /**
  * C++ version of gsl_linalg_LU_decomp().
  * @param A A matrix
  * @param p A permutation
  * @param signum The sign of the permutation
  * @return Error code on failure
  */
 inline int LU_decomp( matrix& A, permutation& p, int* signum ){
   return gsl_linalg_LU_decomp( A.get(), p.get(), signum ); } 

 /**
  * C++ version of gsl_linalg_QR_unpack().
  * @param QR A QR decomposition matrix
  * @param tau A vector
  * @param Q A matrix
  * @param R A matrix
  * @return Error code on failure
  */
 inline int QR_unpack( matrix const& QR, vector const& tau, matrix& Q, matrix& R ){
   return gsl_linalg_QR_unpack( QR.get(), tau.get(), Q.get(), R.get() ); } 

    /**
     * C++ version of gsl_linalg_QR_lssolve().
     * @param QR A QR decomposition
     * @param tau A vector
     * @param b A vector
     * @param x A vector
     * @param residual A residual vector
     * @return Error code on failure
     */
    inline int QR_lssolve( matrix const& QR, vector const& tau, vector const& b, vector& x,
			   vector& residual ){
      return gsl_linalg_QR_lssolve( QR.get(), tau.get(), b.get(), x.get(), residual.get() ); } 

 /**
  * C++ version of gsl_linalg_R_solve().
  * @param R A matrix
  * @param b A vector
  * @param x A vector
  * @return Error code on failure
  */
 inline int R_solve( matrix const& R, vector const& b, vector& x ){
   return gsl_linalg_R_solve( R.get(), b.get(), x.get() ); } 

 /**
  * C++ version of gsl_linalg_QR_QRsolve().
  * @param Q A Matrix
  * @param R A Matrix
  * @param b A vector
  * @param x A vector
  * @return Error code on failure
  */
 inline int QR_QRsolve( matrix& Q, matrix& R, vector const& b, vector& x ){
   return gsl_linalg_QR_QRsolve( Q.get(), R.get(), b.get(), x.get() ); } 

 /**
  * C++ version of gsl_linalg_QRPT_decomp().
  * @param A A matrix
  * @param tau A vector
  * @param p A permutation
  * @param signum The sign of the permutation
  * @param norm A vector used for column pivoting
  * @return Error code on failure
  */
 inline int QRPT_decomp( matrix& A, vector& tau, permutation& p, int* signum, vector& norm ){
   return gsl_linalg_QRPT_decomp( A.get(), tau.get(), p.get(), signum, norm.get() ); } 

 /**
  * C++ version of gsl_linalg_QR_Rsolve().
  * @param QR A QR decomposition matrix
  * @param b A vector
  * @param x A vector
  * @return Error code on failure
  */
 inline int QR_Rsolve( matrix const& QR, vector const& b, vector& x ){
   return gsl_linalg_QR_Rsolve( QR.get(), b.get(), x.get() ); }