Fix lu, rank and qr handling of empty arrays and check for nullptr

Author: umar456

src/api/c/lu.cpp

@@ -49,6 +49,9 @@ af_err af_lu(af_array *lower, af_array *upper, af_array *pivot,
 
         af_dtype type = i_info.getType();
 
+        ARG_ASSERT(0, lower != nullptr);
+        ARG_ASSERT(1, upper != nullptr);
+        ARG_ASSERT(2, pivot != nullptr);
         ARG_ASSERT(3, i_info.isFloating());  // Only floating and complex types
 
         if (i_info.ndims() == 0) {
@@ -81,21 +84,21 @@ af_err af_lu_inplace(af_array *pivot, af_array in, const bool is_lapack_piv) {
         }
 
         ARG_ASSERT(1, i_info.isFloating());  // Only floating and complex types
+        ARG_ASSERT(0, pivot != nullptr);
 
         if (i_info.ndims() == 0) {
             return af_create_handle(pivot, 0, nullptr, type);
         }
 
         af_array out;
-
         switch (type) {
             case f32: out = lu_inplace<float>(in, is_lapack_piv); break;
             case f64: out = lu_inplace<double>(in, is_lapack_piv); break;
             case c32: out = lu_inplace<cfloat>(in, is_lapack_piv); break;
             case c64: out = lu_inplace<cdouble>(in, is_lapack_piv); break;
             default: TYPE_ERROR(1, type);
         }
-        if (pivot != NULL) std::swap(*pivot, out);
+        std::swap(*pivot, out);
     }
     CATCHALL;
 

src/api/c/qr.cpp

@@ -55,6 +55,9 @@ af_err af_qr(af_array *q, af_array *r, af_array *tau, const af_array in) {
             return AF_SUCCESS;
         }
 
+        ARG_ASSERT(0, q != nullptr);
+        ARG_ASSERT(1, r != nullptr);
+        ARG_ASSERT(2, tau != nullptr);
         ARG_ASSERT(3, i_info.isFloating());  // Only floating and complex types
 
         switch (type) {
@@ -81,21 +84,21 @@ af_err af_qr_inplace(af_array *tau, af_array in) {
         af_dtype type = i_info.getType();
 
         ARG_ASSERT(1, i_info.isFloating());  // Only floating and complex types
+        ARG_ASSERT(0, tau != nullptr);
 
         if (i_info.ndims() == 0) {
             return af_create_handle(tau, 0, nullptr, type);
         }
 
         af_array out;
-
         switch (type) {
             case f32: out = qr_inplace<float>(in); break;
             case f64: out = qr_inplace<double>(in); break;
             case c32: out = qr_inplace<cfloat>(in); break;
             case c64: out = qr_inplace<cdouble>(in); break;
             default: TYPE_ERROR(1, type);
         }
-        if (tau != NULL) std::swap(*tau, out);
+        std::swap(*tau, out);
     }
     CATCHALL;
 

src/api/c/rank.cpp

@@ -56,19 +56,17 @@ af_err af_rank(uint* out, const af_array in, const double tol) {
         af_dtype type = i_info.getType();
 
         ARG_ASSERT(1, i_info.isFloating());  // Only floating and complex types
+        ARG_ASSERT(0, out != nullptr);
 
-        uint output;
-        if (i_info.ndims() == 0) {
-            output = 0;
-            return AF_SUCCESS;
-        }
-
-        switch (type) {
-            case f32: output = rank<float>(in, tol); break;
-            case f64: output = rank<double>(in, tol); break;
-            case c32: output = rank<cfloat>(in, tol); break;
-            case c64: output = rank<cdouble>(in, tol); break;
-            default: TYPE_ERROR(1, type);
+        uint output = 0;
+        if (i_info.ndims() != 0) {
+            switch (type) {
+                case f32: output = rank<float>(in, tol); break;
+                case f64: output = rank<double>(in, tol); break;
+                case c32: output = rank<cfloat>(in, tol); break;
+                case c64: output = rank<cdouble>(in, tol); break;
+                default: TYPE_ERROR(1, type);
+            }
         }
         std::swap(*out, output);
     }

test/lu_dense.cpp

@@ -235,3 +235,46 @@ TYPED_TEST(LU, RectangularLarge1) {
 TYPED_TEST(LU, RectangularMultipleOfTwoLarge1) {
     luTester<TypeParam>(512, 1024, eps<TypeParam>());
 }
+
+TEST(LU, NullLowerOutput) {
+    if (noLAPACKTests()) return;
+    dim4 dims(3, 3);
+    af_array in = 0;
+    ASSERT_SUCCESS(af_randu(&in, dims.ndims(), dims.get(), f32));
+
+    af_array upper, pivot;
+    ASSERT_EQ(AF_ERR_ARG, af_lu(NULL, &upper, &pivot, in));
+    ASSERT_SUCCESS(af_release_array(in));
+}
+
+TEST(LU, NullUpperOutput) {
+    if (noLAPACKTests()) return;
+    dim4 dims(3, 3);
+    af_array in = 0;
+    ASSERT_SUCCESS(af_randu(&in, dims.ndims(), dims.get(), f32));
+
+    af_array lower, pivot;
+    ASSERT_EQ(AF_ERR_ARG, af_lu(&lower, NULL, &pivot, in));
+    ASSERT_SUCCESS(af_release_array(in));
+}
+
+TEST(LU, NullPivotOutput) {
+    if (noLAPACKTests()) return;
+    dim4 dims(3, 3);
+    af_array in = 0;
+    ASSERT_SUCCESS(af_randu(&in, dims.ndims(), dims.get(), f32));
+
+    af_array lower, upper;
+    ASSERT_EQ(AF_ERR_ARG, af_lu(&lower, &upper, NULL, in));
+    ASSERT_SUCCESS(af_release_array(in));
+}
+
+TEST(LU, InPlaceNullOutput) {
+    if (noLAPACKTests()) return;
+    dim4 dims(3, 3);
+    af_array in = 0;
+    ASSERT_SUCCESS(af_randu(&in, dims.ndims(), dims.get(), f32));
+
+    ASSERT_EQ(AF_ERR_ARG, af_lu_inplace(NULL, in, true));
+    ASSERT_SUCCESS(af_release_array(in));
+}

test/qr_dense.cpp

@@ -179,3 +179,13 @@ TYPED_TEST(QR, RectangularLarge1) {
 TYPED_TEST(QR, RectangularMultipleOfTwoLarge1) {
     qrTester<TypeParam>(512, 1024, eps<TypeParam>());
 }
+
+TEST(QR, InPlaceNullOutput) {
+    if (noLAPACKTests()) return;
+    dim4 dims(3, 3);
+    af_array in = 0;
+    ASSERT_SUCCESS(af_randu(&in, dims.ndims(), dims.get(), f32));
+
+    ASSERT_EQ(AF_ERR_ARG, af_qr_inplace(NULL, in));
+    ASSERT_SUCCESS(af_release_array(in));
+}

test/rank_dense.cpp

@@ -112,3 +112,13 @@ void detTest() {
 }
 
 TYPED_TEST(Det, Small) { detTest<TypeParam>(); }
+
+TEST(Rank, NullOutput) {
+    if (noLAPACKTests()) return;
+    dim4 dims(3, 3);
+    af_array in = 0;
+    af_randu(&in, dims.ndims(), dims.get(), f32);
+
+    ASSERT_EQ(AF_ERR_ARG, af_rank(NULL, in, 1e-6));
+    ASSERT_SUCCESS(af_release_array(in));
+}