FLA_Random_tri_matrix.c File Reference

(r)


Functions

FLA_Error FLA_Random_tri_matrix (FLA_Uplo uplo, FLA_Diag diag, FLA_Obj A)
void FLA_F2C() fla_random_tri_matrix_f (F_INT *uplo, F_INT *diag, F_INT *A, F_INT *IERROR)

Function Documentation

FLA_Error FLA_Random_tri_matrix ( FLA_Uplo  uplo,
FLA_Diag  diag,
FLA_Obj  A 
)

References FLA_Check_error_level(), FLA_Obj_datatype(), FLA_Obj_ldim(), FLA_Obj_length(), FLA_Obj_width(), FLA_ONE, FLA_random_dcomplex(), FLA_random_double(), FLA_random_float(), FLA_random_scomplex(), FLA_Random_tri_matrix_check(), and FLA_ZERO.

Referenced by FLA_Random_herm_matrix(), and fla_random_tri_matrix_f().

00036 {
00037   FLA_Datatype datatype;
00038   int          i, j;
00039   int          m_A, n_A, ldim_A;
00040 
00041   if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
00042     FLA_Random_tri_matrix_check( uplo, diag, A );
00043 
00044   datatype = FLA_Obj_datatype( A );
00045 
00046   m_A      = FLA_Obj_length( A );
00047   n_A      = FLA_Obj_width( A );
00048   ldim_A   = FLA_Obj_ldim( A );
00049 
00050   switch( datatype ){
00051 
00052   case FLA_FLOAT:
00053   {
00054     float *buff_A = ( float * ) FLA_FLOAT_PTR( A );
00055     float *buff_0 = ( float * ) FLA_FLOAT_PTR( FLA_ZERO );
00056     float *buff_1 = ( float * ) FLA_FLOAT_PTR( FLA_ONE );
00057 
00058     if ( uplo == FLA_LOWER_TRIANGULAR )
00059     {
00060       for ( j = 0; j < n_A; j++ )
00061       {
00062         for ( i = 0; i < j; i++ )
00063           buff_A[ j*ldim_A + i ] = *buff_0;
00064 
00065         if      ( diag == FLA_UNIT_DIAG )
00066           buff_A[ j*ldim_A + j ] = *buff_1;
00067         else if ( diag == FLA_ZERO_DIAG )
00068           buff_A[ j*ldim_A + j ] = *buff_0;
00069         else
00070           buff_A[ j*ldim_A + j ] = FLA_random_float();
00071 
00072         for ( i = j + 1; i < m_A; i++ )
00073           buff_A[ j*ldim_A + i ] = FLA_random_float();
00074       } 
00075     }
00076     else if ( uplo == FLA_UPPER_TRIANGULAR ) 
00077     {
00078       for ( j = 0; j < n_A; j++ )
00079       {
00080         for ( i = 0; i < j; i++ )
00081           buff_A[ j*ldim_A + i ] = FLA_random_float();
00082 
00083         if      ( diag == FLA_UNIT_DIAG )
00084           buff_A[ j*ldim_A + j ] = *buff_1;
00085         else if ( diag == FLA_ZERO_DIAG )
00086           buff_A[ j*ldim_A + j ] = *buff_0;
00087         else
00088           buff_A[ j*ldim_A + j ] = FLA_random_float();
00089 
00090         for ( i = j + 1; i < m_A; i++ )
00091           buff_A[ j*ldim_A + i ] = *buff_0;
00092       } 
00093     }
00094 
00095     break;
00096   }
00097 
00098   case FLA_DOUBLE:
00099   {
00100     double *buff_A = ( double * ) FLA_DOUBLE_PTR( A );
00101     double *buff_0 = ( double * ) FLA_DOUBLE_PTR( FLA_ZERO );
00102     double *buff_1 = ( double * ) FLA_DOUBLE_PTR( FLA_ONE );
00103 
00104     if ( uplo == FLA_LOWER_TRIANGULAR )
00105     {
00106       for ( j = 0; j < n_A; j++ )
00107       {
00108         for ( i = 0; i < j; i++ )
00109           buff_A[ j*ldim_A + i ] = *buff_0;
00110 
00111         if      ( diag == FLA_UNIT_DIAG )
00112           buff_A[ j*ldim_A + j ] = *buff_1;
00113         else if ( diag == FLA_ZERO_DIAG )
00114           buff_A[ j*ldim_A + j ] = *buff_0;
00115         else
00116           buff_A[ j*ldim_A + j ] = FLA_random_double();
00117 
00118         for ( i = j + 1; i < m_A; i++ )
00119           buff_A[ j*ldim_A + i ] = FLA_random_double();
00120       } 
00121     }
00122     else if ( uplo == FLA_UPPER_TRIANGULAR ) 
00123     {
00124       for ( j = 0; j < n_A; j++ )
00125       {
00126         for ( i = 0; i < j; i++ )
00127           buff_A[ j*ldim_A + i ] = FLA_random_double();
00128 
00129         if      ( diag == FLA_UNIT_DIAG )
00130           buff_A[ j*ldim_A + j ] = *buff_1;
00131         else if ( diag == FLA_ZERO_DIAG )
00132           buff_A[ j*ldim_A + j ] = *buff_0;
00133         else
00134           buff_A[ j*ldim_A + j ] = FLA_random_double();
00135 
00136         for ( i = j + 1; i < m_A; i++ )
00137           buff_A[ j*ldim_A + i ] = *buff_0;
00138       } 
00139     }
00140 
00141     break;
00142   }
00143 
00144   case FLA_COMPLEX:
00145   {
00146     scomplex *buff_A = ( scomplex * ) FLA_COMPLEX_PTR( A );
00147     scomplex *buff_0 = ( scomplex * ) FLA_COMPLEX_PTR( FLA_ZERO );
00148     scomplex *buff_1 = ( scomplex * ) FLA_COMPLEX_PTR( FLA_ONE );
00149 
00150     if ( uplo == FLA_LOWER_TRIANGULAR )
00151     {
00152       for ( j = 0; j < n_A; j++ )
00153       {
00154         for ( i = 0; i < j; i++ )
00155           buff_A[ j*ldim_A + i ] = *buff_0;
00156 
00157         if      ( diag == FLA_UNIT_DIAG )
00158           buff_A[ j*ldim_A + j ] = *buff_1;
00159         else if ( diag == FLA_ZERO_DIAG )
00160           buff_A[ j*ldim_A + j ] = *buff_0;
00161         else
00162           buff_A[ j*ldim_A + j ] = FLA_random_scomplex();
00163 
00164         for ( i = j + 1; i < m_A; i++ )
00165           buff_A[ j*ldim_A + i ] = FLA_random_scomplex();
00166       } 
00167     }
00168     else if ( uplo == FLA_UPPER_TRIANGULAR ) 
00169     {
00170       for ( j = 0; j < n_A; j++ )
00171       {
00172         for ( i = 0; i < j; i++ )
00173           buff_A[ j*ldim_A + i ] = FLA_random_scomplex();
00174 
00175         if      ( diag == FLA_UNIT_DIAG )
00176           buff_A[ j*ldim_A + j ] = *buff_1;
00177         else if ( diag == FLA_ZERO_DIAG )
00178           buff_A[ j*ldim_A + j ] = *buff_0;
00179         else
00180           buff_A[ j*ldim_A + j ] = FLA_random_scomplex();
00181 
00182         for ( i = j + 1; i < m_A; i++ )
00183           buff_A[ j*ldim_A + i ] = *buff_0;
00184       } 
00185     }
00186 
00187     break;
00188   }
00189 
00190   case FLA_DOUBLE_COMPLEX:
00191   {
00192     dcomplex *buff_A = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( A );
00193     dcomplex *buff_0 = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( FLA_ZERO );
00194     dcomplex *buff_1 = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( FLA_ONE );
00195 
00196     if ( uplo == FLA_LOWER_TRIANGULAR )
00197     {
00198       for ( j = 0; j < n_A; j++ )
00199       {
00200         for ( i = 0; i < j; i++ )
00201           buff_A[ j*ldim_A + i ] = *buff_0;
00202 
00203         if      ( diag == FLA_UNIT_DIAG )
00204           buff_A[ j*ldim_A + j ] = *buff_1;
00205         else if ( diag == FLA_ZERO_DIAG )
00206           buff_A[ j*ldim_A + j ] = *buff_0;
00207         else
00208           buff_A[ j*ldim_A + j ] = FLA_random_dcomplex();
00209 
00210         for ( i = j + 1; i < m_A; i++ )
00211           buff_A[ j*ldim_A + i ] = FLA_random_dcomplex();
00212       } 
00213     }
00214     else if ( uplo == FLA_UPPER_TRIANGULAR ) 
00215     {
00216       for ( j = 0; j < n_A; j++ )
00217       {
00218         for ( i = 0; i < j; i++ )
00219           buff_A[ j*ldim_A + i ] = FLA_random_dcomplex();
00220 
00221         if      ( diag == FLA_UNIT_DIAG )
00222           buff_A[ j*ldim_A + j ] = *buff_1;
00223         else if ( diag == FLA_ZERO_DIAG )
00224           buff_A[ j*ldim_A + j ] = *buff_0;
00225         else
00226           buff_A[ j*ldim_A + j ] = FLA_random_dcomplex();
00227 
00228         for ( i = j + 1; i < m_A; i++ )
00229           buff_A[ j*ldim_A + i ] = *buff_0;
00230       } 
00231     }
00232 
00233     break;
00234   }
00235 
00236   }
00237 
00238   return FLA_SUCCESS;
00239 }

void FLA_F2C() fla_random_tri_matrix_f ( F_INT *  uplo,
F_INT *  diag,
F_INT *  A,
F_INT *  IERROR 
)

References FLA_Random_tri_matrix().

00243 {
00244   *IERROR = FLA_Random_tri_matrix( *( ( FLA_Uplo * ) uplo ),
00245                                    *( ( FLA_Diag * ) diag ),
00246                                    *( ( FLA_Obj  * ) A    ) );
00247 }


Generated on Mon Jul 6 05:45:53 2009 for libflame by  doxygen 1.5.9