FLASH_lapack_prototypes.h File Reference

(r)

Go to the source code of this file.

Functions

FLA_Error FLASH_Chol (FLA_Uplo uplo, FLA_Obj A)
FLA_Error FLASH_LU_nopiv (FLA_Obj A)
FLA_Error FLASH_LU_incpiv (FLA_Obj A, FLA_Obj p, FLA_Obj L)
FLA_Error FLASH_FS_incpiv (FLA_Obj A, FLA_Obj p, FLA_Obj L, FLA_Obj b)
FLA_Error FLASH_Trinv (FLA_Uplo uplo, FLA_Diag diag, FLA_Obj A)
FLA_Error FLASH_Ttmm (FLA_Uplo uplo, FLA_Obj A)
FLA_Error FLASH_SPDinv (FLA_Uplo uplo, FLA_Obj A)
FLA_Error FLASH_Sylv (FLA_Trans transa, FLA_Trans transb, FLA_Obj isgn, FLA_Obj A, FLA_Obj B, FLA_Obj C, FLA_Obj scale)
FLA_Error FLASH_Apply_Q_UT (FLA_Side side, FLA_Trans trans, FLA_Store storev, FLA_Obj A, FLA_Obj T, FLA_Obj W, FLA_Obj B)
FLA_Error FLASH_Apply_Q_UT_UD (FLA_Side side, FLA_Trans trans, FLA_Store storev, FLA_Obj D, FLA_Obj T, FLA_Obj W, FLA_Obj C, FLA_Obj E)
FLA_Error FLASH_QR_UT_UD (FLA_Obj B, FLA_Obj D, FLA_Obj T)
FLA_Error FLASH_QR_UT_inc (FLA_Obj A, FLA_Obj TW)
FLA_Error FLASH_Apply_Q_UT_inc (FLA_Side side, FLA_Trans trans, FLA_Store storev, FLA_Obj A, FLA_Obj TW, FLA_Obj W1, FLA_Obj B)
FLA_Error FLASH_QR (FLA_Obj A, FLA_Obj t, FLA_Obj S)
FLA_Error FLASH_QR_UT (FLA_Obj A, FLA_Obj t, FLA_Obj S)
FLA_Error FLASH_LQ (FLA_Obj A, FLA_Obj t, FLA_Obj S)
FLA_Error FLASH_LQ_UT (FLA_Obj A, FLA_Obj t, FLA_Obj S)
FLA_Error FLASH_Hess (FLA_Obj A, FLA_Obj t, int ilo, int ihi)
void FLA_F2C() flash_chol_f (F_INT *uplo, F_INT *A, F_INT *IERROR)
void FLA_F2C() flash_lu_nopiv_f (F_INT *A, F_INT *IERROR)
void FLA_F2C() flash_lu_incpiv_f (F_INT *A, F_INT *p, F_INT *L, F_INT *IERROR)
void FLA_F2C() flash_fs_incpiv_f (F_INT *A, F_INT *p, F_INT *L, F_INT *b, F_INT *IERROR)
void FLA_F2C() flash_trinv_f (F_INT *uplo, F_INT *diag, F_INT *A, F_INT *IERROR)
void FLA_F2C() flash_ttmm_f (F_INT *uplo, F_INT *A, F_INT *IERROR)
void FLA_F2C() flash_spdinv_f (F_INT *uplo, F_INT *A, F_INT *IERROR)
void FLA_F2C() flash_sylv_f (F_INT *transa, F_INT *transb, F_INT *isgn, F_INT *A, F_INT *B, F_INT *C, F_INT *scale, F_INT *IERROR)
void FLA_F2C() flash_qr_f (F_INT *A, F_INT *t, F_INT *S, F_INT *IERROR)
void FLA_F2C() flash_qr_ut_f (F_INT *A, F_INT *t, F_INT *S, F_INT *IERROR)
void FLA_F2C() flash_lq_f (F_INT *A, F_INT *t, F_INT *S, F_INT *IERROR)
void FLA_F2C() flash_lq_ut_f (F_INT *A, F_INT *t, F_INT *S, F_INT *IERROR)
void FLA_F2C() flash_hess_f (F_INT *A, F_INT *T, F_INT *ILO, F_INT *IHI, F_INT *IERROR)


Function Documentation

FLA_Error FLASH_Apply_Q_UT ( FLA_Side  side,
FLA_Trans  trans,
FLA_Store  storev,
FLA_Obj  A,
FLA_Obj  T,
FLA_Obj  W,
FLA_Obj  B 
)

References FLA_Apply_Q_UT_check(), FLA_Apply_Q_UT_internal(), FLA_Blocksize_set(), FLA_Check_error_level(), FLASH_Obj_scalar_length(), FLASH_Queue_begin(), and FLASH_Queue_end().

Referenced by flash_apply_q_ut_f().

00040 {
00041   FLA_Error r_val;
00042   int       nb_alg_in;
00043 
00044   // Check parameters.
00045   if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
00046     FLA_Apply_Q_UT_check( side, trans, storev, A, T, W, B );
00047 
00048   // Inspect the length of T to get the blocksize used by the QR/LQ
00049   // factorization, which will be our inner blocksize for Apply_Q_UT.
00050   nb_alg_in = FLASH_Obj_scalar_length( T );
00051 
00052   // Adjust the blocksize of the control tree node for the flat subproblem.
00053   if ( FLA_Cntl_blocksize( fla_apqut_cntl_leaf ) != NULL )
00054     FLA_Blocksize_set( FLA_Cntl_blocksize( fla_apqut_cntl_leaf ),
00055                        nb_alg_in, nb_alg_in, nb_alg_in, nb_alg_in );
00056 
00057   // Begin a parallel region.
00058   FLASH_Queue_begin();
00059   
00060   // Invoke FLA_Apply_Q_UT_internal() with the standard control tree.
00061   r_val = FLA_Apply_Q_UT_internal( side, trans, storev, A, T, W, B, flash_apqut_cntl );
00062 
00063   // End the parallel region.
00064   FLASH_Queue_end();
00065 
00066   return r_val;
00067 }

FLA_Error FLASH_Apply_Q_UT_inc ( FLA_Side  side,
FLA_Trans  trans,
FLA_Store  storev,
FLA_Obj  A,
FLA_Obj  TW,
FLA_Obj  W1,
FLA_Obj  B 
)

00042 {
00043   FLA_Error r_val;
00044   int       nb_alg;
00045   FLA_Obj   TWTL, TWTR,
00046             TWBL, TWBR;
00047 
00048   // Check parameters.
00049   if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
00050     FLA_Apply_Q_UT_inc_check( side, trans, storev, A, TW, W1, B );
00051 
00052   // Inspect the length of a the top-left element of T to get the algorithmic
00053   // blocksize we'll use throughout the Apply_Q_UT_inc algorithm.
00054   FLA_Part_2x2( TW,   &TWTL, &TWTR,
00055                       &TWBL, &TWBR,     1, 1, FLA_TL );
00056   nb_alg = FLASH_Obj_scalar_length( TWTL );
00057 
00058   // Adjust the blocksizes of the leaf control tree nodes, which are invoked
00059   // by the individual QR_UT_inc tasks.
00060   FLA_Blocksize_set( FLA_Cntl_blocksize( fla_apqut_cntl_leaf ),
00061                      nb_alg, nb_alg, nb_alg, nb_alg );
00062   FLA_Blocksize_set( FLA_Cntl_blocksize( fla_apqutud_cntl_leaf ),
00063                      nb_alg, nb_alg, nb_alg, nb_alg );
00064 
00065   // Begin a parallel region.
00066   FLASH_Queue_begin();
00067 
00068   // Invoke FLA_Apply_Q_UT_inc_internal() with the standard control tree.
00069   r_val = FLA_Apply_Q_UT_inc_internal( side, trans, storev, A, TW, W1, B, flash_apqutinc_cntl );
00070 
00071   // End the parallel region.
00072   FLASH_Queue_end();
00073 
00074   return r_val;
00075 }

FLA_Error FLASH_Apply_Q_UT_UD ( FLA_Side  side,
FLA_Trans  trans,
FLA_Store  storev,
FLA_Obj  D,
FLA_Obj  T,
FLA_Obj  W,
FLA_Obj  C,
FLA_Obj  E 
)

00042 {
00043   FLA_Error r_val;
00044   int       nb_alg_in;
00045   FLA_Obj   TT, TB;
00046 
00047   // Check parameters.
00048   if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
00049     FLA_Apply_Q_UT_UD_check( side, trans, storev, D, T, W, C, E );
00050 
00051   // Inspect the length of a single row of T to get the blocksize used by
00052   // the QR/LQ factorization, which will be our inner blocksize for
00053   // Apply_Q_UT_UD.
00054   FLA_Part_2x1( T,   &TT,
00055                      &TB,   1, FLA_TOP );
00056   nb_alg_in = FLASH_Obj_scalar_length( TT );
00057 
00058   // Adjust the blocksize of the leaf control tree node.
00059   FLA_Blocksize_set( FLA_Cntl_blocksize( fla_apqutud_cntl_leaf ),
00060                      nb_alg_in, nb_alg_in, nb_alg_in, nb_alg_in );
00061 
00062   // Begin a parallel region.
00063   FLASH_Queue_begin();
00064   
00065   // Invoke FLA_Apply_Q_UT_UD_internal() with the standard control tree.
00066   r_val = FLA_Apply_Q_UT_UD_internal( side, trans, storev, D, T, W, C, E, flash_apqutud_cntl );
00067 
00068   // End the parallel region.
00069   FLASH_Queue_end();
00070 
00071   return r_val;
00072 }

FLA_Error FLASH_Chol ( FLA_Uplo  uplo,
FLA_Obj  A 
)

References FLA_Check_error_level(), FLA_Chol_check(), FLA_Chol_internal(), FLASH_Queue_begin(), and FLASH_Queue_end().

Referenced by flash_chol_f().

00038 {
00039   FLA_Error r_val;
00040 
00041   // Check parameters.
00042   if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
00043     FLA_Chol_check( uplo, A );
00044 
00045   // Begin a parallel region.
00046   FLASH_Queue_begin();
00047   
00048   // Enqueue tasks via a SuperMatrix-aware control tree.
00049   r_val = FLA_Chol_internal( uplo, A, flash_chol_cntl );
00050   
00051   // End the parallel region.
00052   FLASH_Queue_end();
00053 
00054   return r_val;
00055 }

void FLA_F2C() flash_chol_f ( F_INT *  uplo,
F_INT *  A,
F_INT *  IERROR 
)

References FLASH_Chol().

00059 {
00060   *IERROR = FLASH_Chol( *( ( FLA_Uplo * ) uplo ), 
00061                         *( ( FLA_Obj  * ) A    ) );
00062 }

FLA_Error FLASH_FS_incpiv ( FLA_Obj  A,
FLA_Obj  p,
FLA_Obj  L,
FLA_Obj  b 
)

References FLA_Abort(), FLA_Check_error_level(), FLA_FS_incpiv_check(), FLA_Part_2x2(), FLA_Print_message(), FLASH_FS_incpiv_aux1(), FLASH_Obj_depth(), FLASH_Obj_scalar_width(), FLASH_Queue_disable(), FLASH_Queue_enable(), and FLASH_Queue_get_enabled().

Referenced by flash_fs_incpiv_f().

00036 {
00037   dim_t     nb_alg;
00038   FLA_Error r_val;
00039   FLA_Bool  enable_supermatrix;
00040   FLA_Obj   LTL, LTR,
00041             LBL, LBR;
00042 
00043   // Check parameters.
00044   if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
00045     FLA_FS_incpiv_check( A, p, L, b );
00046 
00047   // *** The current forward substitution algorithm implemented assumes that 
00048   // the matrix has a hierarchical depth of 1. We check for that here, because
00049   // we anticipate that we'll use a more general algorithm in the future, and 
00050   // we don't want to forget to remove the constraint. ***
00051   if ( FLASH_Obj_depth( A ) != 1 )
00052   {
00053     FLA_Print_message( "FLASH_FS_incpiv() currently only supports matrices of depth 1",
00054                        __FILE__, __LINE__ );
00055     FLA_Abort();
00056   }
00057   
00058   // Inspect the width of a the top-left element of L to get the algorithmic
00059   // blocksize we'll use throughout the LU_incpiv algorithm.
00060   FLA_Part_2x2( L,   &LTL, &LTR,
00061                      &LBL, &LBR,     1, 1, FLA_TL );
00062   nb_alg = FLASH_Obj_scalar_width( LTL );
00063 
00064   // Find the status of SuperMatrix.
00065   enable_supermatrix = FLASH_Queue_get_enabled();
00066 
00067   // Temporarily disable SuperMatrix.
00068   FLASH_Queue_disable();
00069   
00070   // Execute tasks.
00071   r_val = FLASH_FS_incpiv_aux1( A, p, L, b, nb_alg );
00072 
00073   // Restore SuperMatrix to its previous status.
00074   if ( enable_supermatrix )
00075      FLASH_Queue_enable();
00076 
00077   return r_val;
00078 }

void FLA_F2C() flash_fs_incpiv_f ( F_INT *  A,
F_INT *  p,
F_INT *  L,
F_INT *  b,
F_INT *  IERROR 
)

References FLASH_FS_incpiv().

00082 {
00083   *IERROR = FLASH_FS_incpiv( *( ( FLA_Obj * ) A ),
00084                              *( ( FLA_Obj * ) p ),
00085                              *( ( FLA_Obj * ) L ),
00086                              *( ( FLA_Obj * ) b ) );
00087 }

FLA_Error FLASH_Hess ( FLA_Obj  A,
FLA_Obj  t,
int  ilo,
int  ihi 
)

void FLA_F2C() flash_hess_f ( F_INT *  A,
F_INT *  T,
F_INT *  ILO,
F_INT *  IHI,
F_INT *  IERROR 
)

FLA_Error FLASH_LQ ( FLA_Obj  A,
FLA_Obj  t,
FLA_Obj  S 
)

void FLA_F2C() flash_lq_f ( F_INT *  A,
F_INT *  t,
F_INT *  S,
F_INT *  IERROR 
)

FLA_Error FLASH_LQ_UT ( FLA_Obj  A,
FLA_Obj  t,
FLA_Obj  S 
)

void FLA_F2C() flash_lq_ut_f ( F_INT *  A,
F_INT *  t,
F_INT *  S,
F_INT *  IERROR 
)

FLA_Error FLASH_LU_incpiv ( FLA_Obj  A,
FLA_Obj  p,
FLA_Obj  L 
)

References FLA_Abort(), FLA_Check_error_level(), FLA_LU_incpiv_check(), FLA_Part_2x2(), FLA_Print_message(), FLASH_LU_incpiv_var2(), FLASH_Obj_depth(), FLASH_Obj_scalar_width(), FLASH_Queue_begin(), and FLASH_Queue_end().

Referenced by flash_lu_incpiv_f().

00036 {
00037   dim_t     nb_alg;
00038   FLA_Error r_val;
00039   FLA_Obj   LTL, LTR,
00040             LBL, LBR;
00041 
00042   // Check parameters.
00043   if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
00044     FLA_LU_incpiv_check( A, p, L );
00045 
00046   // *** The current LU_incpiv algorithm implemented assumes that
00047   // the matrix has a hierarchical depth of 1. We check for that here, because
00048   // we anticipate that we'll use a more general algorithm in the future, and
00049   // we don't want to forget to remove the constraint. ***
00050   if ( FLASH_Obj_depth( A ) != 1 )
00051   {
00052     FLA_Print_message( "FLASH_LU_incpiv() currently only supports matrices of depth 1",
00053                        __FILE__, __LINE__ );
00054     FLA_Abort();
00055   }
00056   
00057   // Inspect the width of a the top-left element of L to get the algorithmic
00058   // blocksize we'll use throughout the LU_incpiv algorithm.
00059   FLA_Part_2x2( L,   &LTL, &LTR,
00060                      &LBL, &LBR,     1, 1, FLA_TL );
00061   nb_alg = FLASH_Obj_scalar_width( LTL );
00062 
00063   // Begin a parallel region.
00064   FLASH_Queue_begin();
00065   
00066   // Enqueue tasks via a SuperMatrix-aware control tree.
00067   r_val = FLASH_LU_incpiv_var2( A, p, L, nb_alg );
00068   
00069   // End the parallel region.
00070   FLASH_Queue_end();
00071 
00072   return r_val;
00073 }

void FLA_F2C() flash_lu_incpiv_f ( F_INT *  A,
F_INT *  p,
F_INT *  L,
F_INT *  IERROR 
)

References FLASH_LU_incpiv().

00077 {
00078   *IERROR = FLASH_LU_incpiv( *( ( FLA_Obj  * ) A ),
00079                              *( ( FLA_Obj  * ) p ),
00080                              *( ( FLA_Obj  * ) L ) );
00081 }

FLA_Error FLASH_LU_nopiv ( FLA_Obj  A  ) 

References FLA_Check_error_level(), FLA_LU_nopiv_check(), FLA_LU_nopiv_internal(), FLASH_Queue_begin(), and FLASH_Queue_end().

Referenced by flash_lu_nopiv_f().

00038 {
00039   FLA_Error r_val;
00040 
00041   // Check parameters.
00042   if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
00043     FLA_LU_nopiv_check( A );
00044 
00045   // Begin a parallel region.
00046   FLASH_Queue_begin();
00047   
00048   // Enqueue tasks via a SuperMatrix-aware control tree.
00049   r_val = FLA_LU_nopiv_internal( A, flash_lu_nopiv_cntl );
00050   
00051   // End the parallel region.
00052   FLASH_Queue_end();
00053 
00054   return r_val;
00055 }

void FLA_F2C() flash_lu_nopiv_f ( F_INT *  A,
F_INT *  IERROR 
)

References FLASH_LU_nopiv().

00059 {
00060   *IERROR = FLASH_LU_nopiv( *( ( FLA_Obj * ) A ) );
00061 }

FLA_Error FLASH_QR ( FLA_Obj  A,
FLA_Obj  t,
FLA_Obj  S 
)

void FLA_F2C() flash_qr_f ( F_INT *  A,
F_INT *  t,
F_INT *  S,
F_INT *  IERROR 
)

FLA_Error FLASH_QR_UT ( FLA_Obj  A,
FLA_Obj  t,
FLA_Obj  S 
)

void FLA_F2C() flash_qr_ut_f ( F_INT *  A,
F_INT *  t,
F_INT *  S,
F_INT *  IERROR 
)

FLA_Error FLASH_QR_UT_inc ( FLA_Obj  A,
FLA_Obj  TW 
)

00036 {
00037   FLA_Error r_val;
00038 
00039   r_val = FLASH_QR_UT_inc_opt1( A, TW );
00040 
00041   return r_val;
00042 }

FLA_Error FLASH_QR_UT_UD ( FLA_Obj  B,
FLA_Obj  D,
FLA_Obj  T 
)

00040 {
00041   FLA_Error r_val;
00042   int       nb_alg_in;
00043   FLA_Obj   TT, TB;
00044 
00045   // Check parameters.
00046   if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
00047     FLA_QR_UT_UD_check( B, D, T );
00048 
00049   // Inspect the length of a single row of T to get the blocksize used by
00050   // the QR/LQ factorization, which will be our inner blocksize for
00051   // QR_UT_UD.
00052   FLA_Part_2x1( T,   &TT,
00053                      &TB,   1, FLA_TOP );
00054   nb_alg_in = FLASH_Obj_scalar_length( TT );
00055 
00056   // Adjust the blocksize of the control tree node for the flat subproblem.
00057   if ( FLA_Cntl_blocksize( fla_qrutud_cntl_leaf ) != NULL )
00058     FLA_Blocksize_set( FLA_Cntl_blocksize( fla_qrutud_cntl_leaf ),
00059                        nb_alg_in, nb_alg_in, nb_alg_in, nb_alg_in );
00060 
00061   // Begin a parallel region.
00062   FLASH_Queue_begin();
00063   
00064   // Invoke FLA_QR_UT_UD_internal() with the standard control tree.
00065   r_val = FLA_QR_UT_UD_internal( B, D, T, flash_qrutud_cntl );
00066 
00067   // End the parallel region.
00068   FLASH_Queue_end();
00069 
00070   return r_val;
00071 }

FLA_Error FLASH_SPDinv ( FLA_Uplo  uplo,
FLA_Obj  A 
)

References FLA_Check_error_level(), FLA_SPDinv_check(), FLA_SPDinv_internal(), FLASH_Queue_begin(), and FLASH_Queue_end().

Referenced by flash_spdinv_f().

00038 {
00039   FLA_Error r_val;
00040 
00041   // Check parameters.
00042   if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
00043     FLA_SPDinv_check( uplo, A );
00044 
00045   // Begin a parallel region.
00046   FLASH_Queue_begin();
00047   
00048   // Enqueue tasks via a SuperMatrix-aware control tree.
00049   r_val = FLA_SPDinv_internal( uplo, A, flash_spdinv_cntl );
00050   
00051   // End the parallel region.
00052   FLASH_Queue_end();
00053 
00054   return r_val;
00055 }

void FLA_F2C() flash_spdinv_f ( F_INT *  uplo,
F_INT *  A,
F_INT *  IERROR 
)

References FLASH_SPDinv().

00059 {
00060   *IERROR = FLASH_SPDinv( *( ( FLA_Uplo * ) uplo ), 
00061                           *( ( FLA_Obj  * ) A    ) );
00062 }

FLA_Error FLASH_Sylv ( FLA_Trans  transa,
FLA_Trans  transb,
FLA_Obj  isgn,
FLA_Obj  A,
FLA_Obj  B,
FLA_Obj  C,
FLA_Obj  scale 
)

References FLA_Check_error_level(), FLA_Sylv_check(), FLA_Sylv_internal(), FLASH_Queue_begin(), and FLASH_Queue_end().

Referenced by flash_sylv_f().

00038 {
00039   FLA_Error r_val;
00040 
00041   // Check parameters.
00042   if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
00043     FLA_Sylv_check( transa, transb, isgn, A, B, C, scale );
00044 
00045   // Begin a parallel region.
00046   FLASH_Queue_begin();
00047   
00048   // Enqueue tasks via a SuperMatrix-aware control tree.
00049   r_val = FLA_Sylv_internal( transa, transb, isgn, A, B, C, scale, flash_sylv_cntl );
00050   
00051   // End the parallel region.
00052   FLASH_Queue_end();
00053 
00054   return r_val;
00055 }

void FLA_F2C() flash_sylv_f ( F_INT *  transa,
F_INT *  transb,
F_INT *  isgn,
F_INT *  A,
F_INT *  B,
F_INT *  C,
F_INT *  scale,
F_INT *  IERROR 
)

References FLASH_Sylv().

00059 {
00060   *IERROR = FLASH_Sylv( *( ( FLA_Trans * ) transa ),
00061                         *( ( FLA_Trans * ) transb ),
00062                         *( ( FLA_Obj   * ) isgn   ),
00063                         *( ( FLA_Obj   * ) A      ),
00064                         *( ( FLA_Obj   * ) B      ),
00065                         *( ( FLA_Obj   * ) C      ),
00066                         *( ( FLA_Obj   * ) scale  ) );
00067 }

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

References FLA_Check_error_level(), FLA_Trinv_check(), FLA_Trinv_internal(), FLASH_Queue_begin(), and FLASH_Queue_end().

Referenced by flash_trinv_f().

00038 {
00039   FLA_Error r_val;
00040 
00041   // Check parameters.
00042   if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
00043     FLA_Trinv_check( uplo, diag, A );
00044 
00045   // Begin a parallel region.
00046   FLASH_Queue_begin();
00047   
00048   // Enqueue tasks via a SuperMatrix-aware control tree.
00049   r_val = FLA_Trinv_internal( uplo, diag, A, flash_trinv_cntl );
00050   
00051   // End the parallel region.
00052   FLASH_Queue_end();
00053 
00054   return r_val;
00055 }

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

References FLASH_Trinv().

00059 {
00060   *IERROR = FLASH_Trinv( *( ( FLA_Uplo * ) uplo ), 
00061                          *( ( FLA_Diag * ) diag ), 
00062                          *( ( FLA_Obj  * ) A    ) );
00063 }

FLA_Error FLASH_Ttmm ( FLA_Uplo  uplo,
FLA_Obj  A 
)

References FLA_Check_error_level(), FLA_Ttmm_check(), FLA_Ttmm_internal(), FLASH_Queue_begin(), and FLASH_Queue_end().

Referenced by flash_ttmm_f().

00038 {
00039   FLA_Error r_val;
00040 
00041   // Check parameters.
00042   if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
00043     FLA_Ttmm_check( uplo, A );
00044 
00045   // Begin a parallel region.
00046   FLASH_Queue_begin();
00047   
00048   // Enqueue tasks via a SuperMatrix-aware control tree.
00049   r_val = FLA_Ttmm_internal( uplo, A, flash_ttmm_cntl );
00050   
00051   // End the parallel region.
00052   FLASH_Queue_end();
00053 
00054   return r_val;
00055 }

void FLA_F2C() flash_ttmm_f ( F_INT *  uplo,
F_INT *  A,
F_INT *  IERROR 
)

References FLASH_Ttmm().

00059 {
00060   *IERROR = FLASH_Ttmm( *( ( FLA_Uplo * ) uplo ), 
00061                         *( ( FLA_Obj  * ) A    ) );
00062 }


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