void F77_zgeru(int *layout, int *m, int *n, CBLAS_TEST_ZOMPLEX *alpha,
CBLAS_TEST_ZOMPLEX *x, int *incx, CBLAS_TEST_ZOMPLEX *y, int *incy,
CBLAS_TEST_ZOMPLEX *a, int *lda) {
CBLAS_TEST_ZOMPLEX *A;
int i,j,LDA;
if (*layout == TEST_ROW_MJR) {
LDA = *n+1;
A=(CBLAS_TEST_ZOMPLEX*)malloc((*m)*LDA*sizeof(CBLAS_TEST_ZOMPLEX));
for( i=0; i<*m; i++ )
for( j=0; j<*n; j++ ) {
A[ LDA*i+j ].real=a[ (*lda)*j+i ].real;
A[ LDA*i+j ].imag=a[ (*lda)*j+i ].imag;
}
cblas_zgeru( 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 ].real=A[ LDA*i+j ].real;
a[ (*lda)*j+i ].imag=A[ LDA*i+j ].imag;
}
free(A);
}
else if (*layout == TEST_COL_MJR)
cblas_zgeru( CblasColMajor, *m, *n, alpha, x, *incx, y, *incy, a, *lda );
else
cblas_zgeru( UNDEFINED, *m, *n, alpha, x, *incx, y, *incy, a, *lda );
}
inline
void geru (CBLAS_ORDER const Order, int const M, int const N,
traits::complex_d const& alpha,
traits::complex_d const* X, int const incX,
traits::complex_d const* Y, int const incY,
traits::complex_d* A, int const lda)
{
cblas_zgeru (Order, M, N,
static_cast<void const*> (&alpha),
static_cast<void const*> (X), incX,
static_cast<void const*> (Y), incY,
static_cast<void*> (A), lda);
}
void
test_ger (void) {
const double flteps = 1e-4, dbleps = 1e-6;
{
int order = 101;
int M = 1;
int N = 1;
int lda = 1;
float alpha = 1.0f;
float A[] = { -0.515f };
float X[] = { 0.611f };
int incX = -1;
float Y[] = { -0.082f };
int incY = -1;
float A_expected[] = { -0.565102f };
cblas_sger(order, M, N, alpha, X, incX, Y, incY, A, lda);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(A[i], A_expected[i], flteps, "sger(case 1390)");
}
};
};
{
int order = 102;
int M = 1;
int N = 1;
int lda = 1;
float alpha = 1.0f;
float A[] = { -0.515f };
float X[] = { 0.611f };
int incX = -1;
float Y[] = { -0.082f };
int incY = -1;
float A_expected[] = { -0.565102f };
cblas_sger(order, M, N, alpha, X, incX, Y, incY, A, lda);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(A[i], A_expected[i], flteps, "sger(case 1391)");
}
};
};
{
int order = 101;
int M = 1;
int N = 1;
int lda = 1;
double alpha = 1;
double A[] = { -0.809 };
double X[] = { -0.652 };
int incX = -1;
double Y[] = { 0.712 };
int incY = -1;
double A_expected[] = { -1.273224 };
cblas_dger(order, M, N, alpha, X, incX, Y, incY, A, lda);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(A[i], A_expected[i], dbleps, "dger(case 1392)");
}
};
};
{
int order = 102;
int M = 1;
int N = 1;
int lda = 1;
double alpha = 1;
double A[] = { -0.809 };
double X[] = { -0.652 };
int incX = -1;
double Y[] = { 0.712 };
int incY = -1;
double A_expected[] = { -1.273224 };
cblas_dger(order, M, N, alpha, X, incX, Y, incY, A, lda);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(A[i], A_expected[i], dbleps, "dger(case 1393)");
}
};
};
{
int order = 101;
int M = 1;
int N = 1;
int lda = 1;
float alpha[2] = {0.0f, 0.0f};
float A[] = { -0.651f, 0.856f };
float X[] = { -0.38f, -0.235f };
int incX = -1;
float Y[] = { -0.627f, 0.757f };
int incY = -1;
float A_expected[] = { -0.651f, 0.856f };
cblas_cgeru(order, M, N, alpha, X, incX, Y, incY, A, lda);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(A[2*i], A_expected[2*i], flteps, "cgeru(case 1394) real");
gsl_test_rel(A[2*i+1], A_expected[2*i+1], flteps, "cgeru(case 1394) imag");
};
};
};
{
int order = 101;
int M = 1;
int N = 1;
int lda = 1;
float alpha[2] = {0.0f, 0.0f};
float A[] = { -0.651f, 0.856f };
float X[] = { -0.38f, -0.235f };
int incX = -1;
float Y[] = { -0.627f, 0.757f };
int incY = -1;
float A_expected[] = { -0.651f, 0.856f };
cblas_cgerc(order, M, N, alpha, X, incX, Y, incY, A, lda);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(A[2*i], A_expected[2*i], flteps, "cgerc(case 1395) real");
gsl_test_rel(A[2*i+1], A_expected[2*i+1], flteps, "cgerc(case 1395) imag");
};
};
};
{
int order = 102;
int M = 1;
int N = 1;
int lda = 1;
float alpha[2] = {0.0f, 0.0f};
float A[] = { -0.651f, 0.856f };
float X[] = { -0.38f, -0.235f };
int incX = -1;
float Y[] = { -0.627f, 0.757f };
int incY = -1;
float A_expected[] = { -0.651f, 0.856f };
cblas_cgeru(order, M, N, alpha, X, incX, Y, incY, A, lda);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(A[2*i], A_expected[2*i], flteps, "cgeru(case 1396) real");
gsl_test_rel(A[2*i+1], A_expected[2*i+1], flteps, "cgeru(case 1396) imag");
};
};
};
{
int order = 102;
int M = 1;
int N = 1;
int lda = 1;
float alpha[2] = {0.0f, 0.0f};
float A[] = { -0.651f, 0.856f };
float X[] = { -0.38f, -0.235f };
int incX = -1;
float Y[] = { -0.627f, 0.757f };
int incY = -1;
float A_expected[] = { -0.651f, 0.856f };
cblas_cgerc(order, M, N, alpha, X, incX, Y, incY, A, lda);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(A[2*i], A_expected[2*i], flteps, "cgerc(case 1397) real");
gsl_test_rel(A[2*i+1], A_expected[2*i+1], flteps, "cgerc(case 1397) imag");
};
};
};
{
int order = 101;
int M = 1;
int N = 1;
int lda = 1;
double alpha[2] = {-1, 0};
double A[] = { -0.426, 0.757 };
double X[] = { -0.579, -0.155 };
int incX = -1;
double Y[] = { 0.831, 0.035 };
int incY = -1;
double A_expected[] = { 0.049724, 0.90607 };
cblas_zgeru(order, M, N, alpha, X, incX, Y, incY, A, lda);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(A[2*i], A_expected[2*i], dbleps, "zgeru(case 1398) real");
gsl_test_rel(A[2*i+1], A_expected[2*i+1], dbleps, "zgeru(case 1398) imag");
};
};
};
{
int order = 101;
int M = 1;
int N = 1;
int lda = 1;
double alpha[2] = {-1, 0};
double A[] = { -0.426, 0.757 };
double X[] = { -0.579, -0.155 };
int incX = -1;
double Y[] = { 0.831, 0.035 };
int incY = -1;
double A_expected[] = { 0.060574, 0.86554 };
cblas_zgerc(order, M, N, alpha, X, incX, Y, incY, A, lda);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(A[2*i], A_expected[2*i], dbleps, "zgerc(case 1399) real");
gsl_test_rel(A[2*i+1], A_expected[2*i+1], dbleps, "zgerc(case 1399) imag");
};
};
};
{
int order = 102;
int M = 1;
int N = 1;
int lda = 1;
double alpha[2] = {-1, 0};
double A[] = { -0.426, 0.757 };
double X[] = { -0.579, -0.155 };
int incX = -1;
double Y[] = { 0.831, 0.035 };
int incY = -1;
double A_expected[] = { 0.049724, 0.90607 };
cblas_zgeru(order, M, N, alpha, X, incX, Y, incY, A, lda);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(A[2*i], A_expected[2*i], dbleps, "zgeru(case 1400) real");
gsl_test_rel(A[2*i+1], A_expected[2*i+1], dbleps, "zgeru(case 1400) imag");
};
};
};
{
int order = 102;
int M = 1;
int N = 1;
int lda = 1;
double alpha[2] = {-1, 0};
double A[] = { -0.426, 0.757 };
double X[] = { -0.579, -0.155 };
int incX = -1;
double Y[] = { 0.831, 0.035 };
int incY = -1;
double A_expected[] = { 0.060574, 0.86554 };
cblas_zgerc(order, M, N, alpha, X, incX, Y, incY, A, lda);
{
int i;
for (i = 0; i < 1; i++) {
gsl_test_rel(A[2*i], A_expected[2*i], dbleps, "zgerc(case 1401) real");
gsl_test_rel(A[2*i+1], A_expected[2*i+1], dbleps, "zgerc(case 1401) imag");
};
};
};
}
/***************************************************************************//**
*
* @ingroup CORE_PLASMA_Complex64_t
*
* CORE_zgetf2_nopiv computes an LU factorization of a general diagonal
* dominant M-by-N matrix A witout no pivoting and no blocking. It is the
* internal function called by CORE_zgetrf_nopiv().
*
* The factorization has the form
* A = L * U
* where L is lower triangular with unit
* diagonal elements (lower trapezoidal if m > n), and U is upper
* triangular (upper trapezoidal if m < n).
*
* This is the right-looking Level 3 BLAS version of the algorithm.
*
*******************************************************************************
*
* @param[in] M
* The number of rows of the matrix A. M >= 0.
*
* @param[in] N
* The number of columns of the matrix A. N >= 0.
*
* @param[in,out] A
* On entry, the M-by-N matrix to be factored.
* On exit, the factors L and U from the factorization
* A = P*L*U; the unit diagonal elements of L are not stored.
*
* @param[in] LDA
* The leading dimension of the array A. LDA >= max(1,M).
*
*******************************************************************************
*
* @return
* \retval PLASMA_SUCCESS successful exit
* \retval <0 if INFO = -k, the k-th argument had an illegal value
* \retval >0 if INFO = k, U(k,k) is exactly zero. The factorization
* has been completed, but the factor U is exactly
* singular, and division by zero will occur if it is used
* to solve a system of equations.
*
******************************************************************************/
int
CORE_zgetf2_nopiv(int M, int N,
PLASMA_Complex64_t *A, int LDA)
{
PLASMA_Complex64_t mzone = (PLASMA_Complex64_t)-1.0;
PLASMA_Complex64_t alpha;
double sfmin;
int i, j, k;
int info;
/* Check input arguments */
info = 0;
if (M < 0) {
coreblas_error(1, "Illegal value of M");
return -1;
}
if (N < 0) {
coreblas_error(2, "Illegal value of N");
return -2;
}
if ((LDA < max(1,M)) && (M > 0)) {
coreblas_error(5, "Illegal value of LDA");
return -5;
}
/* Quick return */
if ( (M == 0) || (N == 0) )
return PLASMA_SUCCESS;
sfmin = LAPACKE_dlamch_work('S');
k = min(M, N);
for(i=0 ; i < k; i++) {
alpha = A[i*LDA+i];
if ( alpha != (PLASMA_Complex64_t)0.0 ) {
/* Compute elements J+1:M of J-th column. */
if (i < M) {
if ( cabs(alpha) > sfmin ) {
alpha = 1.0 / alpha;
cblas_zscal( M-i-1, CBLAS_SADDR(alpha), &(A[i*LDA+i+1]), 1);
} else {
for(j=i+1; j<M; j++)
A[LDA*i+j] = A[LDA*i+j] / alpha;
}
}
} else if ( info == 0 ) {
info = i;
goto end;
}
if ( i < k ) {
/* Update trailing submatrix */
cblas_zgeru(CblasColMajor,
M-i-1, N-i-1, CBLAS_SADDR(mzone),
&A[LDA* i +i+1], 1,
&A[LDA*(i+1)+i ], LDA,
&A[LDA*(i+1)+i+1], LDA);
}
}
end:
return info;
}
