testing_dgels.c File Reference

#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <math.h>
#include <plasma.h>
#include <cblas.h>
#include <lapacke.h>
#include <core_blas.h>
#include "testing_dmain.h"

Include dependency graph for testing_dgels.c:

Go to the source code of this file.

Macros
#define	REAL

Enumerations
enum	blas_order_type {   blas_rowmajor = 101, blas_colmajor = 102, blas_rowmajor = 101, blas_colmajor = 102,   blas_rowmajor = 101, blas_colmajor = 102, blas_rowmajor = 101, blas_colmajor = 102,   blas_rowmajor = 101, blas_colmajor = 102, blas_rowmajor = 101, blas_colmajor = 102,   blas_rowmajor = 101, blas_colmajor = 102, blas_rowmajor = 101, blas_colmajor = 102,   blas_rowmajor = 101, blas_colmajor = 102, blas_rowmajor = 101, blas_colmajor = 102,   blas_rowmajor = 101, blas_colmajor = 102, blas_rowmajor = 101, blas_colmajor = 102,   blas_rowmajor = 101, blas_colmajor = 102, blas_rowmajor = 101, blas_colmajor = 102,   blas_rowmajor = 101, blas_colmajor = 102, blas_rowmajor = 101, blas_colmajor = 102,   blas_rowmajor = 101, blas_colmajor = 102 }
enum	blas_uplo_type {   blas_upper = 121, blas_lower = 122, blas_upper = 121, blas_lower = 122,   blas_upper = 121, blas_lower = 122, blas_upper = 121, blas_lower = 122 }
enum	blas_cmach_type {   blas_base = 151, blas_t = 152, blas_rnd = 153, blas_ieee = 154,   blas_emin = 155, blas_emax = 156, blas_eps = 157, blas_prec = 158,   blas_underflow = 159, blas_overflow = 160, blas_sfmin = 161, blas_base = 151,   blas_t = 152, blas_rnd = 153, blas_ieee = 154, blas_emin = 155,   blas_emax = 156, blas_eps = 157, blas_prec = 158, blas_underflow = 159,   blas_overflow = 160, blas_sfmin = 161, blas_base = 151, blas_t = 152,   blas_rnd = 153, blas_ieee = 154, blas_emin = 155, blas_emax = 156,   blas_eps = 157, blas_prec = 158, blas_underflow = 159, blas_overflow = 160,   blas_sfmin = 161, blas_base = 151, blas_t = 152, blas_rnd = 153,   blas_ieee = 154, blas_emin = 155, blas_emax = 156, blas_eps = 157,   blas_prec = 158, blas_underflow = 159, blas_overflow = 160, blas_sfmin = 161,   blas_base = 151, blas_t = 152, blas_rnd = 153, blas_ieee = 154,   blas_emin = 155, blas_emax = 156, blas_eps = 157, blas_prec = 158,   blas_underflow = 159, blas_overflow = 160, blas_sfmin = 161, blas_base = 151,   blas_t = 152, blas_rnd = 153, blas_ieee = 154, blas_emin = 155,   blas_emax = 156, blas_eps = 157, blas_prec = 158, blas_underflow = 159,   blas_overflow = 160, blas_sfmin = 161, blas_base = 151, blas_t = 152,   blas_rnd = 153, blas_ieee = 154, blas_emin = 155, blas_emax = 156,   blas_eps = 157, blas_prec = 158, blas_underflow = 159, blas_overflow = 160,   blas_sfmin = 161, blas_base = 151, blas_t = 152, blas_rnd = 153,   blas_ieee = 154, blas_emin = 155, blas_emax = 156, blas_eps = 157,   blas_prec = 158, blas_underflow = 159, blas_overflow = 160, blas_sfmin = 161,   blas_base = 151, blas_t = 152, blas_rnd = 153, blas_ieee = 154,   blas_emin = 155, blas_emax = 156, blas_eps = 157, blas_prec = 158,   blas_underflow = 159, blas_overflow = 160, blas_sfmin = 161, blas_base = 151,   blas_t = 152, blas_rnd = 153, blas_ieee = 154, blas_emin = 155,   blas_emax = 156, blas_eps = 157, blas_prec = 158, blas_underflow = 159,   blas_overflow = 160, blas_sfmin = 161, blas_base = 151, blas_t = 152,   blas_rnd = 153, blas_ieee = 154, blas_emin = 155, blas_emax = 156,   blas_eps = 157, blas_prec = 158, blas_underflow = 159, blas_overflow = 160,   blas_sfmin = 161, blas_base = 151, blas_t = 152, blas_rnd = 153,   blas_ieee = 154, blas_emin = 155, blas_emax = 156, blas_eps = 157,   blas_prec = 158, blas_underflow = 159, blas_overflow = 160, blas_sfmin = 161,   blas_base = 151, blas_t = 152, blas_rnd = 153, blas_ieee = 154,   blas_emin = 155, blas_emax = 156, blas_eps = 157, blas_prec = 158,   blas_underflow = 159, blas_overflow = 160, blas_sfmin = 161, blas_base = 151,   blas_t = 152, blas_rnd = 153, blas_ieee = 154, blas_emin = 155,   blas_emax = 156, blas_eps = 157, blas_prec = 158, blas_underflow = 159,   blas_overflow = 160, blas_sfmin = 161, blas_base = 151, blas_t = 152,   blas_rnd = 153, blas_ieee = 154, blas_emin = 155, blas_emax = 156,   blas_eps = 157, blas_prec = 158, blas_underflow = 159, blas_overflow = 160,   blas_sfmin = 161, blas_base = 151, blas_t = 152, blas_rnd = 153,   blas_ieee = 154, blas_emin = 155, blas_emax = 156, blas_eps = 157,   blas_prec = 158, blas_underflow = 159, blas_overflow = 160, blas_sfmin = 161,   blas_base = 151, blas_t = 152, blas_rnd = 153, blas_ieee = 154,   blas_emin = 155, blas_emax = 156, blas_eps = 157, blas_prec = 158,   blas_underflow = 159, blas_overflow = 160, blas_sfmin = 161 }
enum	blas_norm_type {   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178,   blas_one_norm = 171, blas_real_one_norm = 172, blas_two_norm = 173, blas_frobenius_norm = 174,   blas_inf_norm = 175, blas_real_inf_norm = 176, blas_max_norm = 177, blas_real_max_norm = 178 }

Functions
int	testing_dgels (int argc, char **argv)

---

Detailed Description

PLASMA testing routines PLASMA is a software package provided by Univ. of Tennessee, Univ. of California Berkeley and Univ. of Colorado Denver

Version:

2.4.5

Author:

Bilel Hadri

Hatem Ltaief

Date:

2010-11-15 d Tue Nov 22 14:35:48 2011

Definition in file testing_dgels.c.

---

Macro Definition Documentation

#define REAL

Definition at line 28 of file testing_dgels.c.

---

Enumeration Type Documentation

enum blas_cmach_type

Enumerator:

blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin
blas_base
blas_t
blas_rnd
blas_ieee
blas_emin
blas_emax
blas_eps
blas_prec
blas_underflow
blas_overflow
blas_sfmin

Definition at line 38 of file testing_dgels.c.

                     {
            blas_base      = 151,
            blas_t         = 152,
            blas_rnd       = 153,
            blas_ieee      = 154,
            blas_emin      = 155,
            blas_emax      = 156,
            blas_eps       = 157,
            blas_prec      = 158,
            blas_underflow = 159,
            blas_overflow  = 160,
            blas_sfmin     = 161};

enum blas_norm_type

Enumerator:

blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm
blas_one_norm
blas_real_one_norm
blas_two_norm
blas_frobenius_norm
blas_inf_norm
blas_real_inf_norm
blas_max_norm
blas_real_max_norm

Definition at line 51 of file testing_dgels.c.

                    {
            blas_one_norm       = 171,
            blas_real_one_norm  = 172,
            blas_two_norm       = 173,
            blas_frobenius_norm = 174,
            blas_inf_norm       = 175,
            blas_real_inf_norm  = 176,
            blas_max_norm       = 177,
            blas_real_max_norm  = 178 };

enum blas_order_type

Enumerator:

blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor
blas_rowmajor
blas_colmajor

Definition at line 30 of file testing_dgels.c.

                     {
            blas_rowmajor = 101,
            blas_colmajor = 102 };

enum blas_uplo_type

Enumerator:

blas_upper
blas_lower
blas_upper
blas_lower
blas_upper
blas_lower
blas_upper
blas_lower

Definition at line 34 of file testing_dgels.c.

                     {
            blas_upper = 121,
            blas_lower = 122 };

---

Function Documentation

int testing_dgels	(	int	argc,
		char **	argv
	)

Definition at line 198 of file testing_dgels.c.

References blas_eps, check_factorization(), check_orthogonality(), check_solution(), IONE, ISEED, min, PLASMA_Alloc_Workspace_dgels(), PLASMA_dgelqf(), PLASMA_dgelqs(), PLASMA_dgels(), PLASMA_dgeqrf(), PLASMA_dgeqrs(), PLASMA_dorglq(), PLASMA_dorgqr(), PLASMA_dormlq(), PLASMA_dormqr(), PLASMA_dtrsm(), PLASMA_HOUSEHOLDER_MODE, PLASMA_HOUSEHOLDER_SIZE, PLASMA_Set(), PLASMA_TREE_HOUSEHOLDER, PlasmaLeft, PlasmaLower, PlasmaNonUnit, PlasmaNoTrans, PlasmaTrans, PlasmaUpper, Q, T, and USAGE.

{
    int mode = 0;

    if ( argc < 1 ){
        goto usage;
    } else {
        mode = atoi(argv[0]);
    }

    /* Check for number of arguments*/
    if ( ((mode == 0) && (argc != 6)) ||
         ((mode != 0) && (argc != 7)) ){
      usage:
        USAGE("GELS", "MODE M N LDA NRHS LDB [RH]",
              "   - MODE : 0: flat, 1: tree (RH needed)\n"
              "   - M    : number of rows of the matrix A\n"
              "   - N    : number of columns of the matrix A\n"
              "   - LDA  : leading dimension of the matrix A\n"
              "   - NRHS : number of RHS\n"
              "   - LDB  : leading dimension of the matrix B\n"
              "   - RH   : Size of each subdomains\n");
        return -1;
    }

    int M     = atoi(argv[1]);
    int N     = atoi(argv[2]);
    int LDA   = atoi(argv[3]);
    int NRHS  = atoi(argv[4]);
    int LDB   = atoi(argv[5]);
    int rh;

    int K = min(M, N);
    double eps;
    int info_ortho, info_solution, info_factorization;
    int i,j;
    int LDAxN = LDA*N;
    int LDBxNRHS = LDB*NRHS;

    double *A1 = (double *)malloc(LDA*N*sizeof(double));
    double *A2 = (double *)malloc(LDA*N*sizeof(double));
    double *B1 = (double *)malloc(LDB*NRHS*sizeof(double));
    double *B2 = (double *)malloc(LDB*NRHS*sizeof(double));
    double *Q  = (double *)malloc(LDA*N*sizeof(double));
    double *T;

    /* Check if unable to allocate memory */
    if ((!A1)||(!A2)||(!B1)||(!B2)||(!Q)){
        printf("Out of Memory \n ");
        return -2;
    }

    if ( mode ) {
        rh = atoi(argv[6]);

        PLASMA_Set(PLASMA_HOUSEHOLDER_MODE, PLASMA_TREE_HOUSEHOLDER);
        PLASMA_Set(PLASMA_HOUSEHOLDER_SIZE, rh);
    }

    PLASMA_Alloc_Workspace_dgels(M, N, &T);
    eps = BLAS_dfpinfo( blas_eps );

    /*----------------------------------------------------------
    *  TESTING DGELS
    */

    /* Initialize A1 and A2 */
    LAPACKE_dlarnv_work(IONE, ISEED, LDAxN, A1);
    for (i = 0; i < M; i++)
        for (j = 0; j < N; j++)
            A2[LDA*j+i] = A1[LDA*j+i] ;

    /* Initialize B1 and B2 */
    LAPACKE_dlarnv_work(IONE, ISEED, LDBxNRHS, B1);
    for (i = 0; i < M; i++)
        for (j = 0; j < NRHS; j++)
            B2[LDB*j+i] = B1[LDB*j+i] ;

    memset((void*)Q, 0, LDA*N*sizeof(double));
    for (i = 0; i < K; i++)
        Q[LDA*i+i] = 1.0;

    /* PLASMA DGELS */
    PLASMA_dgels(PlasmaNoTrans, M, N, NRHS, A2, LDA, T, B2, LDB);

    /* PLASMA DGELS */
    if (M >= N)
       /* Building the economy-size Q */
       PLASMA_dorgqr(M, N, K, A2, LDA, T, Q, LDA);
    else
       /* Building the economy-size Q */
       PLASMA_dorglq(M, N, K, A2, LDA, T, Q, LDA);

    printf("\n");
    printf("------ TESTS FOR PLASMA DGELS ROUTINE -------  \n");
    printf("            Size of the Matrix %d by %d\n", M, N);
    printf("\n");
    printf(" The matrix A is randomly generated for each test.\n");
    printf("============\n");
    printf(" The relative machine precision (eps) is to be %e \n",eps);
    printf(" Computational tests pass if scaled residuals are less than 60.\n");

    /* Check the orthogonality, factorization and the solution */
    info_ortho = check_orthogonality(M, N, LDA, Q, eps);
    info_factorization = check_factorization(M, N, A1, A2, LDA, Q, eps);
    info_solution = check_solution(M, N, NRHS, A1, LDA, B1, B2, LDB, eps);

    if ((info_solution == 0)&(info_factorization == 0)&(info_ortho == 0)) {
        printf("***************************************************\n");
        printf(" ---- TESTING DGELS ...................... PASSED !\n");
        printf("***************************************************\n");
    }
    else {
        printf("************************************************\n");
        printf(" - TESTING DGELS ... FAILED !\n");
        printf("************************************************\n");
    }

    /*-------------------------------------------------------------
    *  TESTING DGEQRF + DGEQRS or DGELQF + DGELQS
    */

    /* Initialize A1 and A2 */
    LAPACKE_dlarnv_work(IONE, ISEED, LDAxN, A1);
    for (i = 0; i < M; i++)
        for (j = 0; j < N; j++)
            A2[LDA*j+i] = A1[LDA*j+i];

    /* Initialize B1 and B2 */
    LAPACKE_dlarnv_work(IONE, ISEED, LDBxNRHS, B1);
    for (i = 0; i < M; i++)
        for (j = 0; j < NRHS; j++)
             B2[LDB*j+i] = B1[LDB*j+i];

    memset((void*)Q, 0, LDA*N*sizeof(double));
    for (i = 0; i < K; i++)
        Q[LDA*i+i] = 1.0;

    if (M >= N) {
        printf("\n");
        printf("------ TESTS FOR PLASMA DGEQRF + DGEQRS ROUTINE -------  \n");
        printf("            Size of the Matrix %d by %d\n", M, N);
        printf("\n");
        printf(" The matrix A is randomly generated for each test.\n");
        printf("============\n");
        printf(" The relative machine precision (eps) is to be %e \n", eps);
        printf(" Computational tests pass if scaled residuals are less than 60.\n");

        /* Plasma routines */
        PLASMA_dgeqrf(M, N, A2, LDA, T);
        PLASMA_dorgqr(M, N, K, A2, LDA, T, Q, LDA);
        PLASMA_dgeqrs(M, N, NRHS, A2, LDA, T, B2, LDB);

        /* Check the orthogonality, factorization and the solution */
        info_ortho = check_orthogonality(M, N, LDA, Q, eps);
        info_factorization = check_factorization(M, N, A1, A2, LDA, Q, eps);
        info_solution = check_solution(M, N, NRHS, A1, LDA, B1, B2, LDB, eps);

        if ((info_solution == 0)&(info_factorization == 0)&(info_ortho == 0)) {
            printf("***************************************************\n");
            printf(" ---- TESTING DGEQRF + DGEQRS ............ PASSED !\n");
            printf("***************************************************\n");
        }
        else{
            printf("***************************************************\n");
            printf(" - TESTING DGEQRF + DGEQRS ... FAILED !\n");
            printf("***************************************************\n");
        }
    }
    else  {
        printf("\n");
        printf("------ TESTS FOR PLASMA DGELQF + DGELQS ROUTINE -------  \n");
        printf("            Size of the Matrix %d by %d\n", M, N);
        printf("\n");
        printf(" The matrix A is randomly generated for each test.\n");
        printf("============\n");
        printf(" The relative machine precision (eps) is to be %e \n", eps);
        printf(" Computational tests pass if scaled residuals are less than 60.\n");

        /* Plasma routines */
        PLASMA_dgelqf(M, N, A2, LDA, T);
        PLASMA_dorglq(M, N, K, A2, LDA, T, Q, LDA);
        PLASMA_dgelqs(M, N, NRHS, A2, LDA, T, B2, LDB);

       /* Check the orthogonality, factorization and the solution */
       info_ortho = check_orthogonality(M, N, LDA, Q, eps);
       info_factorization = check_factorization(M, N, A1, A2, LDA, Q, eps);
       info_solution = check_solution(M, N, NRHS, A1, LDA, B1, B2, LDB, eps);

       if ( (info_solution == 0) & (info_factorization == 0) & (info_ortho == 0) ) {
          printf("***************************************************\n");
          printf(" ---- TESTING DGELQF + DGELQS ............ PASSED !\n");
          printf("***************************************************\n");
       }
       else {
          printf("***************************************************\n");
          printf(" - TESTING DGELQF + DGELQS ... FAILED !\n");
          printf("***************************************************\n");
        }
    }

    /*----------------------------------------------------------
    *  TESTING DGEQRF + ZORMQR + DTRSM
    */

    /* Initialize A1 and A2 */
    LAPACKE_dlarnv_work(IONE, ISEED, LDAxN, A1);
    for (i = 0; i < M; i++)
        for (j = 0; j < N; j++)
            A2[LDA*j+i] = A1[LDA*j+i];

    /* Initialize B1 and B2 */
    memset(B2, 0, LDB*NRHS*sizeof(double));
    LAPACKE_dlarnv_work(IONE, ISEED, LDBxNRHS, B1);
    for (i = 0; i < M; i++)
        for (j = 0; j < NRHS; j++)
            B2[LDB*j+i] = B1[LDB*j+i];

    /* PLASMA DGEQRF+ DORMQR + DTRSM */
    memset((void*)Q, 0, LDA*N*sizeof(double));
    for (i = 0; i < K; i++)
        Q[LDA*i+i] = 1.0;

    if (M >= N) {
        printf("\n");
        printf("------ TESTS FOR PLASMA DGEQRF + DORMQR + DTRSM  ROUTINE -------  \n");
        printf("            Size of the Matrix %d by %d\n", M, N);
        printf("\n");
        printf(" The matrix A is randomly generated for each test.\n");
        printf("============\n");
        printf(" The relative machine precision (eps) is to be %e \n",eps);
        printf(" Computational tests pass if scaled residuals are less than 60.\n");

        PLASMA_dgeqrf(M, N, A2, LDA, T);
        PLASMA_dorgqr(M, N, K, A2, LDA, T, Q, LDA);
        PLASMA_dormqr(PlasmaLeft, PlasmaTrans, M, NRHS, N, A2, LDA, T, B2, LDB);
        PLASMA_dtrsm(PlasmaLeft, PlasmaUpper, PlasmaNoTrans, PlasmaNonUnit, N, NRHS, 1.0, A2, LDA, B2, LDB);
    }
    else {
        printf("\n");
        printf("------ TESTS FOR PLASMA DGELQF + DORMLQ + DTRSM  ROUTINE -------  \n");
        printf("            Size of the Matrix %d by %d\n", M, N);
        printf("\n");
        printf(" The matrix A is randomly generated for each test.\n");
        printf("============\n");
        printf(" The relative machine precision (eps) is to be %e \n",eps);
        printf(" Computational tests pass if scaled residuals are less than 60.\n");

        PLASMA_dgelqf(M, N, A2, LDA, T);
        PLASMA_dtrsm(PlasmaLeft, PlasmaLower, PlasmaNoTrans, PlasmaNonUnit, M, NRHS, 1.0, A2, LDA, B2, LDB);
        PLASMA_dorglq(M, N, K, A2, LDA, T, Q, LDA);
        PLASMA_dormlq(PlasmaLeft, PlasmaTrans, N, NRHS, M, A2, LDA, T, B2, LDB);
    }

    /* Check the orthogonality, factorization and the solution */
    info_ortho = check_orthogonality(M, N, LDA, Q, eps);
    info_factorization = check_factorization(M, N, A1, A2, LDA, Q, eps);
    info_solution = check_solution(M, N, NRHS, A1, LDA, B1, B2, LDB, eps);

    if ( (info_solution == 0) & (info_factorization == 0) & (info_ortho == 0) ) {
        if (M >= N) {
            printf("***************************************************\n");
            printf(" ---- TESTING DGEQRF + DORMQR + DTRSM .... PASSED !\n");
            printf("***************************************************\n");
        }
        else {
            printf("***************************************************\n");
            printf(" ---- TESTING DGELQF + DTRSM + DORMLQ .... PASSED !\n");
            printf("***************************************************\n");
        }
    }
    else {
        if (M >= N) {
            printf("***************************************************\n");
            printf(" - TESTING DGEQRF + DORMQR + DTRSM ... FAILED !\n");
            printf("***************************************************\n");
        }
        else {
            printf("***************************************************\n");
            printf(" - TESTING DGELQF + DTRSM + DORMLQ ... FAILED !\n");
            printf("***************************************************\n");
        }
    }

    free(A1); free(A2); free(B1); free(B2); free(Q); free(T);

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function: