/*

 *     Written by D.P. Manley, Digital Equipment Corporation.

 *     Prefixed "C_" to BLAS routines and their declarations.

 *

 *     Modified by T. H. Do, 1/23/98, SGI/CRAY Research.

 */

#include <stdlib.h></stdlib.h>

#include "common.h"

#include "cblas_test.h"

void F77_dgemv(int *order, char *transp, int *m, int *n, double *alpha, 

	       double *a, int *lda, double *x, int *incx, double *beta, 

	       double *y, int *incy ) {

  double *A;

  int i,j,LDA;

  enum CBLAS_TRANSPOSE trans;

  get_transpose_type(transp, &trans);

  if (*order == TEST_ROW_MJR) {

     LDA = *n+1;

     A   = ( double* )malloc( (*m)*LDA*sizeof( double ) );

     for( i=0; i<*m; i++ )

        for( j=0; j<*n; j++ )

           A[ LDA*i+j ]=a[ (*lda)*j+i ];

     cblas_dgemv( CblasRowMajor, trans, 

		  *m, *n, *alpha, A, LDA, x, *incx, *beta, y, *incy );

     free(A);

  }

  else if (*order == TEST_COL_MJR)

     cblas_dgemv( CblasColMajor, trans,

		  *m, *n, *alpha, a, *lda, x, *incx, *beta, y, *incy );

  else

     cblas_dgemv( UNDEFINED, trans,

		  *m, *n, *alpha, a, *lda, x, *incx, *beta, y, *incy );

}

void F77_dger(int *order, int *m, int *n, double *alpha, double *x, int *incx,

	     double *y, int *incy, double *a, int *lda ) {

  double *A;

  int i,j,LDA;

  if (*order == TEST_ROW_MJR) {

     LDA = *n+1;

     A   = ( double* )malloc( (*m)*LDA*sizeof( double ) );

     for( i=0; i<*m; i++ ) {

       for( j=0; j<*n; j++ )

         A[ LDA*i+j ]=a[ (*lda)*j+i ];

     }

     cblas_dger(CblasRowMajor, *m, *n, *alpha, x, *incx, y, *incy, A, LDA );

     for( i=0; i<*m; i++ )

       for( j=0; j<*n; j++ )

         a[ (*lda)*j+i ]=A[ LDA*i+j ];

     free(A);

  }

  else

     cblas_dger( CblasColMajor, *m, *n, *alpha, x, *incx, y, *incy, a, *lda );

}

void F77_dtrmv(int *order, char *uplow, char *transp, char *diagn,

	      int *n, double *a, int *lda, double *x, int *incx) {

  double *A;

  int i,j,LDA;

  enum CBLAS_TRANSPOSE trans;

  enum CBLAS_UPLO uplo;

  enum CBLAS_DIAG diag;

  get_transpose_type(transp,&trans); 

  get_uplo_type(uplow,&uplo); 

  get_diag_type(diagn,&diag); 

  if (*order == TEST_ROW_MJR) {

     LDA = *n+1;

     A   = ( double* )malloc( (*n)*LDA*sizeof( double ) );

     for( i=0; i<*n; i++ )

       for( j=0; j<*n; j++ )

         A[ LDA*i+j ]=a[ (*lda)*j+i ];

     cblas_dtrmv(CblasRowMajor, uplo, trans, diag, *n, A, LDA, x, *incx);

     free(A);

  }

  else if (*order == TEST_COL_MJR)

     cblas_dtrmv(CblasColMajor, uplo, trans, diag, *n, a, *lda, x, *incx);

  else {

     cblas_dtrmv(UNDEFINED, uplo, trans, diag, *n, a, *lda, x, *incx);

  }

}

void F77_dtrsv(int *order, char *uplow, char *transp, char *diagn, 

	       int *n, double *a, int *lda, double *x, int *incx ) {

  double *A;

  int i,j,LDA;

  enum CBLAS_TRANSPOSE trans;

  enum CBLAS_UPLO uplo;

  enum CBLAS_DIAG diag;

  get_transpose_type(transp,&trans);

  get_uplo_type(uplow,&uplo);

  get_diag_type(diagn,&diag);

  if (*order == TEST_ROW_MJR) {

     LDA = *n+1;

     A   = ( double* )malloc( (*n)*LDA*sizeof( double ) );

     for( i=0; i<*n; i++ )

        for( j=0; j<*n; j++ )

           A[ LDA*i+j ]=a[ (*lda)*j+i ];

     cblas_dtrsv(CblasRowMajor, uplo, trans, diag, *n, A, LDA, x, *incx );

     free(A);

   }

   else

     cblas_dtrsv(CblasColMajor, uplo, trans, diag, *n, a, *lda, x, *incx );

}

void F77_dsymv(int *order, char *uplow, int *n, double *alpha, double *a, 

	      int *lda, double *x, int *incx, double *beta, double *y,

	      int *incy) {

  double *A;

  int i,j,LDA;

  enum CBLAS_UPLO uplo;

  get_uplo_type(uplow,&uplo);

  if (*order == TEST_ROW_MJR) {

     LDA = *n+1;

     A   = ( double* )malloc( (*n)*LDA*sizeof( double ) );

     for( i=0; i<*n; i++ )

        for( j=0; j<*n; j++ )

           A[ LDA*i+j ]=a[ (*lda)*j+i ];

     cblas_dsymv(CblasRowMajor, uplo, *n, *alpha, A, LDA, x, *incx,

		 *beta, y, *incy );

     free(A);

   }

   else

     cblas_dsymv(CblasColMajor, uplo, *n, *alpha, a, *lda, x, *incx,

		 *beta, y, *incy );

}

void F77_dsyr(int *order, char *uplow, int *n, double *alpha, double *x, 

	     int *incx, double *a, int *lda) {

  double *A;

  int i,j,LDA;

  enum CBLAS_UPLO uplo;

  get_uplo_type(uplow,&uplo);

  if (*order == TEST_ROW_MJR) {

     LDA = *n+1;

     A   = ( double* )malloc( (*n)*LDA*sizeof( double ) );

     for( i=0; i<*n; i++ )

        for( j=0; j<*n; j++ )

           A[ LDA*i+j ]=a[ (*lda)*j+i ];

     cblas_dsyr(CblasRowMajor, uplo, *n, *alpha, x, *incx, A, LDA);

     for( i=0; i<*n; i++ )

       for( j=0; j<*n; j++ )

         a[ (*lda)*j+i ]=A[ LDA*i+j ];

     free(A);

   }

   else

     cblas_dsyr(CblasColMajor, uplo, *n, *alpha, x, *incx, a, *lda);

}

void F77_dsyr2(int *order, char *uplow, int *n, double *alpha, double *x, 

	     int *incx, double *y, int *incy, double *a, int *lda) {

  double *A;

  int i,j,LDA;

  enum CBLAS_UPLO uplo;

  get_uplo_type(uplow,&uplo);

  if (*order == TEST_ROW_MJR) {

     LDA = *n+1;

     A   = ( double* )malloc( (*n)*LDA*sizeof( double ) );

     for( i=0; i<*n; i++ )

        for( j=0; j<*n; j++ )

           A[ LDA*i+j ]=a[ (*lda)*j+i ];

     cblas_dsyr2(CblasRowMajor, uplo, *n, *alpha, x, *incx, y, *incy, A, LDA);

     for( i=0; i<*n; i++ )

       for( j=0; j<*n; j++ )

         a[ (*lda)*j+i ]=A[ LDA*i+j ];

     free(A);

   }

   else

     cblas_dsyr2(CblasColMajor, uplo, *n, *alpha, x, *incx, y, *incy, a, *lda);

}

void F77_dgbmv(int *order, char *transp, int *m, int *n, int *kl, int *ku,

	       double *alpha, double *a, int *lda, double *x, int *incx, 

	       double *beta, double *y, int *incy ) {

  double *A;

  int i,irow,j,jcol,LDA;

  enum CBLAS_TRANSPOSE trans;

  get_transpose_type(transp, &trans);

  if (*order == TEST_ROW_MJR) {

     LDA = *ku+*kl+2;

     A   = ( double* )malloc( (*n+*kl)*LDA*sizeof( double ) );

     for( i=0; i<*ku; i++ ){

        irow=*ku+*kl-i;

        jcol=(*ku)-i;

        for( j=jcol; j<*n; j++ )

           A[ LDA*(j-jcol)+irow ]=a[ (*lda)*j+i ];

     }

     i=*ku;

     irow=*ku+*kl-i;

     for( j=0; j<*n; j++ )

        A[ LDA*j+irow ]=a[ (*lda)*j+i ];

     for( i=*ku+1; i<*ku+*kl+1; i++ ){

        irow=*ku+*kl-i;

        jcol=i-(*ku);

        for( j=jcol; j<(*n+*kl); j++ )

           A[ LDA*j+irow ]=a[ (*lda)*(j-jcol)+i ];

     }

     cblas_dgbmv( CblasRowMajor, trans, *m, *n, *kl, *ku, *alpha, 

		  A, LDA, x, *incx, *beta, y, *incy );

     free(A);

  }

  else

     cblas_dgbmv( CblasColMajor, trans, *m, *n, *kl, *ku, *alpha,

		  a, *lda, x, *incx, *beta, y, *incy );

}

void F77_dtbmv(int *order, char *uplow, char *transp, char *diagn,

	      int *n, int *k, double *a, int *lda, double *x, int *incx) {

  double *A;

  int irow, jcol, i, j, LDA;

  enum CBLAS_TRANSPOSE trans;

  enum CBLAS_UPLO uplo;

  enum CBLAS_DIAG diag;

  get_transpose_type(transp,&trans); 

  get_uplo_type(uplow,&uplo); 

  get_diag_type(diagn,&diag); 

  if (*order == TEST_ROW_MJR) {

     LDA = *k+1;

     A = ( double* )malloc( (*n+*k)*LDA*sizeof( double ) );

     if (uplo == CblasUpper) {

        for( i=0; i<*k; i++ ){

           irow=*k-i;

           jcol=(*k)-i;

           for( j=jcol; j<*n; j++ )

              A[ LDA*(j-jcol)+irow ]=a[ (*lda)*j+i ];

        }

        i=*k;

        irow=*k-i;

        for( j=0; j<*n; j++ )

           A[ LDA*j+irow ]=a[ (*lda)*j+i ];

     }

     else {

       i=0;

       irow=*k-i;

       for( j=0; j<*n; j++ )

          A[ LDA*j+irow ]=a[ (*lda)*j+i ];

       for( i=1; i<*k+1; i++ ){

          irow=*k-i;

          jcol=i;

          for( j=jcol; j<(*n+*k); j++ )

             A[ LDA*j+irow ]=a[ (*lda)*(j-jcol)+i ];

       }

     }

     cblas_dtbmv(CblasRowMajor, uplo, trans, diag, *n, *k, A, LDA, x, *incx);

     free(A);

   }

   else

     cblas_dtbmv(CblasColMajor, uplo, trans, diag, *n, *k, a, *lda, x, *incx);

}

void F77_dtbsv(int *order, char *uplow, char *transp, char *diagn,

	      int *n, int *k, double *a, int *lda, double *x, int *incx) {

  double *A;

  int irow, jcol, i, j, LDA;

  enum CBLAS_TRANSPOSE trans;

  enum CBLAS_UPLO uplo;

  enum CBLAS_DIAG diag;

  get_transpose_type(transp,&trans); 

  get_uplo_type(uplow,&uplo); 

  get_diag_type(diagn,&diag); 

  if (*order == TEST_ROW_MJR) {

     LDA = *k+1;

     A = ( double* )malloc( (*n+*k)*LDA*sizeof( double ) );

     if (uplo == CblasUpper) {

        for( i=0; i<*k; i++ ){

        irow=*k-i;

        jcol=(*k)-i;

        for( j=jcol; j<*n; j++ )

           A[ LDA*(j-jcol)+irow ]=a[ (*lda)*j+i ];

        }

        i=*k;

        irow=*k-i;

        for( j=0; j<*n; j++ )

           A[ LDA*j+irow ]=a[ (*lda)*j+i ];

     }

     else {

        i=0;

        irow=*k-i;

        for( j=0; j<*n; j++ )

           A[ LDA*j+irow ]=a[ (*lda)*j+i ];

        for( i=1; i<*k+1; i++ ){

           irow=*k-i;

           jcol=i;

           for( j=jcol; j<(*n+*k); j++ )

              A[ LDA*j+irow ]=a[ (*lda)*(j-jcol)+i ];

        }

     }

     cblas_dtbsv(CblasRowMajor, uplo, trans, diag, *n, *k, A, LDA, x, *incx);

     free(A);

  }

  else

     cblas_dtbsv(CblasColMajor, uplo, trans, diag, *n, *k, a, *lda, x, *incx);

}

void F77_dsbmv(int *order, char *uplow, int *n, int *k, double *alpha,

	      double *a, int *lda, double *x, int *incx, double *beta, 

	      double *y, int *incy) {

  double *A;

  int i,j,irow,jcol,LDA;

  enum CBLAS_UPLO uplo;

  get_uplo_type(uplow,&uplo);

  if (*order == TEST_ROW_MJR) {

     LDA = *k+1;

     A   = ( double* )malloc( (*n+*k)*LDA*sizeof( double ) );

     if (uplo == CblasUpper) {

        for( i=0; i<*k; i++ ){

           irow=*k-i;

           jcol=(*k)-i;

           for( j=jcol; j<*n; j++ )

        A[ LDA*(j-jcol)+irow ]=a[ (*lda)*j+i ];

        }

        i=*k;

        irow=*k-i;

        for( j=0; j<*n; j++ )

           A[ LDA*j+irow ]=a[ (*lda)*j+i ];

     }

     else {

        i=0;

        irow=*k-i;

        for( j=0; j<*n; j++ )

           A[ LDA*j+irow ]=a[ (*lda)*j+i ];

        for( i=1; i<*k+1; i++ ){

           irow=*k-i;

           jcol=i;

           for( j=jcol; j<(*n+*k); j++ )

              A[ LDA*j+irow ]=a[ (*lda)*(j-jcol)+i ];

        }

     }

     cblas_dsbmv(CblasRowMajor, uplo, *n, *k, *alpha, A, LDA, x, *incx,

		 *beta, y, *incy );

     free(A);

   }

   else

     cblas_dsbmv(CblasColMajor, uplo, *n, *k, *alpha, a, *lda, x, *incx,

		 *beta, y, *incy );

}

void F77_dspmv(int *order, char *uplow, int *n, double *alpha, double *ap,

	      double *x, int *incx, double *beta, double *y, int *incy) {

  double *A,*AP;

  int i,j,k,LDA;

  enum CBLAS_UPLO uplo;

  get_uplo_type(uplow,&uplo);

  if (*order == TEST_ROW_MJR) {

     LDA = *n;

     A   = ( double* )malloc( LDA*LDA*sizeof( double ) );

     AP  = ( double* )malloc( (((LDA+1)*LDA)/2)*sizeof( double ) );

     if (uplo == CblasUpper) {

        for( j=0, k=0; j<*n; j++ )

           for( i=0; i

              A[ LDA*i+j ]=ap[ k ];

        for( i=0, k=0; i<*n; i++ )

           for( j=i; j<*n; j++, k++ )

              AP[ k ]=A[ LDA*i+j ];

     }

     else {

        for( j=0, k=0; j<*n; j++ )

           for( i=j; i<*n; i++, k++ )

              A[ LDA*i+j ]=ap[ k ];

        for( i=0, k=0; i<*n; i++ )

           for( j=0; j

              AP[ k ]=A[ LDA*i+j ];

     }

     cblas_dspmv( CblasRowMajor, uplo, *n, *alpha, AP, x, *incx, *beta, y, 

		  *incy );

     free(A);

     free(AP);

  }

  else

     cblas_dspmv( CblasColMajor, uplo, *n, *alpha, ap, x, *incx, *beta, y, 

		  *incy );

}

void F77_dtpmv(int *order, char *uplow, char *transp, char *diagn,

	      int *n, double *ap, double *x, int *incx) {

  double *A, *AP;

  int i, j, k, LDA;

  enum CBLAS_TRANSPOSE trans;

  enum CBLAS_UPLO uplo;

  enum CBLAS_DIAG diag;

  get_transpose_type(transp,&trans); 

  get_uplo_type(uplow,&uplo); 

  get_diag_type(diagn,&diag); 

  if (*order == TEST_ROW_MJR) {

     LDA = *n;

     A   = ( double* )malloc( LDA*LDA*sizeof( double ) );

     AP  = ( double* )malloc( (((LDA+1)*LDA)/2)*sizeof( double ) );

     if (uplo == CblasUpper) {

        for( j=0, k=0; j<*n; j++ )

           for( i=0; i

              A[ LDA*i+j ]=ap[ k ];

        for( i=0, k=0; i<*n; i++ )

           for( j=i; j<*n; j++, k++ )

              AP[ k ]=A[ LDA*i+j ];

     }

     else {

        for( j=0, k=0; j<*n; j++ )

           for( i=j; i<*n; i++, k++ )

              A[ LDA*i+j ]=ap[ k ];

        for( i=0, k=0; i<*n; i++ )

           for( j=0; j

              AP[ k ]=A[ LDA*i+j ];

     }

     cblas_dtpmv( CblasRowMajor, uplo, trans, diag, *n, AP, x, *incx );

     free(A);

     free(AP);

  }

  else

     cblas_dtpmv( CblasColMajor, uplo, trans, diag, *n, ap, x, *incx );

}

void F77_dtpsv(int *order, char *uplow, char *transp, char *diagn,

	      int *n, double *ap, double *x, int *incx) {

  double *A, *AP;

  int i, j, k, LDA;

  enum CBLAS_TRANSPOSE trans;

  enum CBLAS_UPLO uplo;

  enum CBLAS_DIAG diag;

  get_transpose_type(transp,&trans); 

  get_uplo_type(uplow,&uplo); 

  get_diag_type(diagn,&diag); 

  if (*order == TEST_ROW_MJR) {

     LDA = *n;

     A   = ( double* )malloc( LDA*LDA*sizeof( double ) );

     AP  = ( double* )malloc( (((LDA+1)*LDA)/2)*sizeof( double ) );

     if (uplo == CblasUpper) {

        for( j=0, k=0; j<*n; j++ )

           for( i=0; i

              A[ LDA*i+j ]=ap[ k ];

        for( i=0, k=0; i<*n; i++ )

           for( j=i; j<*n; j++, k++ )

              AP[ k ]=A[ LDA*i+j ];

     }

     else {

        for( j=0, k=0; j<*n; j++ )

           for( i=j; i<*n; i++, k++ )

              A[ LDA*i+j ]=ap[ k ];

        for( i=0, k=0; i<*n; i++ )

           for( j=0; j

              AP[ k ]=A[ LDA*i+j ];

     }

     cblas_dtpsv( CblasRowMajor, uplo, trans, diag, *n, AP, x, *incx );

     free(A);

     free(AP);

  }

  else

     cblas_dtpsv( CblasColMajor, uplo, trans, diag, *n, ap, x, *incx );

}

void F77_dspr(int *order, char *uplow, int *n, double *alpha, double *x, 

	     int *incx, double *ap ){

  double *A, *AP;

  int i,j,k,LDA;

  enum CBLAS_UPLO uplo;

  get_uplo_type(uplow,&uplo);

  if (*order == TEST_ROW_MJR) {

     LDA = *n;

     A   = ( double* )malloc( LDA*LDA*sizeof( double ) );

     AP  = ( double* )malloc( (((LDA+1)*LDA)/2)*sizeof( double ) );

     if (uplo == CblasUpper) {

        for( j=0, k=0; j<*n; j++ )

           for( i=0; i

              A[ LDA*i+j ]=ap[ k ];

        for( i=0, k=0; i<*n; i++ )

           for( j=i; j<*n; j++, k++ )

              AP[ k ]=A[ LDA*i+j ];

     }

     else {

        for( j=0, k=0; j<*n; j++ )

           for( i=j; i<*n; i++, k++ )

              A[ LDA*i+j ]=ap[ k ];

        for( i=0, k=0; i<*n; i++ )

           for( j=0; j

              AP[ k ]=A[ LDA*i+j ];

     }

     cblas_dspr( CblasRowMajor, uplo, *n, *alpha, x, *incx, AP );

     if (uplo == CblasUpper) {

        for( i=0, k=0; i<*n; i++ )

           for( j=i; j<*n; j++, k++ )

              A[ LDA*i+j ]=AP[ k ];

        for( j=0, k=0; j<*n; j++ )

           for( i=0; i

              ap[ k ]=A[ LDA*i+j ];

     }

     else {

        for( i=0, k=0; i<*n; i++ )

           for( j=0; j

              A[ LDA*i+j ]=AP[ k ];

        for( j=0, k=0; j<*n; j++ )

           for( i=j; i<*n; i++, k++ )

              ap[ k ]=A[ LDA*i+j ];

     }

     free(A);

     free(AP);

  }

  else

     cblas_dspr( CblasColMajor, uplo, *n, *alpha, x, *incx, ap );

}

void F77_dspr2(int *order, char *uplow, int *n, double *alpha, double *x, 

	     int *incx, double *y, int *incy, double *ap ){

  double *A, *AP;

  int i,j,k,LDA;

  enum CBLAS_UPLO uplo;

  get_uplo_type(uplow,&uplo);

  if (*order == TEST_ROW_MJR) {

     LDA = *n;

     A   = ( double* )malloc( LDA*LDA*sizeof( double ) );

     AP  = ( double* )malloc( (((LDA+1)*LDA)/2)*sizeof( double ) );

     if (uplo == CblasUpper) {

        for( j=0, k=0; j<*n; j++ )

           for( i=0; i

              A[ LDA*i+j ]=ap[ k ];

        for( i=0, k=0; i<*n; i++ )

           for( j=i; j<*n; j++, k++ )

              AP[ k ]=A[ LDA*i+j ];

     }

     else {

        for( j=0, k=0; j<*n; j++ )

           for( i=j; i<*n; i++, k++ )

              A[ LDA*i+j ]=ap[ k ];

        for( i=0, k=0; i<*n; i++ )

           for( j=0; j

              AP[ k ]=A[ LDA*i+j ];

     }

     cblas_dspr2( CblasRowMajor, uplo, *n, *alpha, x, *incx, y, *incy, AP );

     if (uplo == CblasUpper) {

        for( i=0, k=0; i<*n; i++ )

           for( j=i; j<*n; j++, k++ )

              A[ LDA*i+j ]=AP[ k ];

        for( j=0, k=0; j<*n; j++ )

           for( i=0; i

              ap[ k ]=A[ LDA*i+j ];

     }

     else {

        for( i=0, k=0; i<*n; i++ )

           for( j=0; j

              A[ LDA*i+j ]=AP[ k ];

        for( j=0, k=0; j<*n; j++ )

           for( i=j; i<*n; i++, k++ )

              ap[ k ]=A[ LDA*i+j ];

     }

     free(A);

     free(AP);

  }

  else

     cblas_dspr2( CblasColMajor, uplo, *n, *alpha, x, *incx, y, *incy, ap );

}