FLA_Axpy_external.c File Reference

(r)


Functions

FLA_Error FLA_Axpy_external (FLA_Obj alpha, FLA_Obj A, FLA_Obj B)
void FLA_F2C() fla_axpy_external_f (F_INT *alpha, F_INT *A, F_INT *B, F_INT *IERROR)

Function Documentation

FLA_Error FLA_Axpy_external ( FLA_Obj  alpha,
FLA_Obj  A,
FLA_Obj  B 
)

References caxpy(), cblas_caxpy(), cblas_daxpy(), cblas_saxpy(), cblas_zaxpy(), daxpy(), FLA_Axpy_check(), FLA_Check_error_level(), FLA_Obj_datatype(), FLA_Obj_has_zero_dim(), FLA_Obj_is_vector(), FLA_Obj_ldim(), FLA_Obj_length(), FLA_Obj_vector_dim(), FLA_Obj_width(), saxpy(), and zaxpy().

Referenced by FLA_Apply_househ2_UT(), FLA_Axpy(), fla_axpy_external_f(), FLA_Axpy_internal(), FLA_Axpy_task(), FLA_Axpys_external(), FLA_Axpyt_external(), FLA_LQ_UT_blk_var2(), FLA_QR_UT_Accum_T_blk_var1(), FLA_QR_UT_blk_var2(), FLA_Trmmsx_external(), FLA_Trmvsx_external(), FLA_Trsmsx_external(), FLA_Trsvsx_external(), FLASH_Axpy_hierarchy_r(), and FLASH_Obj_exec_parallel().

00036 {
00037   FLA_Datatype datatype;
00038   int          j, n_iter;
00039   int          num_elem;
00040   int          m_A, n_A, inc_A, ldim_A;
00041   int          m_B,      inc_B, ldim_B;
00042 
00043   if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING ) 
00044     FLA_Axpy_check( alpha, A, B );
00045 
00046   if ( FLA_Obj_has_zero_dim( A ) ) return FLA_SUCCESS;
00047 
00048   datatype = FLA_Obj_datatype( A );
00049 
00050   m_A      = FLA_Obj_length( A );
00051   n_A      = FLA_Obj_width( A );
00052   ldim_A   = FLA_Obj_ldim( A );
00053 
00054   m_B      = FLA_Obj_length( B );
00055   ldim_B   = FLA_Obj_ldim( B );
00056 
00057   if ( FLA_Obj_is_vector( A ) )
00058   {
00059     inc_A    = ( m_A == 1 ? ldim_A : 1 );
00060     inc_B    = ( m_B == 1 ? ldim_B : 1 );
00061     n_iter   = 1;
00062     num_elem = FLA_Obj_vector_dim( A );
00063   }
00064   else
00065   {
00066     inc_A    = 1;
00067     inc_B    = 1;
00068     n_iter   = n_A;
00069     num_elem = m_A;
00070   }
00071 
00072   switch ( datatype ){
00073 
00074   case FLA_FLOAT:
00075   {
00076     float *buff_alpha = ( float * ) FLA_FLOAT_PTR( alpha );
00077     float *buff_A     = ( float * ) FLA_FLOAT_PTR( A );
00078     float *buff_B     = ( float * ) FLA_FLOAT_PTR( B );
00079 
00080     for ( j = 0; j < n_iter; ++j )
00081     {
00082 #ifdef FLA_ENABLE_CBLAS_INTERFACE
00083       cblas_saxpy( num_elem,
00084                    *buff_alpha, 
00085                    buff_A + j*ldim_A, inc_A, 
00086                    buff_B + j*ldim_B, inc_B );
00087 #else
00088       FLA_C2F( saxpy )( &num_elem,
00089                         buff_alpha, 
00090                         buff_A + j*ldim_A, &inc_A, 
00091                         buff_B + j*ldim_B, &inc_B );
00092 #endif
00093     }
00094 
00095     break;
00096   }
00097 
00098   case FLA_DOUBLE:
00099   {
00100     double *buff_alpha = ( double * ) FLA_DOUBLE_PTR( alpha );
00101     double *buff_A     = ( double * ) FLA_DOUBLE_PTR( A );
00102     double *buff_B     = ( double * ) FLA_DOUBLE_PTR( B );
00103 
00104     for ( j = 0; j < n_iter; ++j )
00105     {
00106 #ifdef FLA_ENABLE_CBLAS_INTERFACE
00107       cblas_daxpy( num_elem,
00108                    *buff_alpha, 
00109                    buff_A + j*ldim_A, inc_A, 
00110                    buff_B + j*ldim_B, inc_B );
00111 #else
00112       FLA_C2F( daxpy )( &num_elem,
00113                         buff_alpha, 
00114                         buff_A + j*ldim_A, &inc_A, 
00115                         buff_B + j*ldim_B, &inc_B );
00116 #endif
00117     }
00118 
00119     break;
00120   }
00121 
00122   case FLA_COMPLEX:
00123   {
00124     scomplex *buff_alpha = ( scomplex * ) FLA_COMPLEX_PTR( alpha );
00125     scomplex *buff_A =     ( scomplex * ) FLA_COMPLEX_PTR( A );
00126     scomplex *buff_B =     ( scomplex * ) FLA_COMPLEX_PTR( B );
00127 
00128     for ( j = 0; j < n_iter; ++j )
00129     {
00130 #ifdef FLA_ENABLE_CBLAS_INTERFACE
00131       cblas_caxpy( num_elem,
00132                    *buff_alpha, 
00133                    buff_A + j*ldim_A, inc_A, 
00134                    buff_B + j*ldim_B, inc_B );
00135 #else
00136       FLA_C2F( caxpy )( &num_elem,
00137                         buff_alpha, 
00138                         buff_A + j*ldim_A, &inc_A, 
00139                         buff_B + j*ldim_B, &inc_B );
00140 #endif
00141     }
00142 
00143     break;
00144   }
00145 
00146   case FLA_DOUBLE_COMPLEX:
00147   {
00148     dcomplex *buff_alpha = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( alpha );
00149     dcomplex *buff_A     = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( A );
00150     dcomplex *buff_B     = ( dcomplex * ) FLA_DOUBLE_COMPLEX_PTR( B );
00151 
00152     for ( j = 0; j < n_iter; ++j )
00153     {
00154 #ifdef FLA_ENABLE_CBLAS_INTERFACE
00155       cblas_zaxpy( num_elem,
00156                    *buff_alpha, 
00157                    buff_A + j*ldim_A, inc_A, 
00158                    buff_B + j*ldim_B, inc_B );
00159 #else
00160       FLA_C2F( zaxpy )( &num_elem,
00161                         buff_alpha, 
00162                         buff_A + j*ldim_A, &inc_A, 
00163                         buff_B + j*ldim_B, &inc_B );
00164 #endif
00165     }
00166 
00167     break;
00168   }
00169 
00170   }
00171   
00172   return FLA_SUCCESS;
00173 }

void FLA_F2C() fla_axpy_external_f ( F_INT *  alpha,
F_INT *  A,
F_INT *  B,
F_INT *  IERROR 
)

References FLA_Axpy_external().

00177 {
00178   *IERROR = FLA_Axpy_external( *( ( FLA_Obj * ) alpha ), 
00179                                *( ( FLA_Obj * ) A     ), 
00180                                *( ( FLA_Obj * ) B     ) );
00181 }


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