libflame revision_anchor
Functions
FLA_UDdate_UT_vars.h File Reference

(r)

Go to the source code of this file.

Functions

FLA_Error FLA_UDdate_UT_blk_var1 (FLA_Obj R, FLA_Obj C, FLA_Obj D, FLA_Obj T, fla_uddateut_t *cntl)
 
FLA_Error FLA_UDdate_UT_blk_var2 (FLA_Obj R, FLA_Obj C, FLA_Obj D, FLA_Obj T, fla_uddateut_t *cntl)
 
FLA_Error FLA_UDdate_UT_unb_var1 (FLA_Obj R, FLA_Obj C, FLA_Obj D, FLA_Obj T)
 
FLA_Error FLA_UDdate_UT_opt_var1 (FLA_Obj R, FLA_Obj C, FLA_Obj D, FLA_Obj T)
 
FLA_Error FLA_UDdate_UT_ops_var1 (int mn_RT, int m_C, int m_D, float *R, int rs_R, int cs_R, float *C, int rs_C, int cs_C, float *D, int rs_D, int cs_D, float *T, int rs_T, int cs_T)
 
FLA_Error FLA_UDdate_UT_opd_var1 (int mn_RT, int m_C, int m_D, double *R, int rs_R, int cs_R, double *C, int rs_C, int cs_C, double *D, int rs_D, int cs_D, double *T, int rs_T, int cs_T)
 
FLA_Error FLA_UDdate_UT_opc_var1 (int mn_RT, int m_C, int m_D, scomplex *R, int rs_R, int cs_R, scomplex *C, int rs_C, int cs_C, scomplex *D, int rs_D, int cs_D, scomplex *T, int rs_T, int cs_T)
 
FLA_Error FLA_UDdate_UT_opz_var1 (int mn_RT, int m_C, int m_D, dcomplex *R, int rs_R, int cs_R, dcomplex *C, int rs_C, int cs_C, dcomplex *D, int rs_D, int cs_D, dcomplex *T, int rs_T, int cs_T)
 

Function Documentation

◆ FLA_UDdate_UT_blk_var1()

FLA_Error FLA_UDdate_UT_blk_var1 ( FLA_Obj  R,
FLA_Obj  C,
FLA_Obj  D,
FLA_Obj  T,
fla_uddateut_t *  cntl 
)
16{
17 FLA_Obj RTL, RTR, R00, R01, R02,
18 RBL, RBR, R10, R11, R12,
19 R20, R21, R22;
20
21 FLA_Obj CL, CR, C0, C1, C2;
22
23 FLA_Obj DL, DR, D0, D1, D2;
24
25 FLA_Obj TL, TR, T0, T1, W12;
26
27 FLA_Obj T1T, T1B;
28
29 FLA_Obj W12T, W12B;
30
31 dim_t b_alg, b;
32
33 // Query the algorithmic blocksize by inspecting the length of T.
34 b_alg = FLA_Obj_length( T );
35
36 FLA_Part_2x2( R, &RTL, &RTR,
37 &RBL, &RBR, 0, 0, FLA_TL );
38
39 FLA_Part_1x2( C, &CL, &CR, 0, FLA_LEFT );
40
41 FLA_Part_1x2( D, &DL, &DR, 0, FLA_LEFT );
42
43 FLA_Part_1x2( T, &TL, &TR, 0, FLA_LEFT );
44
45 while ( FLA_Obj_min_dim( RBR ) > 0 ){
46
47 b = min( b_alg, FLA_Obj_min_dim( RBR ) );
48
49 FLA_Repart_2x2_to_3x3( RTL, /**/ RTR, &R00, /**/ &R01, &R02,
50 /* ************* */ /* ******************** */
51 &R10, /**/ &R11, &R12,
52 RBL, /**/ RBR, &R20, /**/ &R21, &R22,
53 b, b, FLA_BR );
54
55 FLA_Repart_1x2_to_1x3( CL, /**/ CR, &C0, /**/ &C1, &C2,
56 b, FLA_RIGHT );
57
58 FLA_Repart_1x2_to_1x3( DL, /**/ DR, &D0, /**/ &D1, &D2,
59 b, FLA_RIGHT );
60
61 FLA_Repart_1x2_to_1x3( TL, /**/ TR, &T0, /**/ &T1, &W12,
62 b, FLA_RIGHT );
63
64 /*------------------------------------------------------------*/
65
66 FLA_Part_2x1( T1, &T1T,
67 &T1B, b, FLA_TOP );
68
69 /*
70 Perform an up/downdate of the upper triangular factor R11 via
71 up/downdating UT Householder transformations:
72
73 [ R11, ...
74 C1, ...
75 D1, T1T ] = FLA_UDdate_UT( R11, ...
76 C1, ...
77 D1, T1T );
78
79 by updating R11 in such a way that removes the contributions of the rows
80 in D1 while simultaneously adding new contributions to the factorization
81 from the rows of C1. Note that C1 and D1 are also updated in the process.
82 */
83
84 FLA_UDdate_UT_internal( R11,
85 C1,
86 D1, T1T,
87 FLA_Cntl_sub_uddateut( cntl ) );
88
89
90 if ( FLA_Obj_width( R12 ) > 0 )
91 {
92 FLA_Part_2x1( W12, &W12T,
93 &W12B, b, FLA_TOP );
94
95 /*
96 Apply Q' to R12, C2, and D2 from the left:
97
98 / R12 \ / R12 \
99 | C2 | = Q' * | C2 |
100 \ D2 / \ D2 /
101
102 where Q is formed from C1 and D1.
103 */
104
105 FLA_Apply_QUD_UT_internal( FLA_LEFT, FLA_CONJ_TRANSPOSE, FLA_FORWARD, FLA_COLUMNWISE,
106 T1T, W12T,
107 R12,
108 C1, C2,
109 D1, D2, FLA_Cntl_sub_apqudut( cntl ) );
110 }
111
112 /*------------------------------------------------------------*/
113
114 FLA_Cont_with_3x3_to_2x2( &RTL, /**/ &RTR, R00, R01, /**/ R02,
115 R10, R11, /**/ R12,
116 /* ************** */ /* ****************** */
117 &RBL, /**/ &RBR, R20, R21, /**/ R22,
118 FLA_TL );
119
120 FLA_Cont_with_1x3_to_1x2( &CL, /**/ &CR, C0, C1, /**/ C2,
121 FLA_LEFT );
122
123 FLA_Cont_with_1x3_to_1x2( &DL, /**/ &DR, D0, D1, /**/ D2,
124 FLA_LEFT );
125
126 FLA_Cont_with_1x3_to_1x2( &TL, /**/ &TR, T0, T1, /**/ W12,
127 FLA_LEFT );
128 }
129
130 return FLA_SUCCESS;
131}
FLA_Apply_QUD_UT_internal
FLA_Error FLA_Apply_QUD_UT_internal(FLA_Side side, FLA_Trans trans, FLA_Direct direct, FLA_Store storev, FLA_Obj T, FLA_Obj W, FLA_Obj R, FLA_Obj U, FLA_Obj C, FLA_Obj V, FLA_Obj D, fla_apqudut_t *cntl)
Definition FLA_Apply_QUD_UT_internal.c:17
FLA_UDdate_UT_internal
FLA_Error FLA_UDdate_UT_internal(FLA_Obj R, FLA_Obj C, FLA_Obj D, FLA_Obj T, fla_uddateut_t *cntl)
Definition FLA_UDdate_UT_internal.c:16
FLA_Cont_with_3x3_to_2x2
FLA_Error FLA_Cont_with_3x3_to_2x2(FLA_Obj *ATL, FLA_Obj *ATR, FLA_Obj A00, FLA_Obj A01, FLA_Obj A02, FLA_Obj A10, FLA_Obj A11, FLA_Obj A12, FLA_Obj *ABL, FLA_Obj *ABR, FLA_Obj A20, FLA_Obj A21, FLA_Obj A22, FLA_Quadrant quadrant)
Definition FLA_View.c:304
FLA_Part_2x2
FLA_Error FLA_Part_2x2(FLA_Obj A, FLA_Obj *A11, FLA_Obj *A12, FLA_Obj *A21, FLA_Obj *A22, dim_t mb, dim_t nb, FLA_Quadrant quadrant)
Definition FLA_View.c:17
FLA_Cont_with_1x3_to_1x2
FLA_Error FLA_Cont_with_1x3_to_1x2(FLA_Obj *AL, FLA_Obj *AR, FLA_Obj A0, FLA_Obj A1, FLA_Obj A2, FLA_Side side)
Definition FLA_View.c:475
FLA_Obj_width
dim_t FLA_Obj_width(FLA_Obj obj)
Definition FLA_Query.c:123
FLA_Part_1x2
FLA_Error FLA_Part_1x2(FLA_Obj A, FLA_Obj *A1, FLA_Obj *A2, dim_t nb, FLA_Side side)
Definition FLA_View.c:110
FLA_Part_2x1
FLA_Error FLA_Part_2x1(FLA_Obj A, FLA_Obj *A1, FLA_Obj *A2, dim_t mb, FLA_Side side)
Definition FLA_View.c:76
FLA_Obj_length
dim_t FLA_Obj_length(FLA_Obj obj)
Definition FLA_Query.c:116
FLA_Repart_2x2_to_3x3
FLA_Error FLA_Repart_2x2_to_3x3(FLA_Obj ATL, FLA_Obj ATR, FLA_Obj *A00, FLA_Obj *A01, FLA_Obj *A02, FLA_Obj *A10, FLA_Obj *A11, FLA_Obj *A12, FLA_Obj ABL, FLA_Obj ABR, FLA_Obj *A20, FLA_Obj *A21, FLA_Obj *A22, dim_t mb, dim_t nb, FLA_Quadrant quadrant)
Definition FLA_View.c:142
FLA_Repart_1x2_to_1x3
FLA_Error FLA_Repart_1x2_to_1x3(FLA_Obj AL, FLA_Obj AR, FLA_Obj *A0, FLA_Obj *A1, FLA_Obj *A2, dim_t nb, FLA_Side side)
Definition FLA_View.c:267
FLA_Obj_min_dim
dim_t FLA_Obj_min_dim(FLA_Obj obj)
Definition FLA_Query.c:153
dim_t
unsigned long dim_t
Definition FLA_type_defs.h:71
i
int i
Definition bl1_axmyv2.c:145
FLA_Obj_view
Definition FLA_type_defs.h:159

References FLA_Apply_QUD_UT_internal(), FLA_Cont_with_1x3_to_1x2(), FLA_Cont_with_3x3_to_2x2(), FLA_Obj_length(), FLA_Obj_min_dim(), FLA_Obj_width(), FLA_Part_1x2(), FLA_Part_2x1(), FLA_Part_2x2(), FLA_Repart_1x2_to_1x3(), FLA_Repart_2x2_to_3x3(), FLA_UDdate_UT_internal(), and i.

Referenced by FLA_UDdate_UT_internal().

◆ FLA_UDdate_UT_blk_var2()

FLA_Error FLA_UDdate_UT_blk_var2 ( FLA_Obj  R,
FLA_Obj  C,
FLA_Obj  D,
FLA_Obj  T,
fla_uddateut_t *  cntl 
)
16{
17 FLA_Obj CT, C0,
18 CB, C1,
19 C2;
20
21 FLA_Obj DT, D0,
22 DB, D1,
23 D2;
24
25 FLA_Obj TT, T0,
26 TB, T1,
27 T2;
28
29 dim_t b_C, b_D, b_T;
30
31 FLA_Part_2x1( C, &CT,
32 &CB, 0, FLA_TOP );
33
34 FLA_Part_2x1( D, &DT,
35 &DB, 0, FLA_TOP );
36
37 FLA_Part_2x1( T, &TT,
38 &TB, 0, FLA_TOP );
39
40 while ( FLA_Obj_length( CT ) < FLA_Obj_length( C ) &&
41 FLA_Obj_length( DT ) < FLA_Obj_length( D ) ){
42
43 b_C = FLA_Determine_blocksize( CB, FLA_BOTTOM, FLA_Cntl_blocksize( cntl ) );
44 b_D = FLA_Determine_blocksize( DB, FLA_BOTTOM, FLA_Cntl_blocksize( cntl ) );
45 b_T = FLA_Determine_blocksize( TB, FLA_BOTTOM, FLA_Cntl_blocksize( cntl ) );
46
47 FLA_Repart_2x1_to_3x1( CT, &C0,
48 /* ** */ /* ****** */
49 &C1,
50 CB, &C2, b_C, FLA_BOTTOM );
51
52 FLA_Repart_2x1_to_3x1( DT, &D0,
53 /* ** */ /* ****** */
54 &D1,
55 DB, &D2, b_D, FLA_BOTTOM );
56
57 FLA_Repart_2x1_to_3x1( TT, &T0,
58 /* ** */ /* ****** */
59 &T1,
60 TB, &T2, b_T, FLA_BOTTOM );
61
62 /*------------------------------------------------------------*/
63
64 /*
65 Perform an up/downdate of the upper triangular Cholesky factor R via
66 "UD" UT Householder transformations:
67
68 [ R, ...
69 C1, ...
70 D1, T1 ] = FLA_UDdate_UT( R, ...
71 C1, ...
72 D1, T1 );
73
74 by updating R in such a way that removes the contributions of the rows
75 in D1 while simultaneously adding new contributions to the factorization
76 from the rows of C1. Note that C1 and D1 are also updated in the process.
77 Also note that either C1 or D1 may become empty at any iteration.
78 */
79
80 FLA_UDdate_UT_internal( R,
81 C1,
82 D1, T1,
83 FLA_Cntl_sub_uddateut( cntl ) );
84
85 /*------------------------------------------------------------*/
86
87 FLA_Cont_with_3x1_to_2x1( &CT, C0,
88 C1,
89 /* ** */ /* ****** */
90 &CB, C2, FLA_TOP );
91
92 FLA_Cont_with_3x1_to_2x1( &DT, D0,
93 D1,
94 /* ** */ /* ****** */
95 &DB, D2, FLA_TOP );
96
97 FLA_Cont_with_3x1_to_2x1( &TT, T0,
98 T1,
99 /* ** */ /* ****** */
100 &TB, T2, FLA_TOP );
101 }
102
103 return FLA_SUCCESS;
104}
FLA_Cont_with_3x1_to_2x1
FLA_Error FLA_Cont_with_3x1_to_2x1(FLA_Obj *AT, FLA_Obj A0, FLA_Obj A1, FLA_Obj *AB, FLA_Obj A2, FLA_Side side)
Definition FLA_View.c:428
FLA_Repart_2x1_to_3x1
FLA_Error FLA_Repart_2x1_to_3x1(FLA_Obj AT, FLA_Obj *A0, FLA_Obj *A1, FLA_Obj AB, FLA_Obj *A2, dim_t mb, FLA_Side side)
Definition FLA_View.c:226
FLA_Determine_blocksize
dim_t FLA_Determine_blocksize(FLA_Obj A_unproc, FLA_Quadrant to_dir, fla_blocksize_t *cntl_blocksizes)
Definition FLA_Blocksize.c:234

References FLA_Cont_with_3x1_to_2x1(), FLA_Determine_blocksize(), FLA_Obj_length(), FLA_Part_2x1(), FLA_Repart_2x1_to_3x1(), FLA_UDdate_UT_internal(), and i.

Referenced by FLA_UDdate_UT_internal().

◆ FLA_UDdate_UT_opc_var1()

FLA_Error FLA_UDdate_UT_opc_var1 ( int  mn_RT,
int  m_C,
int  m_D,
scomplex *  R,
int  rs_R,
int  cs_R,
scomplex *  C,
int  rs_C,
int  cs_C,
scomplex *  D,
int  rs_D,
int  cs_D,
scomplex *  T,
int  rs_T,
int  cs_T 
)
323{
324 scomplex* buff_half = FLA_COMPLEX_PTR( FLA_ONE_HALF );
325 float* buff_1 = FLA_FLOAT_PTR( FLA_ONE );
326 float* buff_m1 = FLA_FLOAT_PTR( FLA_MINUS_ONE );
327 int i;
328
329 for ( i = 0; i < mn_RT; ++i )
330 {
331 scomplex* rho11 = buff_R + (i )*cs_R + (i )*rs_R;
332 scomplex* r12t = buff_R + (i+1)*cs_R + (i )*rs_R;
333
334 scomplex* c1 = buff_C + (i )*cs_C + (0 )*rs_C;
335 scomplex* C2 = buff_C + (i+1)*cs_C + (0 )*rs_C;
336
337 scomplex* d1 = buff_D + (i )*cs_D + (0 )*rs_D;
338 scomplex* D2 = buff_D + (i+1)*cs_D + (0 )*rs_D;
339
340 scomplex* tau11 = buff_T + (i )*cs_T + (i )*rs_T;
341 scomplex* w12t = buff_T + (i+1)*cs_T + (i )*rs_T;
342
343 int mn_ahead = mn_RT - i - 1;
344
345 //------------------------------------------------------------//
346
347 // FLA_Househ3UD_UT( rho11,
348 // c1,
349 // d1, tau11 );
350 FLA_Househ3UD_UT_opc( m_C,
351 m_D,
352 rho11,
353 c1, rs_C,
354 d1, rs_D,
355 tau11 );
356
357 // FLA_Apply_HUD_UT( FLA_LEFT,
358 // tau11, r12t,
359 // c1, C2,
360 // d1, D2 );
361 FLA_Apply_HUD_UT_l_opc_var1( m_C,
362 m_D,
363 mn_ahead,
364 tau11,
365 w12t, cs_T,
366 r12t, cs_R,
367 c1, rs_C,
368 C2, rs_C, cs_C,
369 d1, rs_D,
370 D2, rs_D, cs_D );
371
372 //------------------------------------------------------------//
373
374 }
375
376 // FLA_Set_to_identity( T );
377 bl1_cident( mn_RT, buff_T, rs_T, cs_T );
378
379 // FLA_Herk( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE,
380 // FLA_ONE, C, FLA_ONE, T );
381 bl1_cherk( BLIS1_UPPER_TRIANGULAR,
382 BLIS1_CONJ_TRANSPOSE,
383 mn_RT,
384 m_C,
385 buff_1,
386 buff_C, rs_C, cs_C,
387 buff_1,
388 buff_T, rs_T, cs_T );
389
390 // FLA_Herk( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE,
391 // FLA_MINUS_ONE, D, FLA_ONE, T );
392 bl1_cherk( BLIS1_UPPER_TRIANGULAR,
393 BLIS1_CONJ_TRANSPOSE,
394 mn_RT,
395 m_D,
396 buff_m1,
397 buff_D, rs_D, cs_D,
398 buff_1,
399 buff_T, rs_T, cs_T );
400
401 // FLA_Scale_diag( FLA_NO_CONJUGATE, FLA_ONE_HALF, T );
402 bl1_cscalediag( BLIS1_NO_CONJUGATE,
403 0,
404 mn_RT,
405 mn_RT,
406 buff_half,
407 buff_T, rs_T, cs_T );
408
409 return FLA_SUCCESS;
410}
FLA_Apply_HUD_UT_l_opc_var1
FLA_Error FLA_Apply_HUD_UT_l_opc_var1(int m_u1_C2, int m_v1_D2, int n_r12t, scomplex *tau, scomplex *w12t, int inc_w12t, scomplex *r12t, int inc_r12t, scomplex *u1, int inc_u1, scomplex *C2, int rs_C2, int cs_C2, scomplex *v1, int inc_v1, scomplex *D2, int rs_D2, int cs_D2)
Definition FLA_Apply_HUD_UT_l_opt_var1.c:329
FLA_MINUS_ONE
FLA_Obj FLA_MINUS_ONE
Definition FLA_Init.c:22
FLA_ONE_HALF
FLA_Obj FLA_ONE_HALF
Definition FLA_Init.c:19
FLA_ONE
FLA_Obj FLA_ONE
Definition FLA_Init.c:18
FLA_Househ3UD_UT_opc
FLA_Error FLA_Househ3UD_UT_opc(int m_x2, int m_y2, scomplex *chi_1, scomplex *x2, int inc_x2, scomplex *y2, int inc_y2, scomplex *tau)
Definition FLA_Househ3UD_UT.c:393
bl1_cherk
void bl1_cherk(uplo1_t uplo, trans1_t trans, int m, int k, float *alpha, scomplex *a, int a_rs, int a_cs, float *beta, scomplex *c, int c_rs, int c_cs)
Definition bl1_herk.c:36
bl1_cscalediag
void bl1_cscalediag(conj1_t conj, int offset, int m, int n, scomplex *sigma, scomplex *a, int a_rs, int a_cs)
Definition bl1_scalediag.c:99
bl1_cident
void bl1_cident(int m, scomplex *a, int a_rs, int a_cs)
Definition bl1_ident.c:51
BLIS1_UPPER_TRIANGULAR
@ BLIS1_UPPER_TRIANGULAR
Definition blis_type_defs.h:63
BLIS1_CONJ_TRANSPOSE
@ BLIS1_CONJ_TRANSPOSE
Definition blis_type_defs.h:57
BLIS1_NO_CONJUGATE
@ BLIS1_NO_CONJUGATE
Definition blis_type_defs.h:81
scomplex
Definition blis_type_defs.h:133

References bl1_cherk(), bl1_cident(), bl1_cscalediag(), BLIS1_CONJ_TRANSPOSE, BLIS1_NO_CONJUGATE, BLIS1_UPPER_TRIANGULAR, FLA_Apply_HUD_UT_l_opc_var1(), FLA_Househ3UD_UT_opc(), FLA_MINUS_ONE, FLA_ONE, FLA_ONE_HALF, and i.

Referenced by FLA_UDdate_UT_opt_var1().

◆ FLA_UDdate_UT_opd_var1()

FLA_Error FLA_UDdate_UT_opd_var1 ( int  mn_RT,
int  m_C,
int  m_D,
double *  R,
int  rs_R,
int  cs_R,
double *  C,
int  rs_C,
int  cs_C,
double *  D,
int  rs_D,
int  cs_D,
double *  T,
int  rs_T,
int  cs_T 
)
225{
226 double* buff_half = FLA_DOUBLE_PTR( FLA_ONE_HALF );
227 double* buff_1 = FLA_DOUBLE_PTR( FLA_ONE );
228 double* buff_m1 = FLA_DOUBLE_PTR( FLA_MINUS_ONE );
229 int i;
230
231 for ( i = 0; i < mn_RT; ++i )
232 {
233 double* rho11 = buff_R + (i )*cs_R + (i )*rs_R;
234 double* r12t = buff_R + (i+1)*cs_R + (i )*rs_R;
235
236 double* c1 = buff_C + (i )*cs_C + (0 )*rs_C;
237 double* C2 = buff_C + (i+1)*cs_C + (0 )*rs_C;
238
239 double* d1 = buff_D + (i )*cs_D + (0 )*rs_D;
240 double* D2 = buff_D + (i+1)*cs_D + (0 )*rs_D;
241
242 double* tau11 = buff_T + (i )*cs_T + (i )*rs_T;
243 double* w12t = buff_T + (i+1)*cs_T + (i )*rs_T;
244
245 int mn_ahead = mn_RT - i - 1;
246
247 //------------------------------------------------------------//
248
249 // FLA_Househ3UD_UT( rho11,
250 // c1,
251 // d1, tau11 );
252 FLA_Househ3UD_UT_opd( m_C,
253 m_D,
254 rho11,
255 c1, rs_C,
256 d1, rs_D,
257 tau11 );
258
259 // FLA_Apply_HUD_UT( FLA_LEFT,
260 // tau11, r12t,
261 // c1, C2,
262 // d1, D2 );
263 FLA_Apply_HUD_UT_l_opd_var1( m_C,
264 m_D,
265 mn_ahead,
266 tau11,
267 w12t, cs_T,
268 r12t, cs_R,
269 c1, rs_C,
270 C2, rs_C, cs_C,
271 d1, rs_D,
272 D2, rs_D, cs_D );
273
274 //------------------------------------------------------------//
275
276 }
277
278 // FLA_Set_to_identity( T );
279 bl1_dident( mn_RT, buff_T, rs_T, cs_T );
280
281 // FLA_Herk( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE,
282 // FLA_ONE, C, FLA_ONE, T );
283 bl1_dsyrk( BLIS1_UPPER_TRIANGULAR,
284 BLIS1_CONJ_TRANSPOSE,
285 mn_RT,
286 m_C,
287 buff_1,
288 buff_C, rs_C, cs_C,
289 buff_1,
290 buff_T, rs_T, cs_T );
291
292 // FLA_Herk( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE,
293 // FLA_MINUS_ONE, D, FLA_ONE, T );
294 bl1_dsyrk( BLIS1_UPPER_TRIANGULAR,
295 BLIS1_CONJ_TRANSPOSE,
296 mn_RT,
297 m_D,
298 buff_m1,
299 buff_D, rs_D, cs_D,
300 buff_1,
301 buff_T, rs_T, cs_T );
302
303 // FLA_Scale_diag( FLA_NO_CONJUGATE, FLA_ONE_HALF, T );
304 bl1_dscalediag( BLIS1_NO_CONJUGATE,
305 0,
306 mn_RT,
307 mn_RT,
308 buff_half,
309 buff_T, rs_T, cs_T );
310
311 return FLA_SUCCESS;
312}
FLA_Apply_HUD_UT_l_opd_var1
FLA_Error FLA_Apply_HUD_UT_l_opd_var1(int m_u1_C2, int m_v1_D2, int n_r12t, double *tau, double *w12t, int inc_w12t, double *r12t, int inc_r12t, double *u1, int inc_u1, double *C2, int rs_C2, int cs_C2, double *v1, int inc_v1, double *D2, int rs_D2, int cs_D2)
Definition FLA_Apply_HUD_UT_l_opt_var1.c:237
FLA_Househ3UD_UT_opd
FLA_Error FLA_Househ3UD_UT_opd(int m_x2, int m_y2, double *chi_1, double *x2, int inc_x2, double *y2, int inc_y2, double *tau)
Definition FLA_Househ3UD_UT.c:267
bl1_dsyrk
void bl1_dsyrk(uplo1_t uplo, trans1_t trans, int m, int k, double *alpha, double *a, int a_rs, int a_cs, double *beta, double *c, int c_rs, int c_cs)
Definition bl1_syrk.c:109
bl1_dscalediag
void bl1_dscalediag(conj1_t conj, int offset, int m, int n, double *sigma, double *a, int a_rs, int a_cs)
Definition bl1_scalediag.c:34
bl1_dident
void bl1_dident(int m, double *a, int a_rs, int a_cs)
Definition bl1_ident.c:32

References bl1_dident(), bl1_dscalediag(), bl1_dsyrk(), BLIS1_CONJ_TRANSPOSE, BLIS1_NO_CONJUGATE, BLIS1_UPPER_TRIANGULAR, FLA_Apply_HUD_UT_l_opd_var1(), FLA_Househ3UD_UT_opd(), FLA_MINUS_ONE, FLA_ONE, FLA_ONE_HALF, and i.

Referenced by FLA_UDdate_UT_opt_var1().

◆ FLA_UDdate_UT_ops_var1()

FLA_Error FLA_UDdate_UT_ops_var1 ( int  mn_RT,
int  m_C,
int  m_D,
float *  R,
int  rs_R,
int  cs_R,
float *  C,
int  rs_C,
int  cs_C,
float *  D,
int  rs_D,
int  cs_D,
float *  T,
int  rs_T,
int  cs_T 
)
127{
128 float* buff_half = FLA_FLOAT_PTR( FLA_ONE_HALF );
129 float* buff_1 = FLA_FLOAT_PTR( FLA_ONE );
130 float* buff_m1 = FLA_FLOAT_PTR( FLA_MINUS_ONE );
131 int i;
132
133 for ( i = 0; i < mn_RT; ++i )
134 {
135 float* rho11 = buff_R + (i )*cs_R + (i )*rs_R;
136 float* r12t = buff_R + (i+1)*cs_R + (i )*rs_R;
137
138 float* c1 = buff_C + (i )*cs_C + (0 )*rs_C;
139 float* C2 = buff_C + (i+1)*cs_C + (0 )*rs_C;
140
141 float* d1 = buff_D + (i )*cs_D + (0 )*rs_D;
142 float* D2 = buff_D + (i+1)*cs_D + (0 )*rs_D;
143
144 float* tau11 = buff_T + (i )*cs_T + (i )*rs_T;
145 float* w12t = buff_T + (i+1)*cs_T + (i )*rs_T;
146
147 int mn_ahead = mn_RT - i - 1;
148
149 //------------------------------------------------------------//
150
151 // FLA_Househ3UD_UT( rho11,
152 // c1,
153 // d1, tau11 );
154 FLA_Househ3UD_UT_ops( m_C,
155 m_D,
156 rho11,
157 c1, rs_C,
158 d1, rs_D,
159 tau11 );
160
161 // FLA_Apply_HUD_UT( FLA_LEFT,
162 // tau11, r12t,
163 // c1, C2,
164 // d1, D2 );
165 FLA_Apply_HUD_UT_l_ops_var1( m_C,
166 m_D,
167 mn_ahead,
168 tau11,
169 w12t, cs_T,
170 r12t, cs_R,
171 c1, rs_C,
172 C2, rs_C, cs_C,
173 d1, rs_D,
174 D2, rs_D, cs_D );
175
176 //------------------------------------------------------------//
177
178 }
179
180 // FLA_Set_to_identity( T );
181 bl1_sident( mn_RT, buff_T, rs_T, cs_T );
182
183 // FLA_Herk( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE,
184 // FLA_ONE, C, FLA_ONE, T );
185 bl1_ssyrk( BLIS1_UPPER_TRIANGULAR,
186 BLIS1_CONJ_TRANSPOSE,
187 mn_RT,
188 m_C,
189 buff_1,
190 buff_C, rs_C, cs_C,
191 buff_1,
192 buff_T, rs_T, cs_T );
193
194 // FLA_Herk( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE,
195 // FLA_MINUS_ONE, D, FLA_ONE, T );
196 bl1_ssyrk( BLIS1_UPPER_TRIANGULAR,
197 BLIS1_CONJ_TRANSPOSE,
198 mn_RT,
199 m_D,
200 buff_m1,
201 buff_D, rs_D, cs_D,
202 buff_1,
203 buff_T, rs_T, cs_T );
204
205 // FLA_Scale_diag( FLA_NO_CONJUGATE, FLA_ONE_HALF, T );
206 bl1_sscalediag( BLIS1_NO_CONJUGATE,
207 0,
208 mn_RT,
209 mn_RT,
210 buff_half,
211 buff_T, rs_T, cs_T );
212
213 return FLA_SUCCESS;
214}
FLA_Apply_HUD_UT_l_ops_var1
FLA_Error FLA_Apply_HUD_UT_l_ops_var1(int m_u1_C2, int m_v1_D2, int n_r12t, float *tau, float *w12t, int inc_w12t, float *r12t, int inc_r12t, float *u1, int inc_u1, float *C2, int rs_C2, int cs_C2, float *v1, int inc_v1, float *D2, int rs_D2, int cs_D2)
Definition FLA_Apply_HUD_UT_l_opt_var1.c:145
FLA_Househ3UD_UT_ops
FLA_Error FLA_Househ3UD_UT_ops(int m_x2, int m_y2, float *chi_1, float *x2, int inc_x2, float *y2, int inc_y2, float *tau)
Definition FLA_Househ3UD_UT.c:140
bl1_ssyrk
void bl1_ssyrk(uplo1_t uplo, trans1_t trans, int m, int k, float *alpha, float *a, int a_rs, int a_cs, float *beta, float *c, int c_rs, int c_cs)
Definition bl1_syrk.c:13
bl1_sident
void bl1_sident(int m, float *a, int a_rs, int a_cs)
Definition bl1_ident.c:13
bl1_sscalediag
void bl1_sscalediag(conj1_t conj, int offset, int m, int n, float *sigma, float *a, int a_rs, int a_cs)
Definition bl1_scalediag.c:13

References bl1_sident(), bl1_sscalediag(), bl1_ssyrk(), BLIS1_CONJ_TRANSPOSE, BLIS1_NO_CONJUGATE, BLIS1_UPPER_TRIANGULAR, FLA_Apply_HUD_UT_l_ops_var1(), FLA_Househ3UD_UT_ops(), FLA_MINUS_ONE, FLA_ONE, FLA_ONE_HALF, and i.

Referenced by FLA_UDdate_UT_opt_var1().

◆ FLA_UDdate_UT_opt_var1()

FLA_Error FLA_UDdate_UT_opt_var1 ( FLA_Obj  R,
FLA_Obj  C,
FLA_Obj  D,
FLA_Obj  T 
)
16{
17 FLA_Datatype datatype;
18 int mn_RT, m_C, m_D;
19 int rs_R, cs_R;
20 int rs_C, cs_C;
21 int rs_D, cs_D;
22 int rs_T, cs_T;
23
24 datatype = FLA_Obj_datatype( R );
25
26 mn_RT = FLA_Obj_length( R );
27 m_C = FLA_Obj_length( C );
28 m_D = FLA_Obj_length( D );
29
30 rs_R = FLA_Obj_row_stride( R );
31 cs_R = FLA_Obj_col_stride( R );
32 rs_C = FLA_Obj_row_stride( C );
33 cs_C = FLA_Obj_col_stride( C );
34 rs_D = FLA_Obj_row_stride( D );
35 cs_D = FLA_Obj_col_stride( D );
36 rs_T = FLA_Obj_row_stride( T );
37 cs_T = FLA_Obj_col_stride( T );
38
39
40 switch ( datatype )
41 {
42 case FLA_FLOAT:
43 {
44 float* buff_R = FLA_FLOAT_PTR( R );
45 float* buff_C = FLA_FLOAT_PTR( C );
46 float* buff_D = FLA_FLOAT_PTR( D );
47 float* buff_T = FLA_FLOAT_PTR( T );
48
49 FLA_UDdate_UT_ops_var1( mn_RT,
50 m_C,
51 m_D,
52 buff_R, rs_R, cs_R,
53 buff_C, rs_C, cs_C,
54 buff_D, rs_D, cs_D,
55 buff_T, rs_T, cs_T );
56
57 break;
58 }
59
60 case FLA_DOUBLE:
61 {
62 double* buff_R = FLA_DOUBLE_PTR( R );
63 double* buff_C = FLA_DOUBLE_PTR( C );
64 double* buff_D = FLA_DOUBLE_PTR( D );
65 double* buff_T = FLA_DOUBLE_PTR( T );
66
67 FLA_UDdate_UT_opd_var1( mn_RT,
68 m_C,
69 m_D,
70 buff_R, rs_R, cs_R,
71 buff_C, rs_C, cs_C,
72 buff_D, rs_D, cs_D,
73 buff_T, rs_T, cs_T );
74
75 break;
76 }
77
78 case FLA_COMPLEX:
79 {
80 scomplex* buff_R = FLA_COMPLEX_PTR( R );
81 scomplex* buff_C = FLA_COMPLEX_PTR( C );
82 scomplex* buff_D = FLA_COMPLEX_PTR( D );
83 scomplex* buff_T = FLA_COMPLEX_PTR( T );
84
85 FLA_UDdate_UT_opc_var1( mn_RT,
86 m_C,
87 m_D,
88 buff_R, rs_R, cs_R,
89 buff_C, rs_C, cs_C,
90 buff_D, rs_D, cs_D,
91 buff_T, rs_T, cs_T );
92
93 break;
94 }
95
96 case FLA_DOUBLE_COMPLEX:
97 {
98 dcomplex* buff_R = FLA_DOUBLE_COMPLEX_PTR( R );
99 dcomplex* buff_C = FLA_DOUBLE_COMPLEX_PTR( C );
100 dcomplex* buff_D = FLA_DOUBLE_COMPLEX_PTR( D );
101 dcomplex* buff_T = FLA_DOUBLE_COMPLEX_PTR( T );
102
103 FLA_UDdate_UT_opz_var1( mn_RT,
104 m_C,
105 m_D,
106 buff_R, rs_R, cs_R,
107 buff_C, rs_C, cs_C,
108 buff_D, rs_D, cs_D,
109 buff_T, rs_T, cs_T );
110
111 break;
112 }
113 }
114
115 return FLA_SUCCESS;
116}
FLA_UDdate_UT_opc_var1
FLA_Error FLA_UDdate_UT_opc_var1(int mn_RT, int m_C, int m_D, scomplex *buff_R, int rs_R, int cs_R, scomplex *buff_C, int rs_C, int cs_C, scomplex *buff_D, int rs_D, int cs_D, scomplex *buff_T, int rs_T, int cs_T)
Definition FLA_UDdate_UT_opt_var1.c:316
FLA_UDdate_UT_opd_var1
FLA_Error FLA_UDdate_UT_opd_var1(int mn_RT, int m_C, int m_D, double *buff_R, int rs_R, int cs_R, double *buff_C, int rs_C, int cs_C, double *buff_D, int rs_D, int cs_D, double *buff_T, int rs_T, int cs_T)
Definition FLA_UDdate_UT_opt_var1.c:218
FLA_UDdate_UT_opz_var1
FLA_Error FLA_UDdate_UT_opz_var1(int mn_RT, int m_C, int m_D, dcomplex *buff_R, int rs_R, int cs_R, dcomplex *buff_C, int rs_C, int cs_C, dcomplex *buff_D, int rs_D, int cs_D, dcomplex *buff_T, int rs_T, int cs_T)
Definition FLA_UDdate_UT_opt_var1.c:414
FLA_UDdate_UT_ops_var1
FLA_Error FLA_UDdate_UT_ops_var1(int mn_RT, int m_C, int m_D, float *buff_R, int rs_R, int cs_R, float *buff_C, int rs_C, int cs_C, float *buff_D, int rs_D, int cs_D, float *buff_T, int rs_T, int cs_T)
Definition FLA_UDdate_UT_opt_var1.c:120
FLA_Obj_row_stride
dim_t FLA_Obj_row_stride(FLA_Obj obj)
Definition FLA_Query.c:167
FLA_Obj_col_stride
dim_t FLA_Obj_col_stride(FLA_Obj obj)
Definition FLA_Query.c:174
FLA_Obj_datatype
FLA_Datatype FLA_Obj_datatype(FLA_Obj obj)
Definition FLA_Query.c:13
FLA_Datatype
int FLA_Datatype
Definition FLA_type_defs.h:49
dcomplex
Definition blis_type_defs.h:138

References FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_UDdate_UT_opc_var1(), FLA_UDdate_UT_opd_var1(), FLA_UDdate_UT_ops_var1(), FLA_UDdate_UT_opz_var1(), and i.

Referenced by FLA_UDdate_UT_internal().

◆ FLA_UDdate_UT_opz_var1()

FLA_Error FLA_UDdate_UT_opz_var1 ( int  mn_RT,
int  m_C,
int  m_D,
dcomplex *  R,
int  rs_R,
int  cs_R,
dcomplex *  C,
int  rs_C,
int  cs_C,
dcomplex *  D,
int  rs_D,
int  cs_D,
dcomplex *  T,
int  rs_T,
int  cs_T 
)
421{
422 dcomplex* buff_half = FLA_DOUBLE_COMPLEX_PTR( FLA_ONE_HALF );
423 double* buff_1 = FLA_DOUBLE_PTR( FLA_ONE );
424 double* buff_m1 = FLA_DOUBLE_PTR( FLA_MINUS_ONE );
425 int i;
426
427 for ( i = 0; i < mn_RT; ++i )
428 {
429 dcomplex* rho11 = buff_R + (i )*cs_R + (i )*rs_R;
430 dcomplex* r12t = buff_R + (i+1)*cs_R + (i )*rs_R;
431
432 dcomplex* c1 = buff_C + (i )*cs_C + (0 )*rs_C;
433 dcomplex* C2 = buff_C + (i+1)*cs_C + (0 )*rs_C;
434
435 dcomplex* d1 = buff_D + (i )*cs_D + (0 )*rs_D;
436 dcomplex* D2 = buff_D + (i+1)*cs_D + (0 )*rs_D;
437
438 dcomplex* tau11 = buff_T + (i )*cs_T + (i )*rs_T;
439 dcomplex* w12t = buff_T + (i+1)*cs_T + (i )*rs_T;
440
441 int mn_ahead = mn_RT - i - 1;
442
443 //------------------------------------------------------------//
444
445 // FLA_Househ3UD_UT( rho11,
446 // c1,
447 // d1, tau11 );
448 FLA_Househ3UD_UT_opz( m_C,
449 m_D,
450 rho11,
451 c1, rs_C,
452 d1, rs_D,
453 tau11 );
454
455 // FLA_Apply_HUD_UT( FLA_LEFT,
456 // tau11, r12t,
457 // c1, C2,
458 // d1, D2 );
459 FLA_Apply_HUD_UT_l_opz_var1( m_C,
460 m_D,
461 mn_ahead,
462 tau11,
463 w12t, cs_T,
464 r12t, cs_R,
465 c1, rs_C,
466 C2, rs_C, cs_C,
467 d1, rs_D,
468 D2, rs_D, cs_D );
469
470 //------------------------------------------------------------//
471
472 }
473
474 // FLA_Set_to_identity( T );
475 bl1_zident( mn_RT, buff_T, rs_T, cs_T );
476
477 // FLA_Herk( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE,
478 // FLA_ONE, C, FLA_ONE, T );
479 bl1_zherk( BLIS1_UPPER_TRIANGULAR,
480 BLIS1_CONJ_TRANSPOSE,
481 mn_RT,
482 m_C,
483 buff_1,
484 buff_C, rs_C, cs_C,
485 buff_1,
486 buff_T, rs_T, cs_T );
487
488 // FLA_Herk( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE,
489 // FLA_MINUS_ONE, D, FLA_ONE, T );
490 bl1_zherk( BLIS1_UPPER_TRIANGULAR,
491 BLIS1_CONJ_TRANSPOSE,
492 mn_RT,
493 m_D,
494 buff_m1,
495 buff_D, rs_D, cs_D,
496 buff_1,
497 buff_T, rs_T, cs_T );
498
499 // FLA_Scale_diag( FLA_NO_CONJUGATE, FLA_ONE_HALF, T );
500 bl1_zscalediag( BLIS1_NO_CONJUGATE,
501 0,
502 mn_RT,
503 mn_RT,
504 buff_half,
505 buff_T, rs_T, cs_T );
506
507 return FLA_SUCCESS;
508}
FLA_Apply_HUD_UT_l_opz_var1
FLA_Error FLA_Apply_HUD_UT_l_opz_var1(int m_u1_C2, int m_v1_D2, int n_r12t, dcomplex *tau, dcomplex *w12t, int inc_w12t, dcomplex *r12t, int inc_r12t, dcomplex *u1, int inc_u1, dcomplex *C2, int rs_C2, int cs_C2, dcomplex *v1, int inc_v1, dcomplex *D2, int rs_D2, int cs_D2)
Definition FLA_Apply_HUD_UT_l_opt_var1.c:421
FLA_Househ3UD_UT_opz
FLA_Error FLA_Househ3UD_UT_opz(int m_x2, int m_y2, dcomplex *chi_1, dcomplex *x2, int inc_x2, dcomplex *y2, int inc_y2, dcomplex *tau)
Definition FLA_Househ3UD_UT.c:527
bl1_zherk
void bl1_zherk(uplo1_t uplo, trans1_t trans, int m, int k, double *alpha, dcomplex *a, int a_rs, int a_cs, double *beta, dcomplex *c, int c_rs, int c_cs)
Definition bl1_herk.c:184
bl1_zident
void bl1_zident(int m, dcomplex *a, int a_rs, int a_cs)
Definition bl1_ident.c:71
bl1_zscalediag
void bl1_zscalediag(conj1_t conj, int offset, int m, int n, dcomplex *sigma, dcomplex *a, int a_rs, int a_cs)
Definition bl1_scalediag.c:123

References bl1_zherk(), bl1_zident(), bl1_zscalediag(), BLIS1_CONJ_TRANSPOSE, BLIS1_NO_CONJUGATE, BLIS1_UPPER_TRIANGULAR, FLA_Apply_HUD_UT_l_opz_var1(), FLA_Househ3UD_UT_opz(), FLA_MINUS_ONE, FLA_ONE, FLA_ONE_HALF, and i.

Referenced by FLA_UDdate_UT_opt_var1().

◆ FLA_UDdate_UT_unb_var1()

FLA_Error FLA_UDdate_UT_unb_var1 ( FLA_Obj  R,
FLA_Obj  C,
FLA_Obj  D,
FLA_Obj  T 
)
16{
17 FLA_Obj RTL, RTR, R00, r01, R02,
18 RBL, RBR, r10t, rho11, r12t,
19 R20, r21, R22;
20
21 FLA_Obj CL, CR, C0, c1, C2;
22
23 FLA_Obj DL, DR, D0, d1, D2;
24
25 FLA_Obj TTL, TTR, T00, t01, T02,
26 TBL, TBR, t10t, tau11, w12t,
27 T20, t21, T22;
28
29 FLA_Part_2x2( R, &RTL, &RTR,
30 &RBL, &RBR, 0, 0, FLA_TL );
31
32 FLA_Part_1x2( C, &CL, &CR, 0, FLA_LEFT );
33
34 FLA_Part_1x2( D, &DL, &DR, 0, FLA_LEFT );
35
36 FLA_Part_2x2( T, &TTL, &TTR,
37 &TBL, &TBR, 0, 0, FLA_TL );
38
39 while ( FLA_Obj_min_dim( RBR ) > 0 ){
40
41 FLA_Repart_2x2_to_3x3( RTL, /**/ RTR, &R00, /**/ &r01, &R02,
42 /* ************* */ /* ************************** */
43 &r10t, /**/ &rho11, &r12t,
44 RBL, /**/ RBR, &R20, /**/ &r21, &R22,
45 1, 1, FLA_BR );
46
47 FLA_Repart_1x2_to_1x3( CL, /**/ CR, &C0, /**/ &c1, &C2,
48 1, FLA_RIGHT );
49
50 FLA_Repart_1x2_to_1x3( DL, /**/ DR, &D0, /**/ &d1, &D2,
51 1, FLA_RIGHT );
52
53 FLA_Repart_2x2_to_3x3( TTL, /**/ TTR, &T00, /**/ &t01, &T02,
54 /* ************* */ /* ************************ */
55 &t10t, /**/ &tau11, &w12t,
56 TBL, /**/ TBR, &T20, /**/ &t21, &T22,
57 1, 1, FLA_BR );
58
59 /*------------------------------------------------------------*/
60
61 // Compute tau11, u1, and v2 from rho11, c1, and d1 such that tau11, u1,
62 // and v1 determine an up/downdating UT Householder transform H such that
63 // applying H from the left to the column vector consisting of rho11, c1,
64 // and d1 annihilates the entries in c1 and d1 (and updates rho11).
65 FLA_Househ3UD_UT( rho11,
66 c1,
67 d1, tau11 );
68
69 // / r12t \ / r12t \
70 // | C2 | = H' | C2 |
71 // \ D2 / \ D2 /
72 //
73 // where H is formed from tau11, u1 (stored in c1) and v1 (stored in d1).
74 FLA_Apply_HUD_UT( FLA_LEFT,
75 tau11, w12t,
76 r12t,
77 c1, C2,
78 d1, D2 );
79
80 /*------------------------------------------------------------*/
81
82 FLA_Cont_with_3x3_to_2x2( &RTL, /**/ &RTR, R00, r01, /**/ R02,
83 r10t, rho11, /**/ r12t,
84 /* ************** */ /* ************************ */
85 &RBL, /**/ &RBR, R20, r21, /**/ R22,
86 FLA_TL );
87
88 FLA_Cont_with_1x3_to_1x2( &CL, /**/ &CR, C0, c1, /**/ C2,
89 FLA_LEFT );
90
91 FLA_Cont_with_1x3_to_1x2( &DL, /**/ &DR, D0, d1, /**/ D2,
92 FLA_LEFT );
93
94 FLA_Cont_with_3x3_to_2x2( &TTL, /**/ &TTR, T00, t01, /**/ T02,
95 t10t, tau11, /**/ w12t,
96 /* ************** */ /* ********************** */
97 &TBL, /**/ &TBR, T20, t21, /**/ T22,
98 FLA_TL );
99 }
100
101 // T = I + C' * C - D' * D;
102 // T = striu( T ) + 0.5*diag( T );
103 // NOTE: The only reason this 'herk' method of computing T works is because
104 // up-and-downdating is used to up/downdate a system that is being solved
105 // either by QR factorization, or the method of normal equations (Cholesky
106 // factorization on A' * A), and in either case, R will have a real diagonal.
107
108 FLA_Set_to_identity( T );
109
110 FLA_Herk_external( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE,
111 FLA_ONE, C, FLA_ONE, T );
112
113 FLA_Herk_external( FLA_UPPER_TRIANGULAR, FLA_CONJ_TRANSPOSE,
114 FLA_MINUS_ONE, D, FLA_ONE, T );
115
116 FLA_Scale_diag( FLA_NO_CONJUGATE, FLA_ONE_HALF, T );
117
118 return FLA_SUCCESS;
119}
FLA_Herk_external
FLA_Error FLA_Herk_external(FLA_Uplo uplo, FLA_Trans trans, FLA_Obj alpha, FLA_Obj A, FLA_Obj beta, FLA_Obj C)
Definition FLA_Herk_external.c:13
FLA_Apply_HUD_UT
FLA_Error FLA_Apply_HUD_UT(FLA_Side side, FLA_Obj tau, FLA_Obj w12t, FLA_Obj u2, FLA_Obj v2, FLA_Obj r12t, FLA_Obj C2, FLA_Obj D2)
Definition FLA_Apply_HUD_UT.c:13
FLA_Scale_diag
FLA_Error FLA_Scale_diag(FLA_Conj conj, FLA_Obj alpha, FLA_Obj A)
Definition FLA_Scale_diag.c:13
FLA_Set_to_identity
FLA_Error FLA_Set_to_identity(FLA_Obj A)
Definition FLA_Set_to_identity.c:13
FLA_Househ3UD_UT
FLA_Error FLA_Househ3UD_UT(FLA_Obj chi_1, FLA_Obj x2, FLA_Obj y2, FLA_Obj tau)
Definition FLA_Househ3UD_UT.c:16

References FLA_Apply_HUD_UT(), FLA_Cont_with_1x3_to_1x2(), FLA_Cont_with_3x3_to_2x2(), FLA_Herk_external(), FLA_Househ3UD_UT(), FLA_MINUS_ONE, FLA_Obj_min_dim(), FLA_ONE, FLA_ONE_HALF, FLA_Part_1x2(), FLA_Part_2x2(), FLA_Repart_1x2_to_1x3(), FLA_Repart_2x2_to_3x3(), FLA_Scale_diag(), FLA_Set_to_identity(), and i.

Referenced by FLA_UDdate_UT_internal().

Generated on Thu Sep 23 2021 17:46:17 for libflame by doxygen 1.9.8