nmatrix-lapacke 0.2.1 → 0.2.3

data/ext/nmatrix_lapacke/lapacke/src/lapacke_zunmqr.c

@@ -0,0 +1,88 @@
+/*****************************************************************************
+  Copyright (c) 2014, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************
+* Contents: Native high-level C interface to LAPACK function zunmqr
+* Author: Intel Corporation
+* Generated November 2015
+*****************************************************************************/
+
+#include "lapacke_utils.h"
+
+lapack_int LAPACKE_zunmqr( int matrix_layout, char side, char trans,
+                           lapack_int m, lapack_int n, lapack_int k,
+                           const lapack_complex_double* a, lapack_int lda,
+                           const lapack_complex_double* tau,
+                           lapack_complex_double* c, lapack_int ldc )
+{
+    lapack_int info = 0;
+    lapack_int lwork = -1;
+    lapack_complex_double* work = NULL;
+    lapack_complex_double work_query;
+    lapack_int r;
+    if( matrix_layout != LAPACK_COL_MAJOR && matrix_layout != LAPACK_ROW_MAJOR ) {
+        LAPACKE_xerbla( "LAPACKE_zunmqr", -1 );
+        return -1;
+    }
+#ifndef LAPACK_DISABLE_NAN_CHECK
+    /* Optionally check input matrices for NaNs */
+    r = LAPACKE_lsame( side, 'l' ) ? m : n;
+    if( LAPACKE_zge_nancheck( matrix_layout, r, k, a, lda ) ) {
+        return -7;
+    }
+    if( LAPACKE_zge_nancheck( matrix_layout, m, n, c, ldc ) ) {
+        return -10;
+    }
+    if( LAPACKE_z_nancheck( k, tau, 1 ) ) {
+        return -9;
+    }
+#endif
+    /* Query optimal working array(s) size */
+    info = LAPACKE_zunmqr_work( matrix_layout, side, trans, m, n, k, a, lda, tau,
+                                c, ldc, &work_query, lwork );
+    if( info != 0 ) {
+        goto exit_level_0;
+    }
+    lwork = LAPACK_Z2INT( work_query );
+    /* Allocate memory for work arrays */
+    work = (lapack_complex_double*)
+        LAPACKE_malloc( sizeof(lapack_complex_double) * lwork );
+    if( work == NULL ) {
+        info = LAPACK_WORK_MEMORY_ERROR;
+        goto exit_level_0;
+    }
+    /* Call middle-level interface */
+    info = LAPACKE_zunmqr_work( matrix_layout, side, trans, m, n, k, a, lda, tau,
+                                c, ldc, work, lwork );
+    /* Release memory and exit */
+    LAPACKE_free( work );
+exit_level_0:
+    if( info == LAPACK_WORK_MEMORY_ERROR ) {
+        LAPACKE_xerbla( "LAPACKE_zunmqr", info );
+    }
+    return info;
+}

data/ext/nmatrix_lapacke/lapacke/src/lapacke_zunmqr_work.c

@@ -0,0 +1,111 @@
+/*****************************************************************************
+  Copyright (c) 2014, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+*****************************************************************************
+* Contents: Native middle-level C interface to LAPACK function zunmqr
+* Author: Intel Corporation
+* Generated November 2015
+*****************************************************************************/
+
+#include "lapacke_utils.h"
+
+lapack_int LAPACKE_zunmqr_work( int matrix_layout, char side, char trans,
+                                lapack_int m, lapack_int n, lapack_int k,
+                                const lapack_complex_double* a, lapack_int lda,
+                                const lapack_complex_double* tau,
+                                lapack_complex_double* c, lapack_int ldc,
+                                lapack_complex_double* work, lapack_int lwork )
+{
+    lapack_int info = 0;
+    if( matrix_layout == LAPACK_COL_MAJOR ) {
+        /* Call LAPACK function and adjust info */
+        LAPACK_zunmqr( &side, &trans, &m, &n, &k, a, &lda, tau, c, &ldc, work,
+                       &lwork, &info );
+        if( info < 0 ) {
+            info = info - 1;
+        }
+    } else if( matrix_layout == LAPACK_ROW_MAJOR ) {
+        lapack_int r = LAPACKE_lsame( side, 'l' ) ? m : n;
+        lapack_int lda_t = MAX(1,r);
+        lapack_int ldc_t = MAX(1,m);
+        lapack_complex_double* a_t = NULL;
+        lapack_complex_double* c_t = NULL;
+        /* Check leading dimension(s) */
+        if( lda < k ) {
+            info = -8;
+            LAPACKE_xerbla( "LAPACKE_zunmqr_work", info );
+            return info;
+        }
+        if( ldc < n ) {
+            info = -11;
+            LAPACKE_xerbla( "LAPACKE_zunmqr_work", info );
+            return info;
+        }
+        /* Query optimal working array(s) size if requested */
+        if( lwork == -1 ) {
+            LAPACK_zunmqr( &side, &trans, &m, &n, &k, a, &lda_t, tau, c, &ldc_t,
+                           work, &lwork, &info );
+            return (info < 0) ? (info - 1) : info;
+        }
+        /* Allocate memory for temporary array(s) */
+        a_t = (lapack_complex_double*)
+            LAPACKE_malloc( sizeof(lapack_complex_double) * lda_t * MAX(1,k) );
+        if( a_t == NULL ) {
+            info = LAPACK_TRANSPOSE_MEMORY_ERROR;
+            goto exit_level_0;
+        }
+        c_t = (lapack_complex_double*)
+            LAPACKE_malloc( sizeof(lapack_complex_double) * ldc_t * MAX(1,n) );
+        if( c_t == NULL ) {
+            info = LAPACK_TRANSPOSE_MEMORY_ERROR;
+            goto exit_level_1;
+        }
+        /* Transpose input matrices */
+        LAPACKE_zge_trans( matrix_layout, r, k, a, lda, a_t, lda_t );
+        LAPACKE_zge_trans( matrix_layout, m, n, c, ldc, c_t, ldc_t );
+        /* Call LAPACK function and adjust info */
+        LAPACK_zunmqr( &side, &trans, &m, &n, &k, a_t, &lda_t, tau, c_t, &ldc_t,
+                       work, &lwork, &info );
+        if( info < 0 ) {
+            info = info - 1;
+        }
+        /* Transpose output matrices */
+        LAPACKE_zge_trans( LAPACK_COL_MAJOR, m, n, c_t, ldc_t, c, ldc );
+        /* Release memory and exit */
+        LAPACKE_free( c_t );
+exit_level_1:
+        LAPACKE_free( a_t );
+exit_level_0:
+        if( info == LAPACK_TRANSPOSE_MEMORY_ERROR ) {
+            LAPACKE_xerbla( "LAPACKE_zunmqr_work", info );
+        }
+    } else {
+        info = -1;
+        LAPACKE_xerbla( "LAPACKE_zunmqr_work", info );
+    }
+    return info;
+}

data/ext/nmatrix_lapacke/lapacke/utils/lapacke_c_nancheck.c

@@ -0,0 +1,51 @@
+/*****************************************************************************
+  Copyright (c) 2010, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+******************************************************************************
+* Contents: Native C interface to LAPACK utility function
+* Author: Intel Corporation
+* Created in February, 2010
+*****************************************************************************/
+#include "lapacke_utils.h"
+
+/* Check a vector for NaN entries. */
+
+lapack_logical LAPACKE_c_nancheck( lapack_int n,
+                                    const lapack_complex_float *x,
+                                    lapack_int incx )
+{
+    lapack_int i, inc;
+
+    if( incx == 0 ) return (lapack_logical) LAPACK_CISNAN( x[0] );
+    inc = ( incx > 0 ) ? incx : -incx ;
+
+    for( i = 0; i < n*inc; i+=inc ) {
+        if( LAPACK_CISNAN( x[i] ) )
+            return (lapack_logical) 1;
+    }
+    return (lapack_logical) 0;
+}

data/ext/nmatrix_lapacke/lapacke/utils/lapacke_d_nancheck.c

@@ -0,0 +1,51 @@
+/*****************************************************************************
+  Copyright (c) 2010, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+******************************************************************************
+* Contents: Native C interface to LAPACK utility function
+* Author: Intel Corporation
+* Created in February, 2010
+*****************************************************************************/
+#include "lapacke_utils.h"
+
+/* Check a vector for NaN entries. */
+
+lapack_logical LAPACKE_d_nancheck( lapack_int n,
+                                    const double *x,
+                                    lapack_int incx )
+{
+    lapack_int i, inc;
+
+    if( incx == 0 ) return (lapack_logical) LAPACK_DISNAN( x[0] );
+    inc = ( incx > 0 ) ? incx : -incx ;
+
+    for( i = 0; i < n*inc; i+=inc ) {
+        if( LAPACK_DISNAN( x[i] ) )
+            return (lapack_logical) 1;
+    }
+    return (lapack_logical) 0;
+}

data/ext/nmatrix_lapacke/lapacke/utils/lapacke_s_nancheck.c

@@ -0,0 +1,51 @@
+/*****************************************************************************
+  Copyright (c) 2010, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+******************************************************************************
+* Contents: Native C interface to LAPACK utility function
+* Author: Intel Corporation
+* Created in February, 2010
+*****************************************************************************/
+#include "lapacke_utils.h"
+
+/* Check a vector for NaN entries. */
+
+lapack_logical LAPACKE_s_nancheck( lapack_int n,
+                                    const float *x,
+                                    lapack_int incx )
+{
+    lapack_int i, inc;
+
+    if( incx == 0 ) return (lapack_logical) LAPACK_SISNAN( x[0] );
+    inc = ( incx > 0 ) ? incx : -incx ;
+
+    for( i = 0; i < n*inc; i+=inc ) {
+        if( LAPACK_SISNAN( x[i] ) )
+            return (lapack_logical) 1;
+    }
+    return (lapack_logical) 0;
+}

data/ext/nmatrix_lapacke/lapacke/utils/lapacke_z_nancheck.c

@@ -0,0 +1,51 @@
+/*****************************************************************************
+  Copyright (c) 2010, Intel Corp.
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without
+  modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of Intel Corporation nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+  THE POSSIBILITY OF SUCH DAMAGE.
+******************************************************************************
+* Contents: Native C interface to LAPACK utility function
+* Author: Intel Corporation
+* Created in February, 2010
+*****************************************************************************/
+#include "lapacke_utils.h"
+
+/* Check a vector for NaN entries. */
+
+lapack_logical LAPACKE_z_nancheck( lapack_int n,
+                                    const lapack_complex_double *x,
+                                    lapack_int incx )
+{
+    lapack_int i, inc;
+
+    if( incx == 0 ) return (lapack_logical) LAPACK_ZISNAN( x[0] );
+    inc = ( incx > 0 ) ? incx : -incx ;
+
+    for( i = 0; i < n*inc; i+=inc ) {
+        if( LAPACK_ZISNAN( x[i] ) )
+            return (lapack_logical) 1;
+    }
+    return (lapack_logical) 0;
+}

data/ext/nmatrix_lapacke/math_lapacke.cpp

@@ -77,6 +77,11 @@ extern "C" {
   static VALUE nm_lapacke_lapacke_potrs(VALUE self, VALUE order, VALUE uplo, VALUE n, VALUE nrhs, VALUE a, VALUE lda, VALUE b, VALUE ldb);
   static VALUE nm_lapacke_lapacke_potri(VALUE self, VALUE order, VALUE uplo, VALUE n, VALUE a, VALUE lda);
 
+  static VALUE nm_lapacke_lapacke_geqrf(VALUE self, VALUE order, VALUE m, VALUE n, VALUE a, VALUE lda, VALUE tau);
+  static VALUE nm_lapacke_lapacke_ormqr(VALUE self, VALUE order, VALUE side, VALUE trans, VALUE m, VALUE n, VALUE k, VALUE a, VALUE lda, VALUE tau, VALUE c, VALUE ldc);
+  static VALUE nm_lapacke_lapacke_unmqr(VALUE self, VALUE order, VALUE side, VALUE trans, VALUE m, VALUE n, VALUE k, VALUE a, VALUE lda, VALUE tau, VALUE c, VALUE ldc);
+
+
   static VALUE nm_lapacke_lapacke_gesvd(VALUE self, VALUE order, VALUE jobu, VALUE jobvt, VALUE m, VALUE n, VALUE a, VALUE lda, VALUE s, VALUE u, VALUE ldu, VALUE vt, VALUE ldvt, VALUE superb);
   static VALUE nm_lapacke_lapacke_gesdd(VALUE self, VALUE order, VALUE jobz, VALUE m, VALUE n, VALUE a, VALUE lda, VALUE s, VALUE u, VALUE ldu, VALUE vt, VALUE ldvt);
   static VALUE nm_lapacke_lapacke_geev(VALUE self, VALUE order, VALUE jobvl, VALUE jobvr, VALUE n, VALUE a, VALUE lda, VALUE w, VALUE wi, VALUE vl, VALUE ldvl, VALUE vr, VALUE ldvr);
@@ -121,6 +126,10 @@ void nm_math_init_lapack() {
   rb_define_singleton_method(cNMatrix_LAPACKE_LAPACK, "lapacke_potrs", (METHOD)nm_lapacke_lapacke_potrs, 8);
   rb_define_singleton_method(cNMatrix_LAPACKE_LAPACK, "lapacke_potri", (METHOD)nm_lapacke_lapacke_potri, 5);
 
+  rb_define_singleton_method(cNMatrix_LAPACKE_LAPACK, "lapacke_geqrf", (METHOD)nm_lapacke_lapacke_geqrf, 6);
+  rb_define_singleton_method(cNMatrix_LAPACKE_LAPACK, "lapacke_ormqr", (METHOD)nm_lapacke_lapacke_ormqr, 11);
+  rb_define_singleton_method(cNMatrix_LAPACKE_LAPACK, "lapacke_unmqr", (METHOD)nm_lapacke_lapacke_unmqr, 11);
+
   rb_define_singleton_method(cNMatrix_LAPACKE_LAPACK, "lapacke_gesvd", (METHOD)nm_lapacke_lapacke_gesvd, 13);
   rb_define_singleton_method(cNMatrix_LAPACKE_LAPACK, "lapacke_gesdd", (METHOD)nm_lapacke_lapacke_gesdd, 11);
   rb_define_singleton_method(cNMatrix_LAPACKE_LAPACK, "lapacke_geev", (METHOD)nm_lapacke_lapacke_geev, 12);
@@ -311,11 +320,11 @@ static VALUE nm_lapacke_cblas_nrm2(VALUE self, VALUE n, VALUE x, VALUE incx) {
 
   static void (*ttable[nm::NUM_DTYPES])(const int N, const void* X, const int incX, void* sum) = {
       NULL, NULL, NULL, NULL, NULL, // no help for integers
-      nm::math::lapacke::cblas_nrm2<float32_t,float32_t>,
-      nm::math::lapacke::cblas_nrm2<float64_t,float64_t>,
-      nm::math::lapacke::cblas_nrm2<float32_t,nm::Complex64>,
-      nm::math::lapacke::cblas_nrm2<float64_t,nm::Complex128>,
-      nm::math::lapacke::cblas_nrm2<nm::RubyObject,nm::RubyObject>
+      nm::math::lapacke::cblas_nrm2<float32_t>,
+      nm::math::lapacke::cblas_nrm2<float64_t>,
+      nm::math::lapacke::cblas_nrm2<nm::Complex64>,
+      nm::math::lapacke::cblas_nrm2<nm::Complex128>,
+      nm::math::lapacke::cblas_nrm2<nm::RubyObject>
   };
 
   nm::dtype_t dtype  = NM_DTYPE(x);
@@ -360,16 +369,16 @@ static VALUE nm_lapacke_cblas_nrm2(VALUE self, VALUE n, VALUE x, VALUE incx) {
 static VALUE nm_lapacke_cblas_asum(VALUE self, VALUE n, VALUE x, VALUE incx) {
 
   static void (*ttable[nm::NUM_DTYPES])(const int N, const void* X, const int incX, void* sum) = {
-      nm::math::lapacke::cblas_asum<uint8_t,uint8_t>,
-      nm::math::lapacke::cblas_asum<int8_t,int8_t>,
-      nm::math::lapacke::cblas_asum<int16_t,int16_t>,
-      nm::math::lapacke::cblas_asum<int32_t,int32_t>,
-      nm::math::lapacke::cblas_asum<int64_t,int64_t>,
-      nm::math::lapacke::cblas_asum<float32_t,float32_t>,
-      nm::math::lapacke::cblas_asum<float64_t,float64_t>,
-      nm::math::lapacke::cblas_asum<float32_t,nm::Complex64>,
-      nm::math::lapacke::cblas_asum<float64_t,nm::Complex128>,
-      nm::math::lapacke::cblas_asum<nm::RubyObject,nm::RubyObject>
+      nm::math::lapacke::cblas_asum<uint8_t>,
+      nm::math::lapacke::cblas_asum<int8_t>,
+      nm::math::lapacke::cblas_asum<int16_t>,
+      nm::math::lapacke::cblas_asum<int32_t>,
+      nm::math::lapacke::cblas_asum<int64_t>,
+      nm::math::lapacke::cblas_asum<float32_t>,
+      nm::math::lapacke::cblas_asum<float64_t>,
+      nm::math::lapacke::cblas_asum<nm::Complex64>,
+      nm::math::lapacke::cblas_asum<nm::Complex128>,
+      nm::math::lapacke::cblas_asum<nm::RubyObject>
   };
 
   nm::dtype_t dtype  = NM_DTYPE(x);
@@ -647,7 +656,7 @@ static VALUE nm_lapacke_lapacke_getri(VALUE self, VALUE order, VALUE n, VALUE a,
 
   // Allocate the C version of the pivot index array
   int* ipiv_;
-  if (TYPE(ipiv) != T_ARRAY) {
+  if (!RB_TYPE_P(ipiv, T_ARRAY)) {
     rb_raise(rb_eArgError, "ipiv must be of type Array");
   } else {
     ipiv_ = NM_ALLOCA_N(int, RARRAY_LEN(ipiv));
@@ -739,7 +748,7 @@ static VALUE nm_lapacke_lapacke_getrs(VALUE self, VALUE order, VALUE trans, VALU
 
   // Allocate the C version of the pivot index array
   int* ipiv_;
-  if (TYPE(ipiv) != T_ARRAY) {
+  if (!RB_TYPE_P(ipiv, T_ARRAY)) {
     rb_raise(rb_eArgError, "ipiv must be of type Array");
   } else {
     ipiv_ = NM_ALLOCA_N(int, RARRAY_LEN(ipiv));
@@ -963,5 +972,128 @@ static VALUE nm_lapacke_lapacke_geev(VALUE self, VALUE order, VALUE jobvl, VALUE
   }
 }
 
+/* 
+ * GEQRF calculates the QR factorization for an MxN real or complex matrix.
+ *  
+ * The QR factorization is A = QR, where Q is orthogonal and R is Upper Triangular
+ * +A+ is overwritten with the elements of R and Q with Q being represented by the 
+ * elements below A's diagonal and an array of scalar factors in the output NMatrix. 
+ *
+ * The matrix Q is represented as a product of elementary reflectors
+ *     Q = H(1) H(2) . . . H(k), where k = min(m,n).
+ *
+ * Each H(i) has the form
+ *
+ *     H(i) = I - tau * v * v'
+ *
+ * http://www.netlib.org/lapack/explore-html/d3/d69/dgeqrf_8f.html
+ */
+
+static VALUE nm_lapacke_lapacke_geqrf(VALUE self, VALUE order, VALUE m, VALUE n, VALUE a, VALUE lda, VALUE tau) {
+  static int (*ttable[nm::NUM_DTYPES])(const enum CBLAS_ORDER order, const int m, const int n, void* a, const int lda, void* tau) = {
+      NULL, NULL, NULL, NULL, NULL,
+      nm::math::lapacke::lapacke_geqrf<float>,
+      nm::math::lapacke::lapacke_geqrf<double>,
+      nm::math::lapacke::lapacke_geqrf<nm::Complex64>,
+      nm::math::lapacke::lapacke_geqrf<nm::Complex128>,
+      NULL
+  };
+
+  int M = FIX2INT(m),
+      N = FIX2INT(n);
+ 
+  nm::dtype_t dtype = NM_DTYPE(a);
+
+  if (!ttable[dtype]) {
+    rb_raise(nm_eDataTypeError, "this matrix operation is undefined for integer matrices");
+    return Qfalse;
+  } else {
+    int info = ttable[dtype](blas_order_sym(order), M, N, NM_STORAGE_DENSE(a)->elements, FIX2INT(lda), NM_STORAGE_DENSE(tau)->elements);
+    return INT2FIX(info);
+  }
+}
+
+/* ORMQR calculates the orthogonal matrix Q from TAU and A after calling GEQRF on a real matrix
+ *  
+ *
+ * The matrix Q is represented as a product of elementary reflectors
+ *     Q = H(1) H(2) . . . H(k), where k = min(m,n).
+ *
+ * Each H(i) has the form
+ *
+ *     H(i) = I - tau * v * v'
+ *  
+ *  v is contained in the matrix passed to GEQRF     
+ *
+ *  www.netlib.org/lapack/explore-html/da/d82/dormqr_8f.html
+ */
+
+static VALUE nm_lapacke_lapacke_ormqr(VALUE self, VALUE order, VALUE side, VALUE trans, VALUE m, VALUE n, VALUE k, VALUE a, VALUE lda, VALUE tau, VALUE c, VALUE ldc) {
+  static int (*ttable[nm::NUM_DTYPES])(const enum CBLAS_ORDER order, char side, char trans, const int m, const int n, const int k, void* a, const int lda, void* tau, void* c, const int ldc) = {
+      NULL, NULL, NULL, NULL, NULL,
+      nm::math::lapacke::lapacke_ormqr<float>,
+      nm::math::lapacke::lapacke_ormqr<double>,
+      NULL,NULL,NULL // no complex or Ruby objects
+  };
+
+  int M = FIX2INT(m),
+      N = FIX2INT(n),
+      K = FIX2INT(k); 
+
+  char SIDE  = lapacke_side_sym(side),
+       TRANS = lapacke_transpose_sym(trans);
+
+  nm::dtype_t dtype = NM_DTYPE(a);
+
+
+  if (!ttable[dtype]) {
+    rb_raise(nm_eDataTypeError, "this matrix operation is undefined for integer matrices");
+    return Qfalse;
+  } else {
+    int info = ttable[dtype](blas_order_sym(order), SIDE, TRANS, M, N, K, NM_STORAGE_DENSE(a)->elements, FIX2INT(lda), NM_STORAGE_DENSE(tau)->elements, NM_STORAGE_DENSE(c)->elements, FIX2INT(ldc));
+    return INT2FIX(info);
+  }
+}
+
+/* UNMQR calculates the orthogonal matrix Q from TAU and A after calling GEQRF on a complex matrix.
+ *  
+ *
+ * The matrix Q is represented as a product of elementary reflectors
+ *     Q = H(1) H(2) . . . H(k), where k = min(m,n).
+ *
+ * Each H(i) has the form
+ *
+ *     H(i) = I - tau * v * v'
+ *  
+ *  v is contained in the matrix passed to GEQRF     
+ *
+ *  http://www.netlib.org/lapack/explore-html/d5/d65/zunmqr_8f.html
+ */
+
+static VALUE nm_lapacke_lapacke_unmqr(VALUE self, VALUE order, VALUE side, VALUE trans, VALUE m, VALUE n, VALUE k, VALUE a, VALUE lda, VALUE tau, VALUE c, VALUE ldc) {
+  static int (*ttable[nm::NUM_DTYPES])(const enum CBLAS_ORDER order, char side, char trans, const int m, const int n, const int k, void* a, const int lda, void* tau, void* c, const int ldc) = {
+      NULL, NULL, NULL, NULL, NULL,NULL,NULL, // no non-complex ops
+      nm::math::lapacke::lapacke_unmqr<nm::Complex64>,
+      nm::math::lapacke::lapacke_unmqr<nm::Complex128>,
+      NULL // no Ruby objects
+  };
+
+  int M = FIX2INT(m),
+      N = FIX2INT(n),
+      K = FIX2INT(k); 
+
+  char SIDE  = lapacke_side_sym(side),
+       TRANS = lapacke_transpose_sym(trans);
+
+  nm::dtype_t dtype = NM_DTYPE(a);
+
+  if (!ttable[dtype]) {
+    rb_raise(nm_eDataTypeError, "this matrix operation is valid only for complex datatypes");
+    return Qfalse;
+  } else {
+    int info = ttable[dtype](blas_order_sym(order), SIDE, TRANS, M, N, K, NM_STORAGE_DENSE(a)->elements, FIX2INT(lda), NM_STORAGE_DENSE(tau)->elements, NM_STORAGE_DENSE(c)->elements, FIX2INT(ldc));
+    return INT2FIX(info);
+  }
+}
 
 }