libflame revision_anchor
Functions
FLA_Bidiag_UT.h File Reference

(r)

Go to the source code of this file.

Functions

FLA_Error FLA_Bidiag_UT (FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
 
FLA_Error FLA_Bidiag_UT_internal (FLA_Obj A, FLA_Obj TU, FLA_Obj TV, fla_bidiagut_t *cntl)
 
FLA_Error FLA_Bidiag_UT_l (FLA_Obj A, FLA_Obj TU, FLA_Obj TV, fla_bidiagut_t *cntl)
 
FLA_Error FLA_Bidiag_UT_u (FLA_Obj A, FLA_Obj TU, FLA_Obj TV, fla_bidiagut_t *cntl)
 
FLA_Error FLA_Bidiag_UT_create_T (FLA_Obj A, FLA_Obj *TU, FLA_Obj *TV)
 
FLA_Error FLA_Bidiag_UT_recover_tau (FLA_Obj TU, FLA_Obj TV, FLA_Obj tu, FLA_Obj tv)
 
FLA_Error FLA_Bidiag_UT_extract_diagonals (FLA_Obj A, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Bidiag_UT_u_extract_diagonals (FLA_Obj A, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Bidiag_UT_l_extract_diagonals (FLA_Obj A, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Bidiag_UT_extract_real_diagonals (FLA_Obj A, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Bidiag_UT_u_extract_real_diagonals (FLA_Obj A, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Bidiag_UT_l_extract_real_diagonals (FLA_Obj A, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Bidiag_UT_scale_diagonals (FLA_Obj alpha, FLA_Obj A)
 
FLA_Error FLA_Bidiag_UT_u_scale_diagonals (FLA_Obj alpha, FLA_Obj A)
 
FLA_Error FLA_Bidiag_UT_l_scale_diagonals (FLA_Obj alpha, FLA_Obj A)
 
FLA_Error FLA_Bidiag_UT_realify (FLA_Obj A, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Bidiag_UT_l_realify_unb (FLA_Obj A, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Bidiag_UT_l_realify_opt (FLA_Obj A, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Bidiag_UT_u_realify_unb (FLA_Obj A, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Bidiag_UT_u_realify_opt (FLA_Obj A, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Bidiag_UT_realify_diagonals (FLA_Uplo uplo, FLA_Obj a, FLA_Obj b, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Bidiag_UT_realify_diagonals_opt (FLA_Obj a, FLA_Obj b, FLA_Obj d, FLA_Obj e)
 
FLA_Error FLA_Bidiag_UT_form_U (FLA_Obj A, FLA_Obj T, FLA_Obj U)
 
FLA_Error FLA_Bidiag_UT_form_V (FLA_Obj A, FLA_Obj S, FLA_Obj V)
 
FLA_Error FLA_Bidiag_UT_form_U_ext (FLA_Uplo uplo, FLA_Obj A, FLA_Obj T, FLA_Trans transu, FLA_Obj U)
 
FLA_Error FLA_Bidiag_UT_form_V_ext (FLA_Uplo uplo, FLA_Obj A, FLA_Obj S, FLA_Trans transv, FLA_Obj V)
 

Function Documentation

◆ FLA_Bidiag_UT()

FLA_Error FLA_Bidiag_UT ( FLA_Obj  A,
FLA_Obj  TU,
FLA_Obj  TV 
)
18{
19 FLA_Error r_val;
20
21 // Check parameters.
22 if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
23 FLA_Bidiag_UT_check( A, TU, TV );
24
25 if ( FLA_Obj_row_stride( A ) == 1 &&
26 FLA_Obj_row_stride( TU ) == 1 &&
27 FLA_Obj_row_stride( TV ) == 1 &&
28 FLA_Obj_is_double_precision( A ) )
29 // Temporary modification to "nofus";
30 // fused operations are not working for row-major, ex) bl1_ddotsv2
31 r_val = FLA_Bidiag_UT_internal( A, TU, TV, fla_bidiagut_cntl_plain );
32 else
33 r_val = FLA_Bidiag_UT_internal( A, TU, TV, fla_bidiagut_cntl_plain );
34
35 return r_val;
36}
fla_bidiagut_cntl_plain
fla_bidiagut_t * fla_bidiagut_cntl_plain
Definition FLA_Bidiag_UT_cntl_init.c:15
FLA_Bidiag_UT_internal
FLA_Error FLA_Bidiag_UT_internal(FLA_Obj A, FLA_Obj TU, FLA_Obj TV, fla_bidiagut_t *cntl)
Definition FLA_Bidiag_UT_internal.c:13
FLA_Bidiag_UT_check
FLA_Error FLA_Bidiag_UT_check(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition FLA_Bidiag_UT_check.c:13
FLA_Obj_row_stride
dim_t FLA_Obj_row_stride(FLA_Obj obj)
Definition FLA_Query.c:167
FLA_Check_error_level
unsigned int FLA_Check_error_level(void)
Definition FLA_Check.c:18
FLA_Obj_is_double_precision
FLA_Bool FLA_Obj_is_double_precision(FLA_Obj A)
Definition FLA_Query.c:358
FLA_Error
int FLA_Error
Definition FLA_type_defs.h:47
i
int i
Definition bl1_axmyv2.c:145

References FLA_Bidiag_UT_check(), FLA_Bidiag_UT_internal(), fla_bidiagut_cntl_plain, FLA_Check_error_level(), FLA_Obj_is_double_precision(), FLA_Obj_row_stride(), and i.

Referenced by FLA_Svd_ext_u_unb_var1(), FLA_Svd_uv_unb_var1(), and FLA_Svd_uv_unb_var2().

◆ FLA_Bidiag_UT_create_T()

FLA_Error FLA_Bidiag_UT_create_T ( FLA_Obj  A,
FLA_Obj *  TU,
FLA_Obj *  TV 
)
14{
15 FLA_Datatype datatype;
16 dim_t b_alg, k;
17 dim_t rs_T, cs_T;
18
19 // Query the datatype of A.
20 datatype = FLA_Obj_datatype( A );
21
22 // Query the blocksize from the library.
23 b_alg = FLA_Query_blocksize( datatype, FLA_DIMENSION_MIN );
24
25 // Scale the blocksize by a pre-set global constant.
26 b_alg = ( dim_t )( ( ( double ) b_alg ) * FLA_BIDIAG_INNER_TO_OUTER_B_RATIO );
27
28 // Query the minimum dimension of A.
29 k = FLA_Obj_min_dim( A );
30
31 b_alg = 5;
32
33 // Adjust the blocksize with respect to the min-dim of A.
34 b_alg = min( b_alg, k );
35
36 // Figure out whether TU and TV should be row-major or column-major.
37 if ( FLA_Obj_row_stride( A ) == 1 )
38 {
39 rs_T = 1;
40 cs_T = b_alg;
41 }
42 else // if ( FLA_Obj_col_stride( A ) == 1 )
43 {
44 rs_T = k;
45 cs_T = 1;
46 }
47
48 // Create two b_alg x k matrices to hold the block Householder transforms
49 // that will be accumulated within the bidiagonal reduction algorithm.
50 // If the matrix dimension has a zero dimension, apply_q complains it.
51 if ( TU != NULL ) FLA_Obj_create( datatype, b_alg, k, rs_T, cs_T, TU );
52 if ( TV != NULL ) FLA_Obj_create( datatype, b_alg, k, rs_T, cs_T, TV );
53
54 return FLA_SUCCESS;
55}
FLA_Obj_create
FLA_Error FLA_Obj_create(FLA_Datatype datatype, dim_t m, dim_t n, dim_t rs, dim_t cs, FLA_Obj *obj)
Definition FLA_Obj.c:55
FLA_Query_blocksize
dim_t FLA_Query_blocksize(FLA_Datatype dt, FLA_Dimension dim)
Definition FLA_Blocksize.c:161
FLA_Obj_min_dim
dim_t FLA_Obj_min_dim(FLA_Obj obj)
Definition FLA_Query.c:153
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
dim_t
unsigned long dim_t
Definition FLA_type_defs.h:71

References FLA_Obj_create(), FLA_Obj_datatype(), FLA_Obj_min_dim(), FLA_Obj_row_stride(), FLA_Query_blocksize(), and i.

Referenced by FLA_Svd_ext_u_unb_var1(), FLA_Svd_uv_unb_var1(), and FLA_Svd_uv_unb_var2().

◆ FLA_Bidiag_UT_extract_diagonals()

FLA_Error FLA_Bidiag_UT_extract_diagonals ( FLA_Obj  A,
FLA_Obj  d,
FLA_Obj  e 
)
14{
15 FLA_Error r_val = FLA_SUCCESS;
16
17 if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
18 FLA_Bidiag_UT_extract_diagonals_check( A, d, e );
19
20 if ( FLA_Obj_length( A ) >= FLA_Obj_width( A ) )
21 r_val = FLA_Bidiag_UT_u_extract_diagonals( A, d, e );
22 else
23 r_val = FLA_Bidiag_UT_l_extract_diagonals( A, d, e );
24
25 return r_val;
26}
FLA_Bidiag_UT_l_extract_diagonals
FLA_Error FLA_Bidiag_UT_l_extract_diagonals(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition FLA_Bidiag_UT_extract_diagonals.c:165
FLA_Bidiag_UT_u_extract_diagonals
FLA_Error FLA_Bidiag_UT_u_extract_diagonals(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition FLA_Bidiag_UT_extract_diagonals.c:30
FLA_Bidiag_UT_extract_diagonals_check
FLA_Error FLA_Bidiag_UT_extract_diagonals_check(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition FLA_Bidiag_UT_extract_diagonals_check.c:13
FLA_Obj_width
dim_t FLA_Obj_width(FLA_Obj obj)
Definition FLA_Query.c:123
FLA_Obj_length
dim_t FLA_Obj_length(FLA_Obj obj)
Definition FLA_Query.c:116

References FLA_Bidiag_UT_extract_diagonals_check(), FLA_Bidiag_UT_l_extract_diagonals(), FLA_Bidiag_UT_u_extract_diagonals(), FLA_Check_error_level(), FLA_Obj_length(), FLA_Obj_width(), and i.

◆ FLA_Bidiag_UT_extract_real_diagonals()

FLA_Error FLA_Bidiag_UT_extract_real_diagonals ( FLA_Obj  A,
FLA_Obj  d,
FLA_Obj  e 
)
14{
15 FLA_Error r_val = FLA_SUCCESS;
16
17 if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
18 FLA_Bidiag_UT_extract_real_diagonals_check( A, d, e );
19
20 if ( FLA_Obj_length( A ) >= FLA_Obj_width( A ) )
21 r_val = FLA_Bidiag_UT_u_extract_real_diagonals( A, d, e );
22 else
23 r_val = FLA_Bidiag_UT_l_extract_real_diagonals( A, d, e );
24
25 return r_val;
26}
FLA_Bidiag_UT_l_extract_real_diagonals
FLA_Error FLA_Bidiag_UT_l_extract_real_diagonals(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition FLA_Bidiag_UT_extract_real_diagonals.c:163
FLA_Bidiag_UT_u_extract_real_diagonals
FLA_Error FLA_Bidiag_UT_u_extract_real_diagonals(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition FLA_Bidiag_UT_extract_real_diagonals.c:28
FLA_Bidiag_UT_extract_real_diagonals_check
FLA_Error FLA_Bidiag_UT_extract_real_diagonals_check(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition FLA_Bidiag_UT_extract_real_diagonals_check.c:13

References FLA_Bidiag_UT_extract_real_diagonals_check(), FLA_Bidiag_UT_l_extract_real_diagonals(), FLA_Bidiag_UT_u_extract_real_diagonals(), FLA_Check_error_level(), FLA_Obj_length(), FLA_Obj_width(), and i.

Referenced by FLA_Svd_ext_u_unb_var1(), FLA_Svd_uv_unb_var1(), and FLA_Svd_uv_unb_var2().

◆ FLA_Bidiag_UT_form_U()

FLA_Error FLA_Bidiag_UT_form_U ( FLA_Obj  A,
FLA_Obj  T,
FLA_Obj  U 
)
14{
15 FLA_Uplo uplo;
16
17 if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
18 FLA_Bidiag_UT_form_U_check( A, T, U );
19
20 uplo = ( FLA_Obj_length( A ) >= FLA_Obj_width( A ) ?
21 FLA_UPPER_TRIANGULAR : FLA_LOWER_TRIANGULAR );
22
23 FLA_Bidiag_UT_form_U_ext( uplo, A, T,
24 FLA_NO_TRANSPOSE, U );
25
26 return FLA_SUCCESS;
27}
FLA_Bidiag_UT_form_U_ext
FLA_Error FLA_Bidiag_UT_form_U_ext(FLA_Uplo uplo, FLA_Obj A, FLA_Obj T, FLA_Trans transu, FLA_Obj U)
Definition FLA_Bidiag_UT_form_U_ext.c:13
FLA_Bidiag_UT_form_U_check
FLA_Error FLA_Bidiag_UT_form_U_check(FLA_Obj A, FLA_Obj T, FLA_Obj U)
Definition FLA_Bidiag_UT_form_U_check.c:13
FLA_Uplo
int FLA_Uplo
Definition FLA_type_defs.h:52

References FLA_Bidiag_UT_form_U_check(), FLA_Bidiag_UT_form_U_ext(), FLA_Check_error_level(), FLA_Obj_length(), FLA_Obj_width(), and i.

Referenced by FLA_Svd_uv_unb_var1(), and FLA_Svd_uv_unb_var2().

◆ FLA_Bidiag_UT_form_U_ext()

FLA_Error FLA_Bidiag_UT_form_U_ext ( FLA_Uplo  uplo,
FLA_Obj  A,
FLA_Obj  T,
FLA_Trans  transu,
FLA_Obj  U 
)
15{
16 //if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
17 // FLA_Bidiag_UT_form_U_ext_check( uplo, A, T, transu, U );
18
19 if ( transu == FLA_NO_TRANSPOSE ||
20 transu == FLA_CONJ_NO_TRANSPOSE )
21 {
22
23 if ( uplo == FLA_UPPER_TRIANGULAR )
24 {
25 FLA_QR_UT_form_Q( A, T, U );
26 }
27 else // if ( uplo == FLA_LOWER_TRIANGULAR )
28 {
29 FLA_Obj ATL, ATR,
30 ABL, ABR;
31
32 FLA_Obj UTL, UTR,
33 UBL, UBR;
34
35 FLA_Obj TL, TR;
36
37 dim_t b = ( FLA_Obj_length( A ) - 1 );
38
39 FLA_Part_1x2( T, &TL, &TR, 1, FLA_RIGHT );
40 FLA_Part_2x2( U, &UTL, &UTR,
41 &UBL, &UBR, 1, 1, FLA_TL );
42
43 if ( FLA_Obj_is( A, U ) == FALSE )
44 {
45 FLA_Set( FLA_ONE, UTL ); FLA_Set( FLA_ZERO, UTR );
46 FLA_Set( FLA_ZERO, UBL );
47
48 FLA_Part_2x2( A, &ATL, &ATR,
49 &ABL, &ABR, 1, b, FLA_TL );
50
51 FLA_QR_UT_form_Q( ABL, TL, UBR );
52 }
53 else
54 {
55 FLA_Obj p, pt, pb;
56 FLA_Part_2x2( A, &ATL, &ATR,
57 &ABL, &ABR, 1, b+1, FLA_TL );
58
59 FLA_Obj_create( FLA_INT, b+1,1, 0, 0, &p );
60 FLA_Part_2x1( p, &pt,
61 &pb, 1, FLA_BOTTOM );
62 FLA_Set( FLA_ONE, pt );
63 FLA_Set( FLA_ZERO, pb );
64 FLA_Apply_pivots ( FLA_RIGHT, FLA_NO_TRANSPOSE, p, ABL );
65 FLA_Obj_free(&p );
66
67 FLA_Set( FLA_ONE, UTL );
68 FLA_Set( FLA_ZERO, UBL );
69 FLA_Set( FLA_ZERO, UTR );
70
71 FLA_Part_1x2( ABL, &ABL,
72 &ABR, 1, FLA_LEFT );
73
74 FLA_QR_UT_form_Q( ABR, TL, UBR );
75 }
76 }
77 }
78 else
79 {
80 FLA_Uplo uplo_flip = ( uplo == FLA_UPPER_TRIANGULAR ?
81 FLA_LOWER_TRIANGULAR : FLA_UPPER_TRIANGULAR );
82
83 FLA_Obj_flip_base( &A );
84 FLA_Obj_flip_view( &A );
85
86 // A and U should have different base objects
87 FLA_Bidiag_UT_form_V_ext( uplo_flip, A, T,
88 FLA_CONJ_TRANSPOSE, U );
89
90 FLA_Obj_flip_base( &A );
91
92 // As we use QR and LQ for constructing U and V,
93 // conjugation naturally fits there.
94 // Never apply conjugation separately here even if flipping trick is applied.
95 //FLA_Conjugate( U );
96 }
97
98 return FLA_SUCCESS;
99}
FLA_Bidiag_UT_form_V_ext
FLA_Error FLA_Bidiag_UT_form_V_ext(FLA_Uplo uplo, FLA_Obj A, FLA_Obj S, FLA_Trans transv, FLA_Obj V)
Definition FLA_Bidiag_UT_form_V_ext.c:13
FLA_QR_UT_form_Q
FLA_Error FLA_QR_UT_form_Q(FLA_Obj A, FLA_Obj T, FLA_Obj Q)
Definition FLA_QR_UT_form_Q.c:13
FLA_ZERO
FLA_Obj FLA_ZERO
Definition FLA_Init.c:20
FLA_ONE
FLA_Obj FLA_ONE
Definition FLA_Init.c:18
FLA_Apply_pivots
FLA_Error FLA_Apply_pivots(FLA_Side side, FLA_Trans trans, FLA_Obj p, FLA_Obj A)
Definition FLA_Apply_pivots.c:15
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_Obj_flip_view
FLA_Error FLA_Obj_flip_view(FLA_Obj *obj)
Definition FLA_Obj.c:669
FLA_Obj_flip_base
FLA_Error FLA_Obj_flip_base(FLA_Obj *obj)
Definition FLA_Obj.c:647
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_is
FLA_Bool FLA_Obj_is(FLA_Obj A, FLA_Obj B)
Definition FLA_Query.c:460
FLA_Obj_free
FLA_Error FLA_Obj_free(FLA_Obj *obj)
Definition FLA_Obj.c:588
FLA_Set
FLA_Error FLA_Set(FLA_Obj alpha, FLA_Obj A)
Definition FLA_Set.c:13
FLA_Obj_view
Definition FLA_type_defs.h:159

References FLA_Apply_pivots(), FLA_Bidiag_UT_form_V_ext(), FLA_Obj_create(), FLA_Obj_flip_base(), FLA_Obj_flip_view(), FLA_Obj_free(), FLA_Obj_is(), FLA_Obj_length(), FLA_ONE, FLA_Part_1x2(), FLA_Part_2x1(), FLA_Part_2x2(), FLA_QR_UT_form_Q(), FLA_Set(), FLA_ZERO, and i.

Referenced by FLA_Bidiag_UT_form_U(), FLA_Bidiag_UT_form_V_ext(), and FLA_Svd_ext_u_unb_var1().

◆ FLA_Bidiag_UT_form_V()

FLA_Error FLA_Bidiag_UT_form_V ( FLA_Obj  A,
FLA_Obj  S,
FLA_Obj  V 
)
14{
15 FLA_Uplo uplo;
16
17 if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
18 FLA_Bidiag_UT_form_V_check( A, S, V );
19
20 uplo = ( FLA_Obj_length( A ) >= FLA_Obj_width( A ) ?
21 FLA_UPPER_TRIANGULAR : FLA_LOWER_TRIANGULAR );
22
23 FLA_Bidiag_UT_form_V_ext( uplo, A, S,
24 FLA_NO_TRANSPOSE, V );
25
26 return FLA_SUCCESS;
27}
FLA_Bidiag_UT_form_V_check
FLA_Error FLA_Bidiag_UT_form_V_check(FLA_Obj A, FLA_Obj T, FLA_Obj V)
Definition FLA_Bidiag_UT_form_V_check.c:13

References FLA_Bidiag_UT_form_V_check(), FLA_Bidiag_UT_form_V_ext(), FLA_Check_error_level(), FLA_Obj_length(), FLA_Obj_width(), and i.

Referenced by FLA_Svd_uv_unb_var1(), and FLA_Svd_uv_unb_var2().

◆ FLA_Bidiag_UT_form_V_ext()

FLA_Error FLA_Bidiag_UT_form_V_ext ( FLA_Uplo  uplo,
FLA_Obj  A,
FLA_Obj  S,
FLA_Trans  transv,
FLA_Obj  V 
)
15{
16 //if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
17 // FLA_Bidiag_UT_form_V_ext_check( uplo, A, S, transv, V );
18
19
20 if ( transv == FLA_TRANSPOSE ||
21 transv == FLA_CONJ_TRANSPOSE )
22 {
23 if ( uplo == FLA_UPPER_TRIANGULAR )
24 {
25 FLA_Obj ATL, ATR,
26 ABL, ABR;
27
28 FLA_Obj VTL, VTR,
29 VBL, VBR;
30
31 FLA_Obj SL, SR;
32
33 dim_t b = ( FLA_Obj_width( A ) - 1 );
34
35 FLA_Part_1x2( S, &SL, &SR, 1, FLA_RIGHT );
36 FLA_Part_2x2( V, &VTL, &VTR,
37 &VBL, &VBR, 1, 1, FLA_TL );
38
39 if ( FLA_Obj_is( A, V ) == FALSE )
40 {
41 FLA_Set( FLA_ONE, VTL ); FLA_Set( FLA_ZERO, VTR );
42 FLA_Set( FLA_ZERO, VBL );
43
44
45 FLA_Part_2x2( A, &ATL, &ATR,
46 &ABL, &ABR, b, b, FLA_TR );
47
48 FLA_LQ_UT_form_Q( ATR, SL, VBR );
49 }
50 else
51 {
52 FLA_Obj p, pt, pb;
53 FLA_Part_2x2( A, &ATL, &ATR,
54 &ABL, &ABR, b+1, b, FLA_TR );
55
56 FLA_Obj_create( FLA_INT, b+1, 1, 0, 0, &p );
57 FLA_Part_2x1( p, &pt,
58 &pb, 1, FLA_BOTTOM );
59 FLA_Set( FLA_ONE, pt );
60 FLA_Set( FLA_ZERO, pb );
61
62 FLA_Apply_pivots ( FLA_LEFT, FLA_TRANSPOSE, p, ATR );
63 FLA_Obj_free( &p );
64
65 FLA_Set( FLA_ONE, VTL );
66 FLA_Set( FLA_ZERO, VBL );
67 FLA_Set( FLA_ZERO, VTR );
68
69 FLA_Part_2x1( ATR, &ATR,
70 &ABR, 1, FLA_TOP );
71
72 FLA_LQ_UT_form_Q( ABR, SL, VBR );
73 }
74 }
75 else // if ( uplo == FLA_LOWER_TRIANGULAR )
76 {
77 FLA_LQ_UT_form_Q( A, S, V );
78 }
79 }
80 else
81 {
82 FLA_Uplo uplo_flip = ( uplo == FLA_UPPER_TRIANGULAR ?
83 FLA_LOWER_TRIANGULAR : FLA_UPPER_TRIANGULAR );
84
85 FLA_Obj_flip_base( &A );
86 FLA_Obj_flip_view( &A );
87
88 // A and U should have different base objects.
89 FLA_Bidiag_UT_form_U_ext( uplo_flip, A, S,
90 FLA_NO_TRANSPOSE, V );
91
92 FLA_Obj_flip_base( &A );
93
94 // As we use QR and LQ for constructing U and V,
95 // conjugation naturally fits there.
96 // Never apply conjugation separately here even if flipping trick is applied.
97 // FLA_Conjugate( V );
98 }
99
100 return FLA_SUCCESS;
101}
FLA_LQ_UT_form_Q
FLA_Error FLA_LQ_UT_form_Q(FLA_Obj A, FLA_Obj T, FLA_Obj Q)
Definition FLA_LQ_UT_form_Q.c:13

References FLA_Apply_pivots(), FLA_Bidiag_UT_form_U_ext(), FLA_LQ_UT_form_Q(), FLA_Obj_create(), FLA_Obj_flip_base(), FLA_Obj_flip_view(), FLA_Obj_free(), FLA_Obj_is(), FLA_Obj_width(), FLA_ONE, FLA_Part_1x2(), FLA_Part_2x1(), FLA_Part_2x2(), FLA_Set(), FLA_ZERO, and i.

Referenced by FLA_Bidiag_UT_form_U_ext(), FLA_Bidiag_UT_form_V(), and FLA_Svd_ext_u_unb_var1().

◆ FLA_Bidiag_UT_internal()

FLA_Error FLA_Bidiag_UT_internal ( FLA_Obj  A,
FLA_Obj  TU,
FLA_Obj  TV,
fla_bidiagut_t *  cntl 
)
14{
15 FLA_Error r_val = FLA_SUCCESS;
16
17 if ( FLA_Check_error_level() == FLA_FULL_ERROR_CHECKING )
18 FLA_Bidiag_UT_internal_check( A, TU, TV, cntl );
19
20 if ( FLA_Obj_length( A ) >= FLA_Obj_width( A ) )
21 {
22 r_val = FLA_Bidiag_UT_u( A, TU, TV, cntl );
23 }
24 else // if ( FLA_Obj_length( A ) < FLA_Obj_width( A ) )
25 {
26 // Flip A; swap(rs, cs), swap(m, n)
27 FLA_Obj_flip_base( &A );
28 FLA_Obj_flip_view( &A );
29
30 r_val = FLA_Bidiag_UT_u( A, TV, TU, cntl );
31
32 // Recover A; swap(rs, cs), swap(m, n)
33 FLA_Obj_flip_base( &A );
34 FLA_Obj_flip_view( &A );
35
36 // According to the UT transform, the house-holder vectors are conjugated
37 // when they are applied from the right.
38 if ( FLA_Obj_is_complex( A ) )
39 {
40 FLA_Obj ATL, ATR,
41 ABL, ABR;
42 dim_t b;
43
44 FLA_Conjugate( TU );
45 FLA_Conjugate( TV );
46
47 // U
48 b = ( FLA_Obj_length( A ) - 1 );
49 FLA_Part_2x2( A, &ATL, &ATR,
50 &ABL, &ABR, 2, b, FLA_TL );
51 FLA_Conjugate_r( FLA_LOWER_TRIANGULAR, ABL );
52
53 // V
54 b = ( FLA_Obj_width( A ) - 1 );
55 FLA_Part_1x2( A, &ATL, &ATR, b, FLA_RIGHT );
56 FLA_Conjugate_r( FLA_UPPER_TRIANGULAR, ATR );
57 }
58 }
59
60 return r_val;
61}
FLA_Bidiag_UT_u
FLA_Error FLA_Bidiag_UT_u(FLA_Obj A, FLA_Obj TU, FLA_Obj TV, fla_bidiagut_t *cntl)
Definition FLA_Bidiag_UT_u.c:13
FLA_Bidiag_UT_internal_check
FLA_Error FLA_Bidiag_UT_internal_check(FLA_Obj A, FLA_Obj TU, FLA_Obj TV, fla_bidiagut_t *cntl)
Definition FLA_Bidiag_UT_internal_check.c:13
FLA_Obj_is_complex
FLA_Bool FLA_Obj_is_complex(FLA_Obj A)
Definition FLA_Query.c:324
FLA_Conjugate_r
FLA_Error FLA_Conjugate_r(FLA_Uplo uplo, FLA_Obj A)
Definition FLA_Conjugate_r.c:13
FLA_Conjugate
FLA_Error FLA_Conjugate(FLA_Obj A)
Definition FLA_Conjugate.c:13

References FLA_Bidiag_UT_internal_check(), FLA_Bidiag_UT_u(), FLA_Check_error_level(), FLA_Conjugate(), FLA_Conjugate_r(), FLA_Obj_flip_base(), FLA_Obj_flip_view(), FLA_Obj_is_complex(), FLA_Obj_length(), FLA_Obj_width(), FLA_Part_1x2(), FLA_Part_2x2(), and i.

Referenced by FLA_Bidiag_UT().

◆ FLA_Bidiag_UT_l()

FLA_Error FLA_Bidiag_UT_l ( FLA_Obj  A,
FLA_Obj  TU,
FLA_Obj  TV,
fla_bidiagut_t *  cntl 
)

◆ FLA_Bidiag_UT_l_extract_diagonals()

FLA_Error FLA_Bidiag_UT_l_extract_diagonals ( FLA_Obj  A,
FLA_Obj  d,
FLA_Obj  e 
)
166{
167 FLA_Datatype datatype;
168 int m_A;
169 int rs_A, cs_A;
170 int inc_d;
171 int inc_e;
172 int i;
173
174 datatype = FLA_Obj_datatype( A );
175
176 m_A = FLA_Obj_length( A );
177
178 rs_A = FLA_Obj_row_stride( A );
179 cs_A = FLA_Obj_col_stride( A );
180
181 inc_d = FLA_Obj_vector_inc( d );
182
183 if ( m_A != 1 )
184 inc_e = FLA_Obj_vector_inc( e );
185 else
186 inc_e = 0;
187
188 switch ( datatype )
189 {
190 case FLA_FLOAT:
191 {
192 float* buff_A = FLA_FLOAT_PTR( A );
193 float* buff_d = FLA_FLOAT_PTR( d );
194 float* buff_e = ( m_A != 1 ? FLA_FLOAT_PTR( e ) : NULL );
195
196 for ( i = 0; i < m_A; ++i )
197 {
198 float* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
199 float* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
200 float* delta1 = buff_d + (i )*inc_d;
201 float* epsilon1 = buff_e + (i )*inc_e;
202
203 int m_ahead = m_A - i - 1;
204
205 // delta1 = alpha11;
206 *delta1 = *alpha11;
207
208 // epsilon1 = a21_t;
209 if ( m_ahead > 0 )
210 *epsilon1 = *a21_t;
211 }
212
213 break;
214 }
215
216 case FLA_DOUBLE:
217 {
218 double* buff_A = FLA_DOUBLE_PTR( A );
219 double* buff_d = FLA_DOUBLE_PTR( d );
220 double* buff_e = ( m_A != 1 ? FLA_DOUBLE_PTR( e ) : NULL );
221
222 for ( i = 0; i < m_A; ++i )
223 {
224 double* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
225 double* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
226 double* delta1 = buff_d + (i )*inc_d;
227 double* epsilon1 = buff_e + (i )*inc_e;
228
229 int m_ahead = m_A - i - 1;
230
231 // delta1 = alpha11;
232 *delta1 = *alpha11;
233
234 // epsilon1 = a21_t;
235 if ( m_ahead > 0 )
236 *epsilon1 = *a21_t;
237 }
238
239 break;
240 }
241
242 case FLA_COMPLEX:
243 {
244 scomplex* buff_A = FLA_COMPLEX_PTR( A );
245 scomplex* buff_d = FLA_COMPLEX_PTR( d );
246 scomplex* buff_e = ( m_A != 1 ? FLA_COMPLEX_PTR( e ) : NULL );
247
248 for ( i = 0; i < m_A; ++i )
249 {
250 scomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
251 scomplex* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
252 scomplex* delta1 = buff_d + (i )*inc_d;
253 scomplex* epsilon1 = buff_e + (i )*inc_e;
254
255 int m_ahead = m_A - i - 1;
256
257 // delta1 = alpha11;
258 *delta1 = *alpha11;
259
260 // epsilon1 = a21_t;
261 if ( m_ahead > 0 )
262 *epsilon1 = *a21_t;
263 }
264
265 break;
266 }
267
268 case FLA_DOUBLE_COMPLEX:
269 {
270 dcomplex* buff_A = FLA_DOUBLE_COMPLEX_PTR( A );
271 dcomplex* buff_d = FLA_DOUBLE_COMPLEX_PTR( d );
272 dcomplex* buff_e = ( m_A != 1 ? FLA_DOUBLE_COMPLEX_PTR( e ) : NULL );
273
274 for ( i = 0; i < m_A; ++i )
275 {
276 dcomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
277 dcomplex* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
278 dcomplex* delta1 = buff_d + (i )*inc_d;
279 dcomplex* epsilon1 = buff_e + (i )*inc_e;
280
281 int m_ahead = m_A - i - 1;
282
283 // delta1 = alpha11;
284 *delta1 = *alpha11;
285
286 // epsilon1 = a21_t;
287 if ( m_ahead > 0 )
288 *epsilon1 = *a21_t;
289 }
290
291 break;
292 }
293 }
294
295 return FLA_SUCCESS;
296}
FLA_Obj_col_stride
dim_t FLA_Obj_col_stride(FLA_Obj obj)
Definition FLA_Query.c:174
FLA_Obj_vector_inc
dim_t FLA_Obj_vector_inc(FLA_Obj obj)
Definition FLA_Query.c:145
dcomplex
Definition blis_type_defs.h:138
scomplex
Definition blis_type_defs.h:133

References FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_Obj_vector_inc(), and i.

Referenced by FLA_Bidiag_UT_extract_diagonals(), and FLA_Tridiag_UT_extract_diagonals().

◆ FLA_Bidiag_UT_l_extract_real_diagonals()

FLA_Error FLA_Bidiag_UT_l_extract_real_diagonals ( FLA_Obj  A,
FLA_Obj  d,
FLA_Obj  e 
)
164{
165 FLA_Datatype datatype;
166 int m_A;
167 int rs_A, cs_A;
168 int inc_d;
169 int inc_e;
170 int i;
171
172 datatype = FLA_Obj_datatype( A );
173
174 m_A = FLA_Obj_length( A );
175
176 rs_A = FLA_Obj_row_stride( A );
177 cs_A = FLA_Obj_col_stride( A );
178
179 inc_d = FLA_Obj_vector_inc( d );
180
181 if ( m_A != 1 )
182 inc_e = FLA_Obj_vector_inc( e );
183 else
184 inc_e = 0;
185
186 switch ( datatype )
187 {
188 case FLA_FLOAT:
189 {
190 float* buff_A = FLA_FLOAT_PTR( A );
191 float* buff_d = FLA_FLOAT_PTR( d );
192 float* buff_e = ( m_A != 1 ? FLA_FLOAT_PTR( e ) : NULL );
193
194 for ( i = 0; i < m_A; ++i )
195 {
196 float* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
197 float* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
198 float* delta1 = buff_d + (i )*inc_d;
199 float* epsilon1 = buff_e + (i )*inc_e;
200
201 int m_ahead = m_A - i - 1;
202
203 // delta1 = alpha11;
204 *delta1 = *alpha11;
205
206 // epsilon1 = a21_t;
207 if ( m_ahead > 0 )
208 *epsilon1 = *a21_t;
209 }
210
211 break;
212 }
213
214 case FLA_DOUBLE:
215 {
216 double* buff_A = FLA_DOUBLE_PTR( A );
217 double* buff_d = FLA_DOUBLE_PTR( d );
218 double* buff_e = ( m_A != 1 ? FLA_DOUBLE_PTR( e ) : NULL );
219
220 for ( i = 0; i < m_A; ++i )
221 {
222 double* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
223 double* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
224 double* delta1 = buff_d + (i )*inc_d;
225 double* epsilon1 = buff_e + (i )*inc_e;
226
227 int m_ahead = m_A - i - 1;
228
229 // delta1 = alpha11;
230 *delta1 = *alpha11;
231
232 // epsilon1 = a21_t;
233 if ( m_ahead > 0 )
234 *epsilon1 = *a21_t;
235 }
236
237 break;
238 }
239
240 case FLA_COMPLEX:
241 {
242 scomplex* buff_A = FLA_COMPLEX_PTR( A );
243 float* buff_d = FLA_FLOAT_PTR( d );
244 float* buff_e = ( m_A != 1 ? FLA_FLOAT_PTR( e ) : NULL );
245
246 for ( i = 0; i < m_A; ++i )
247 {
248 scomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
249 scomplex* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
250 float* delta1 = buff_d + (i )*inc_d;
251 float* epsilon1 = buff_e + (i )*inc_e;
252
253 int m_ahead = m_A - i - 1;
254
255 // delta1 = alpha11;
256 *delta1 = alpha11->real;
257
258 // epsilon1 = a21_t;
259 if ( m_ahead > 0 )
260 *epsilon1 = a21_t->real;
261 }
262
263 break;
264 }
265
266 case FLA_DOUBLE_COMPLEX:
267 {
268 dcomplex* buff_A = FLA_DOUBLE_COMPLEX_PTR( A );
269 double* buff_d = FLA_DOUBLE_PTR( d );
270 double* buff_e = ( m_A != 1 ? FLA_DOUBLE_PTR( e ) : NULL );
271
272 for ( i = 0; i < m_A; ++i )
273 {
274 dcomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
275 dcomplex* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
276 double* delta1 = buff_d + (i )*inc_d;
277 double* epsilon1 = buff_e + (i )*inc_e;
278
279 int m_ahead = m_A - i - 1;
280
281 // delta1 = alpha11;
282 *delta1 = alpha11->real;
283
284 // epsilon1 = a21_t;
285 if ( m_ahead > 0 )
286 *epsilon1 = a21_t->real;
287 }
288
289 break;
290 }
291 }
292
293 return FLA_SUCCESS;
294}
dcomplex::real
double real
Definition blis_type_defs.h:139
scomplex::real
float real
Definition blis_type_defs.h:134

References FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_Obj_vector_inc(), i, scomplex::real, and dcomplex::real.

Referenced by FLA_Bidiag_UT_extract_real_diagonals(), and FLA_Tridiag_UT_extract_real_diagonals().

◆ FLA_Bidiag_UT_l_realify_opt()

FLA_Error FLA_Bidiag_UT_l_realify_opt ( FLA_Obj  A,
FLA_Obj  d,
FLA_Obj  e 
)
160{
161 FLA_Datatype datatype;
162 int m_A, n_A;
163 int min_m_n;
164 int rs_A, cs_A;
165 int inc_d;
166 int inc_e;
167 int i;
168
169 datatype = FLA_Obj_datatype( A );
170
171 m_A = FLA_Obj_length( A );
172 n_A = FLA_Obj_width( A );
173 min_m_n = FLA_Obj_min_dim( A );
174
175 rs_A = FLA_Obj_row_stride( A );
176 cs_A = FLA_Obj_col_stride( A );
177
178 inc_d = FLA_Obj_vector_inc( d );
179
180 inc_e = FLA_Obj_vector_inc( e );
181
182
183 switch ( datatype )
184 {
185 case FLA_FLOAT:
186 {
187 float* buff_d = FLA_FLOAT_PTR( d );
188 float* buff_e = FLA_FLOAT_PTR( e );
189 float* buff_1 = FLA_FLOAT_PTR( FLA_ONE );
190
191 bl1_ssetv( min_m_n,
192 buff_1,
193 buff_d, inc_d );
194
195 bl1_ssetv( min_m_n,
196 buff_1,
197 buff_e, inc_e );
198
199 break;
200 }
201
202 case FLA_DOUBLE:
203 {
204 double* buff_d = FLA_DOUBLE_PTR( d );
205 double* buff_e = FLA_DOUBLE_PTR( e );
206 double* buff_1 = FLA_DOUBLE_PTR( FLA_ONE );
207
208 bl1_dsetv( min_m_n,
209 buff_1,
210 buff_d, inc_d );
211
212 bl1_dsetv( min_m_n,
213 buff_1,
214 buff_e, inc_e );
215
216 break;
217 }
218
219 case FLA_COMPLEX:
220 {
221 scomplex* buff_A = FLA_COMPLEX_PTR( A );
222 scomplex* buff_d = FLA_COMPLEX_PTR( d );
223 scomplex* buff_e = FLA_COMPLEX_PTR( e );
224 scomplex* buff_1 = FLA_COMPLEX_PTR( FLA_ONE );
225 float* buff_0 = FLA_FLOAT_PTR( FLA_ZERO );
226
227 for ( i = 0; i < min_m_n; ++i )
228 {
229
230 scomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
231 scomplex* delta1 = buff_d + (i )*inc_d;
232 scomplex* epsilon1 = buff_e + (i )*inc_e;
233 scomplex absv;
234
235 int m_ahead = m_A - i - 1;
236 int m_behind = i;
237
238 if ( m_behind == 0 )
239 {
240 // FLA_Set( FLA_ONE, delta1 );
241 *delta1 = *buff_1;
242 }
243 else
244 {
245 scomplex* a10t_r = buff_A + (i-1)*cs_A + (i )*rs_A;
246 // FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, a10t_r, delta1 );
247 // FLA_Copyt( FLA_NO_TRANSPOSE, a10t_r, absv );
248 // FLA_Absolute_value( absv );
249 // FLA_Inv_scal( absv, delta1 );
250 bl1_ccopys( BLIS1_CONJUGATE, a10t_r, delta1 );
251 bl1_cabsval2( a10t_r, &absv );
252 bl1_cinvscals( &absv, delta1 );
253
254 // FLA_Scalc( FLA_NO_CONJUGATE, delta1, a10t_r );
255 // FLA_Obj_set_imag_part( FLA_ZERO, a10t_r );
256 bl1_cscals( delta1, a10t_r );
257 a10t_r->imag = *buff_0;
258
259 // FLA_Scalc( FLA_NO_CONJUGATE, delta1, alpha11 );
260 bl1_cscals( delta1, alpha11 );
261 }
262
263 // FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, alpha11, epsilon1 );
264 // FLA_Copyt( FLA_NO_TRANSPOSE, alpha11, absv );
265 // FLA_Absolute_value( absv );
266 // FLA_Inv_scal( absv, epsilon1 );
267 bl1_ccopys( BLIS1_CONJUGATE, alpha11, epsilon1 );
268 bl1_cabsval2( alpha11, &absv );
269 bl1_cinvscals( &absv, epsilon1 );
270
271 // FLA_Scalc( FLA_NO_CONJUGATE, epsilon1, alpha11 );
272 // FLA_Obj_set_imag_part( FLA_ZERO, alpha11 );
273 bl1_cscals( epsilon1, alpha11 );
274 alpha11->imag = *buff_0;
275
276 if ( m_ahead > 0 )
277 {
278 scomplex* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
279 // FLA_Scalc( FLA_NO_CONJUGATE, epsilon1, a21_t );
280 bl1_cscals( epsilon1, a21_t );
281 }
282 }
283
284 break;
285 }
286
287 case FLA_DOUBLE_COMPLEX:
288 {
289 dcomplex* buff_A = FLA_DOUBLE_COMPLEX_PTR( A );
290 dcomplex* buff_d = FLA_DOUBLE_COMPLEX_PTR( d );
291 dcomplex* buff_e = FLA_DOUBLE_COMPLEX_PTR( e );
292 dcomplex* buff_1 = FLA_DOUBLE_COMPLEX_PTR( FLA_ONE );
293 double* buff_0 = FLA_DOUBLE_PTR( FLA_ZERO );
294
295 for ( i = 0; i < min_m_n; ++i )
296 {
297
298 dcomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
299 dcomplex* delta1 = buff_d + (i )*inc_d;
300 dcomplex* epsilon1 = buff_e + (i )*inc_e;
301 dcomplex absv;
302
303 int m_ahead = m_A - i - 1;
304 int m_behind = i;
305
306 if ( m_behind == 0 )
307 {
308 // FLA_Set( FLA_ONE, delta1 );
309 *delta1 = *buff_1;
310 }
311 else
312 {
313 dcomplex* a10t_r = buff_A + (i-1)*cs_A + (i )*rs_A;
314 // FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, a10t_r, delta1 );
315 // FLA_Copyt( FLA_NO_TRANSPOSE, a10t_r, absv );
316 // FLA_Absolute_value( absv );
317 // FLA_Inv_scal( absv, delta1 );
318 bl1_zcopys( BLIS1_CONJUGATE, a10t_r, delta1 );
319 bl1_zabsval2( a10t_r, &absv );
320 bl1_zinvscals( &absv, delta1 );
321
322 // FLA_Scalc( FLA_NO_CONJUGATE, delta1, a10t_r );
323 // FLA_Obj_set_imag_part( FLA_ZERO, a10t_r );
324 bl1_zscals( delta1, a10t_r );
325 a10t_r->imag = *buff_0;
326
327 // FLA_Scalc( FLA_NO_CONJUGATE, delta1, alpha11 );
328 bl1_zscals( delta1, alpha11 );
329 }
330
331 // FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, alpha11, epsilon1 );
332 // FLA_Copyt( FLA_NO_TRANSPOSE, alpha11, absv );
333 // FLA_Absolute_value( absv );
334 // FLA_Inv_scal( absv, epsilon1 );
335 bl1_zcopys( BLIS1_CONJUGATE, alpha11, epsilon1 );
336 bl1_zabsval2( alpha11, &absv );
337 bl1_zinvscals( &absv, epsilon1 );
338
339 // FLA_Scalc( FLA_NO_CONJUGATE, epsilon1, alpha11 );
340 // FLA_Obj_set_imag_part( FLA_ZERO, alpha11 );
341 bl1_zscals( epsilon1, alpha11 );
342 alpha11->imag = *buff_0;
343
344 if ( m_ahead > 0 )
345 {
346 dcomplex* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
347 // FLA_Scalc( FLA_NO_CONJUGATE, epsilon1, a21_t );
348 bl1_zscals( epsilon1, a21_t );
349 }
350 }
351
352 break;
353 }
354 }
355
356 return FLA_SUCCESS;
357}
bl1_zscals
bl1_zscals(beta, rho_yz)
bl1_dsetv
void bl1_dsetv(int m, double *sigma, double *x, int incx)
Definition bl1_setv.c:39
bl1_ssetv
void bl1_ssetv(int m, float *sigma, float *x, int incx)
Definition bl1_setv.c:26
BLIS1_CONJUGATE
@ BLIS1_CONJUGATE
Definition blis_type_defs.h:82

References bl1_dsetv(), bl1_ssetv(), bl1_zscals(), BLIS1_CONJUGATE, FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_min_dim(), FLA_Obj_row_stride(), FLA_Obj_vector_inc(), FLA_Obj_width(), FLA_ONE, FLA_ZERO, and i.

Referenced by FLA_Bidiag_UT_realify().

◆ FLA_Bidiag_UT_l_realify_unb()

FLA_Error FLA_Bidiag_UT_l_realify_unb ( FLA_Obj  A,
FLA_Obj  d,
FLA_Obj  e 
)
39{
40 FLA_Obj ATL, ATR, A00, a01, A02,
41 ABL, ABR, a10t, alpha11, a12t,
42 A20, a21, A22;
43
44 FLA_Obj dT, d0,
45 dB, delta1,
46 d2;
47
48 FLA_Obj eT, e0,
49 eB, epsilon1,
50 e2;
51
52 FLA_Obj a10t_l, a10t_r;
53
54 FLA_Obj a21_t,
55 a21_b;
56
57 FLA_Obj absv;
58
59
60 FLA_Obj_create( FLA_Obj_datatype( A ), 1, 1, 0, 0, &absv );
61
62 FLA_Part_2x2( A, &ATL, &ATR,
63 &ABL, &ABR, 0, 0, FLA_TL );
64
65 FLA_Part_2x1( d, &dT,
66 &dB, 0, FLA_TOP );
67
68 FLA_Part_2x1( e, &eT,
69 &eB, 0, FLA_TOP );
70
71 while ( FLA_Obj_min_dim( ABR ) > 0 )
72 {
73 FLA_Repart_2x2_to_3x3( ATL, /**/ ATR, &A00, /**/ &a01, &A02,
74 /* ************* */ /* ************************** */
75 &a10t, /**/ &alpha11, &a12t,
76 ABL, /**/ ABR, &A20, /**/ &a21, &A22,
77 1, 1, FLA_BR );
78
79 FLA_Repart_2x1_to_3x1( dT, &d0,
80 /* ** */ /* ****** */
81 &delta1,
82 dB, &d2, 1, FLA_BOTTOM );
83
84 FLA_Repart_2x1_to_3x1( eT, &e0,
85 /* ** */ /* ******** */
86 &epsilon1,
87 eB, &e2, 1, FLA_BOTTOM );
88
89 /*------------------------------------------------------------*/
90
91 if ( FLA_Obj_width( a10t ) == 0 )
92 {
93 // delta1 = 1;
94 FLA_Set( FLA_ONE, delta1 );
95 }
96 else
97 {
98 FLA_Part_1x2( a10t, &a10t_l, &a10t_r, 1, FLA_RIGHT );
99
100 // delta1 = conj(a10t_r) / abs(a10t_r);
101 FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, a10t_r, delta1 );
102 FLA_Copyt( FLA_NO_TRANSPOSE, a10t_r, absv );
103 FLA_Absolute_value( absv );
104 FLA_Inv_scal( absv, delta1 );
105
106 // a10t_r = delta1 * a10t_r;
107 // a10t_r.imag = 0;
108 FLA_Scalc( FLA_NO_CONJUGATE, delta1, a10t_r );
109 FLA_Obj_set_imag_part( FLA_ZERO, a10t_r );
110
111 // alpha11 = delta1 * alpha11;
112 FLA_Scalc( FLA_NO_CONJUGATE, delta1, alpha11 );
113 }
114
115 // epsilon1 = conj(alpha11) / abs(alpha11);
116 FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, alpha11, epsilon1 );
117 FLA_Copyt( FLA_NO_TRANSPOSE, alpha11, absv );
118 FLA_Absolute_value( absv );
119 FLA_Inv_scal( absv, epsilon1 );
120
121 // alpha11 = epsilon1 * alpha11;
122 // alpha11.imag = 0;
123 FLA_Scalc( FLA_NO_CONJUGATE, epsilon1, alpha11 );
124 FLA_Obj_set_imag_part( FLA_ZERO, alpha11 );
125
126 if ( FLA_Obj_length( a21 ) > 0 )
127 {
128 FLA_Part_2x1( a21, &a21_t,
129 &a21_b, 1, FLA_TOP );
130
131 // a21_t = epsilon1 * a21_t;
132 FLA_Scalc( FLA_NO_CONJUGATE, epsilon1, a21_t );
133 }
134
135 /*------------------------------------------------------------*/
136
137 FLA_Cont_with_3x3_to_2x2( &ATL, /**/ &ATR, A00, a01, /**/ A02,
138 a10t, alpha11, /**/ a12t,
139 /* ************** */ /* ************************ */
140 &ABL, /**/ &ABR, A20, a21, /**/ A22,
141 FLA_TL );
142
143 FLA_Cont_with_3x1_to_2x1( &dT, d0,
144 delta1,
145 /* ** */ /* ****** */
146 &dB, d2, FLA_TOP );
147
148 FLA_Cont_with_3x1_to_2x1( &eT, e0,
149 epsilon1,
150 /* ** */ /* ******** */
151 &eB, e2, FLA_TOP );
152 }
153
154 FLA_Obj_free( &absv );
155
156 return FLA_SUCCESS;
157}
FLA_Scalc
FLA_Error FLA_Scalc(FLA_Conj conjalpha, FLA_Obj alpha, FLA_Obj A)
Definition FLA_Scalc.c:13
FLA_Inv_scal
FLA_Error FLA_Inv_scal(FLA_Obj alpha, FLA_Obj A)
Definition FLA_Inv_scal.c:13
FLA_Copyt
FLA_Error FLA_Copyt(FLA_Trans trans, FLA_Obj A, FLA_Obj B)
Definition FLA_Copyt.c:15
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_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_Obj_set_imag_part
void FLA_Obj_set_imag_part(FLA_Obj alpha, FLA_Obj beta)
Definition FLA_Misc.c:229
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_Absolute_value
FLA_Error FLA_Absolute_value(FLA_Obj alpha)
Definition FLA_Absolute_value.c:13

References FLA_Absolute_value(), FLA_Cont_with_3x1_to_2x1(), FLA_Cont_with_3x3_to_2x2(), FLA_Copyt(), FLA_Inv_scal(), FLA_Obj_create(), FLA_Obj_datatype(), FLA_Obj_free(), FLA_Obj_length(), FLA_Obj_min_dim(), FLA_Obj_set_imag_part(), FLA_Obj_width(), FLA_ONE, FLA_Part_1x2(), FLA_Part_2x1(), FLA_Part_2x2(), FLA_Repart_2x1_to_3x1(), FLA_Repart_2x2_to_3x3(), FLA_Scalc(), FLA_Set(), FLA_ZERO, and i.

◆ FLA_Bidiag_UT_l_scale_diagonals()

FLA_Error FLA_Bidiag_UT_l_scale_diagonals ( FLA_Obj  alpha,
FLA_Obj  A 
)
127{
128 FLA_Datatype datatype;
129 int m_A;
130 int rs_A, cs_A;
131 int i;
132
133 datatype = FLA_Obj_datatype( A );
134
135 m_A = FLA_Obj_length( A );
136
137 rs_A = FLA_Obj_row_stride( A );
138 cs_A = FLA_Obj_col_stride( A );
139
140 switch ( datatype )
141 {
142 case FLA_FLOAT:
143 {
144 float* buff_A = FLA_FLOAT_PTR( A );
145 float* buff_alpha = FLA_FLOAT_PTR( alpha );
146 for ( i = 0; i < m_A; ++i )
147 {
148 float* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
149 float* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
150 int m_ahead = m_A - i - 1;
151
152 bl1_sscals( buff_alpha, alpha11 );
153
154 if ( m_ahead > 0 )
155 bl1_sscals( buff_alpha, a21_t );
156 }
157
158 break;
159 }
160
161 case FLA_DOUBLE:
162 {
163 double* buff_A = FLA_DOUBLE_PTR( A );
164 double* buff_alpha = FLA_DOUBLE_PTR( alpha );
165 for ( i = 0; i < m_A; ++i )
166 {
167 double* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
168 double* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
169 int m_ahead = m_A - i - 1;
170
171 bl1_dscals( buff_alpha, alpha11 );
172
173 if ( m_ahead > 0 )
174 bl1_dscals( buff_alpha, a21_t );
175 }
176
177 break;
178 }
179
180 case FLA_COMPLEX:
181 {
182 scomplex* buff_A = FLA_COMPLEX_PTR( A );
183 float* buff_alpha = FLA_FLOAT_PTR( alpha );
184 for ( i = 0; i < m_A; ++i )
185 {
186 scomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
187 scomplex* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
188 int m_ahead = m_A - i - 1;
189
190 bl1_csscals( buff_alpha, alpha11 );
191
192 if ( m_ahead > 0 )
193 bl1_csscals( buff_alpha, a21_t );
194 }
195
196 break;
197 }
198
199 case FLA_DOUBLE_COMPLEX:
200 {
201 dcomplex* buff_A = FLA_DOUBLE_COMPLEX_PTR( A );
202 double* buff_alpha = FLA_DOUBLE_PTR( alpha );
203 for ( i = 0; i < m_A; ++i )
204 {
205 dcomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
206 dcomplex* a21_t = buff_A + (i )*cs_A + (i+1)*rs_A;
207 int m_ahead = m_A - i - 1;
208
209 bl1_zdscals( buff_alpha, alpha11 );
210
211 if ( m_ahead > 0 )
212 bl1_zdscals( buff_alpha, a21_t );
213 }
214
215 break;
216 }
217 }
218
219 return FLA_SUCCESS;
220}

References FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_row_stride(), and i.

Referenced by FLA_Bidiag_UT_scale_diagonals(), and FLA_Tridiag_UT_scale_diagonals().

◆ FLA_Bidiag_UT_realify()

FLA_Error FLA_Bidiag_UT_realify ( FLA_Obj  A,
FLA_Obj  d,
FLA_Obj  e 
)
14{
15 FLA_Error r_val = FLA_SUCCESS;
16
17 if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
18 FLA_Bidiag_UT_realify_check( A, d, e );
19
20 if ( FLA_Obj_is_real( A ) )
21 {
22 FLA_Set( FLA_ONE, d );
23 FLA_Set( FLA_ONE, e );
24 return FLA_SUCCESS;
25 }
26
27 if ( FLA_Obj_length( A ) < FLA_Obj_width( A ) )
28 //r_val = FLA_Bidiag_UT_l_realify_unb( A, d, e );
29 r_val = FLA_Bidiag_UT_l_realify_opt( A, d, e );
30 else
31 //r_val = FLA_Bidiag_UT_u_realify_unb( A, d, e );
32 r_val = FLA_Bidiag_UT_u_realify_opt( A, d, e );
33
34 return r_val;
35}
FLA_Bidiag_UT_u_realify_opt
FLA_Error FLA_Bidiag_UT_u_realify_opt(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition FLA_Bidiag_UT_realify.c:482
FLA_Bidiag_UT_l_realify_opt
FLA_Error FLA_Bidiag_UT_l_realify_opt(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition FLA_Bidiag_UT_realify.c:159
FLA_Bidiag_UT_realify_check
FLA_Error FLA_Bidiag_UT_realify_check(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition FLA_Bidiag_UT_realify_check.c:13
FLA_Obj_is_real
FLA_Bool FLA_Obj_is_real(FLA_Obj A)
Definition FLA_Query.c:307

References FLA_Bidiag_UT_l_realify_opt(), FLA_Bidiag_UT_realify_check(), FLA_Bidiag_UT_u_realify_opt(), FLA_Check_error_level(), FLA_Obj_is_real(), FLA_Obj_length(), FLA_Obj_width(), FLA_ONE, FLA_Set(), and i.

Referenced by FLA_Svd_ext_u_unb_var1(), FLA_Svd_uv_unb_var1(), and FLA_Svd_uv_unb_var2().

◆ FLA_Bidiag_UT_realify_diagonals()

FLA_Error FLA_Bidiag_UT_realify_diagonals ( FLA_Uplo  uplo,
FLA_Obj  a,
FLA_Obj  b,
FLA_Obj  d,
FLA_Obj  e 
)
14{
15 FLA_Error r_val = FLA_SUCCESS;
16
17 if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
18 FLA_Bidiag_UT_realify_diagonals_check( uplo, a, b, d, e );
19
20 if ( uplo == FLA_LOWER_TRIANGULAR )
21 r_val = FLA_Bidiag_UT_realify_diagonals_opt( a, b, d, e );
22 else
23 r_val = FLA_Bidiag_UT_realify_diagonals_opt( a, b, e, d );
24
25 return r_val;
26}
FLA_Bidiag_UT_realify_diagonals_opt
FLA_Error FLA_Bidiag_UT_realify_diagonals_opt(FLA_Obj a, FLA_Obj b, FLA_Obj d, FLA_Obj e)
Definition FLA_Bidiag_UT_realify_diagonals.c:28
FLA_Bidiag_UT_realify_diagonals_check
FLA_Error FLA_Bidiag_UT_realify_diagonals_check(FLA_Uplo uplo, FLA_Obj a, FLA_Obj b, FLA_Obj d, FLA_Obj e)
Definition FLA_Bidiag_UT_realify_diagonals_check.c:13

References FLA_Bidiag_UT_realify_diagonals_check(), FLA_Bidiag_UT_realify_diagonals_opt(), FLA_Check_error_level(), and i.

◆ FLA_Bidiag_UT_realify_diagonals_opt()

FLA_Error FLA_Bidiag_UT_realify_diagonals_opt ( FLA_Obj  a,
FLA_Obj  b,
FLA_Obj  d,
FLA_Obj  e 
)
29{
30 FLA_Datatype datatype;
31 int i, m, inc_a, inc_b, inc_d, inc_e;
32
33 datatype = FLA_Obj_datatype( a );
34
35 m = FLA_Obj_vector_dim( a );
36
37 inc_a = FLA_Obj_vector_inc( a );
38 inc_b = ( m > 1 ? FLA_Obj_vector_inc( b ) : 0 );
39
40 inc_d = FLA_Obj_vector_inc( d );
41 inc_e = FLA_Obj_vector_inc( e );
42
43 switch ( datatype )
44 {
45 case FLA_FLOAT:
46 {
47 float* buff_d = FLA_FLOAT_PTR( d );
48 float* buff_e = FLA_FLOAT_PTR( e );
49 float* buff_1 = FLA_FLOAT_PTR( FLA_ONE );
50
51 bl1_ssetv( m,
52 buff_1,
53 buff_d, inc_d );
54
55 bl1_ssetv( m,
56 buff_1,
57 buff_e, inc_e );
58
59 break;
60 }
61 case FLA_DOUBLE:
62 {
63 double* buff_d = FLA_DOUBLE_PTR( d );
64 double* buff_e = FLA_DOUBLE_PTR( e );
65 double* buff_1 = FLA_DOUBLE_PTR( FLA_ONE );
66
67 bl1_dsetv( m,
68 buff_1,
69 buff_d, inc_d );
70
71 bl1_dsetv( m,
72 buff_1,
73 buff_e, inc_e );
74
75 break;
76 }
77 case FLA_COMPLEX:
78 {
79 scomplex* buff_a = FLA_COMPLEX_PTR( a );
80 scomplex* buff_b = ( m > 1 ? FLA_COMPLEX_PTR( b ) : NULL );
81 scomplex* buff_d = FLA_COMPLEX_PTR( d );
82 scomplex* buff_e = FLA_COMPLEX_PTR( e );
83 scomplex* buff_1 = FLA_COMPLEX_PTR( FLA_ONE );
84 float* buff_0 = FLA_FLOAT_PTR( FLA_ZERO );
85
86 for ( i = 0; i < m; ++i )
87 {
88 scomplex* alpha1 = buff_a + (i )*inc_a;
89 scomplex* delta1 = buff_d + (i )*inc_d;
90 scomplex* epsilon1 = buff_e + (i )*inc_e;
91
92 scomplex absv;
93
94 if ( i == 0 )
95 {
96 *delta1 = *buff_1;
97 }
98 else
99 {
100 scomplex* beta1 = buff_b + (i-1)*inc_b;
101 if ( beta1->imag == 0.0F )
102 *delta1 = *buff_1;
103 else
104 {
105 bl1_ccopys( BLIS1_CONJUGATE, beta1, delta1 );
106 bl1_cabsval2( beta1, &absv );
107 bl1_cinvscals( &absv, delta1 );
108
109 bl1_cscals( delta1, beta1 );
110 beta1->imag = *buff_0;
111
112 bl1_cscals( delta1, alpha1 );
113 }
114 }
115
116 if ( alpha1->imag == 0.0F )
117 *epsilon1 = *buff_1;
118 else
119 {
120 bl1_ccopys( BLIS1_CONJUGATE, alpha1, epsilon1 );
121 bl1_cabsval2( alpha1, &absv );
122 bl1_cinvscals( &absv, epsilon1 );
123
124 bl1_cscals( epsilon1, alpha1 );
125 alpha1->imag = *buff_0;
126 }
127
128 if ( i < ( m - 1 ) )
129 {
130 scomplex* beta2 = buff_b + (i )*inc_b;
131 bl1_cscals( epsilon1, beta2 );
132 }
133 }
134 break;
135 }
136 case FLA_DOUBLE_COMPLEX:
137 {
138 dcomplex* buff_a = FLA_DOUBLE_COMPLEX_PTR( a );
139 dcomplex* buff_b = ( m > 1 ? FLA_DOUBLE_COMPLEX_PTR( b ) : NULL );
140 dcomplex* buff_d = FLA_DOUBLE_COMPLEX_PTR( d );
141 dcomplex* buff_e = FLA_DOUBLE_COMPLEX_PTR( e );
142 dcomplex* buff_1 = FLA_DOUBLE_COMPLEX_PTR( FLA_ONE );
143 double* buff_0 = FLA_DOUBLE_PTR( FLA_ZERO );
144
145 for ( i = 0; i < m; ++i )
146 {
147 dcomplex* alpha1 = buff_a + (i )*inc_a;
148 dcomplex* delta1 = buff_d + (i )*inc_d;
149 dcomplex* epsilon1 = buff_e + (i )*inc_e;
150
151 dcomplex absv;
152
153 if ( i == 0 )
154 {
155 *delta1 = *buff_1;
156 }
157 else
158 {
159 dcomplex* beta1 = buff_b + (i-1)*inc_b;
160 bl1_zcopys( BLIS1_CONJUGATE, beta1, delta1 );
161 bl1_zabsval2( beta1, &absv );
162 bl1_zinvscals( &absv, delta1 );
163
164 bl1_zscals( delta1, beta1 );
165 beta1->imag = *buff_0;
166
167 bl1_zscals( delta1, alpha1 );
168 }
169
170 bl1_zcopys( BLIS1_CONJUGATE, alpha1, epsilon1 );
171 bl1_zabsval2( alpha1, &absv );
172 bl1_zinvscals( &absv, epsilon1 );
173
174 bl1_zscals( epsilon1, alpha1 );
175 alpha1->imag = *buff_0;
176
177 if ( i < ( m - 1 ) )
178 {
179 dcomplex* beta2 = buff_b + (i )*inc_b;
180 bl1_zscals( epsilon1, beta2 );
181 }
182 }
183 break;
184 }
185 }
186 return FLA_SUCCESS;
187}
FLA_Obj_vector_dim
dim_t FLA_Obj_vector_dim(FLA_Obj obj)
Definition FLA_Query.c:137
alpha1
double *restrict alpha1
Definition bl1_axpyv2bdotaxpy.c:198

References alpha1, bl1_dsetv(), bl1_ssetv(), bl1_zscals(), BLIS1_CONJUGATE, FLA_Obj_datatype(), FLA_Obj_vector_dim(), FLA_Obj_vector_inc(), FLA_ONE, FLA_ZERO, and i.

Referenced by FLA_Bidiag_UT_realify_diagonals().

◆ FLA_Bidiag_UT_recover_tau()

FLA_Error FLA_Bidiag_UT_recover_tau ( FLA_Obj  TU,
FLA_Obj  TV,
FLA_Obj  tu,
FLA_Obj  tv 
)
17{
18 if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
19 FLA_Bidiag_UT_recover_tau_check( TU, TV, tu, tv );
20
21 FLA_Bidiag_UT_recover_tau_panel( TU, tu );
22 FLA_Bidiag_UT_recover_tau_panel( TV, tv );
23
24 return FLA_SUCCESS;
25}
FLA_Bidiag_UT_recover_tau_panel
FLA_Error FLA_Bidiag_UT_recover_tau_panel(FLA_Obj T, FLA_Obj t)
Definition FLA_Bidiag_UT_recover_tau.c:27
FLA_Bidiag_UT_recover_tau_check
FLA_Error FLA_Bidiag_UT_recover_tau_check(FLA_Obj TU, FLA_Obj TV, FLA_Obj tu, FLA_Obj tv)
Definition FLA_Bidiag_UT_recover_tau_check.c:13

References FLA_Bidiag_UT_recover_tau_check(), FLA_Bidiag_UT_recover_tau_panel(), FLA_Check_error_level(), and i.

◆ FLA_Bidiag_UT_scale_diagonals()

FLA_Error FLA_Bidiag_UT_scale_diagonals ( FLA_Obj  alpha,
FLA_Obj  A 
)
14{
15 FLA_Error r_val = FLA_SUCCESS;
16
17 if ( FLA_Check_error_level() >= FLA_MIN_ERROR_CHECKING )
18 FLA_Bidiag_UT_scale_diagonals_check( alpha, A );
19
20 if ( FLA_Obj_length( A ) >= FLA_Obj_width( A ) )
21 r_val = FLA_Bidiag_UT_u_scale_diagonals( alpha, A );
22 else
23 r_val = FLA_Bidiag_UT_l_scale_diagonals( alpha, A );
24
25 return r_val;
26}
FLA_Bidiag_UT_u_scale_diagonals
FLA_Error FLA_Bidiag_UT_u_scale_diagonals(FLA_Obj alpha, FLA_Obj A)
Definition FLA_Bidiag_UT_scale_diagonals.c:30
FLA_Bidiag_UT_l_scale_diagonals
FLA_Error FLA_Bidiag_UT_l_scale_diagonals(FLA_Obj alpha, FLA_Obj A)
Definition FLA_Bidiag_UT_scale_diagonals.c:126
FLA_Bidiag_UT_scale_diagonals_check
FLA_Error FLA_Bidiag_UT_scale_diagonals_check(FLA_Obj alpha, FLA_Obj A)
Definition FLA_Bidiag_UT_scale_diagonals_check.c:13

References FLA_Bidiag_UT_l_scale_diagonals(), FLA_Bidiag_UT_scale_diagonals_check(), FLA_Bidiag_UT_u_scale_diagonals(), FLA_Check_error_level(), FLA_Obj_length(), FLA_Obj_width(), and i.

◆ FLA_Bidiag_UT_u()

FLA_Error FLA_Bidiag_UT_u ( FLA_Obj  A,
FLA_Obj  TU,
FLA_Obj  TV,
fla_bidiagut_t *  cntl 
)
14{
15 FLA_Error r_val = FLA_SUCCESS;
16
17 if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT1 )
18 {
19 r_val = FLA_Bidiag_UT_u_unb_var1( A, TU, TV );
20 }
21 else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT2 )
22 {
23 r_val = FLA_Bidiag_UT_u_unb_var2( A, TU, TV );
24 }
25 else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT3 )
26 {
27 r_val = FLA_Bidiag_UT_u_unb_var3( A, TU, TV );
28 }
29 else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT4 )
30 {
31 r_val = FLA_Bidiag_UT_u_unb_var4( A, TU, TV );
32 }
33 else if ( FLA_Cntl_variant( cntl ) == FLA_UNBLOCKED_VARIANT5 )
34 {
35 r_val = FLA_Bidiag_UT_u_unb_var5( A, TU, TV );
36 }
37 else if ( FLA_Cntl_variant( cntl ) == FLA_UNB_OPT_VARIANT1 )
38 {
39 r_val = FLA_Bidiag_UT_u_opt_var1( A, TU, TV );
40 }
41 else if ( FLA_Cntl_variant( cntl ) == FLA_UNB_OPT_VARIANT2 )
42 {
43 r_val = FLA_Bidiag_UT_u_opt_var2( A, TU, TV );
44 }
45 else if ( FLA_Cntl_variant( cntl ) == FLA_UNB_OPT_VARIANT3 )
46 {
47 r_val = FLA_Bidiag_UT_u_opt_var3( A, TU, TV );
48 }
49 else if ( FLA_Cntl_variant( cntl ) == FLA_UNB_OPT_VARIANT4 )
50 {
51 r_val = FLA_Bidiag_UT_u_opt_var4( A, TU, TV );
52 }
53 else if ( FLA_Cntl_variant( cntl ) == FLA_UNB_OPT_VARIANT5 )
54 {
55 r_val = FLA_Bidiag_UT_u_opt_var5( A, TU, TV );
56 }
57 else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT1 )
58 {
59 r_val = FLA_Bidiag_UT_u_blk_var1( A, TU, TV );
60 }
61 else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT2 )
62 {
63 r_val = FLA_Bidiag_UT_u_blk_var2( A, TU, TV );
64 }
65 else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT3 )
66 {
67 r_val = FLA_Bidiag_UT_u_blk_var3( A, TU, TV );
68 }
69 else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT4 )
70 {
71 r_val = FLA_Bidiag_UT_u_blk_var4( A, TU, TV );
72 }
73 else if ( FLA_Cntl_variant( cntl ) == FLA_BLOCKED_VARIANT5 )
74 {
75 r_val = FLA_Bidiag_UT_u_blk_var5( A, TU, TV );
76 }
77 else if ( FLA_Cntl_variant( cntl ) == FLA_BLK_FUS_VARIANT2 )
78 {
79 r_val = FLA_Bidiag_UT_u_blf_var2( A, TU, TV );
80 }
81 else if ( FLA_Cntl_variant( cntl ) == FLA_BLK_FUS_VARIANT3 )
82 {
83 r_val = FLA_Bidiag_UT_u_blf_var3( A, TU, TV );
84 }
85 else if ( FLA_Cntl_variant( cntl ) == FLA_BLK_FUS_VARIANT4 )
86 {
87 r_val = FLA_Bidiag_UT_u_blf_var4( A, TU, TV );
88 }
89 else
90 {
91 FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
92 }
93
94 return r_val;
95}
FLA_Bidiag_UT_u_opt_var3
FLA_Error FLA_Bidiag_UT_u_opt_var3(FLA_Obj A, FLA_Obj T, FLA_Obj S)
Definition FLA_Bidiag_UT_u_opt_var3.c:13
FLA_Bidiag_UT_u_blf_var2
FLA_Error FLA_Bidiag_UT_u_blf_var2(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition FLA_Bidiag_UT_u_blf_var2.c:13
FLA_Bidiag_UT_u_unb_var2
FLA_Error FLA_Bidiag_UT_u_unb_var2(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition FLA_Bidiag_UT_u_unb_var2.c:13
FLA_Bidiag_UT_u_opt_var4
FLA_Error FLA_Bidiag_UT_u_opt_var4(FLA_Obj A, FLA_Obj T, FLA_Obj S)
Definition FLA_Bidiag_UT_u_opt_var4.c:13
FLA_Bidiag_UT_u_blf_var4
FLA_Error FLA_Bidiag_UT_u_blf_var4(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition FLA_Bidiag_UT_u_blf_var4.c:13
FLA_Bidiag_UT_u_blf_var3
FLA_Error FLA_Bidiag_UT_u_blf_var3(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition FLA_Bidiag_UT_u_blf_var3.c:13
FLA_Bidiag_UT_u_opt_var2
FLA_Error FLA_Bidiag_UT_u_opt_var2(FLA_Obj A, FLA_Obj T, FLA_Obj S)
Definition FLA_Bidiag_UT_u_opt_var2.c:13
FLA_Bidiag_UT_u_blk_var5
FLA_Error FLA_Bidiag_UT_u_blk_var5(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition FLA_Bidiag_UT_u_blk_var5.c:13
FLA_Bidiag_UT_u_opt_var5
FLA_Error FLA_Bidiag_UT_u_opt_var5(FLA_Obj A, FLA_Obj T, FLA_Obj S)
Definition FLA_Bidiag_UT_u_opt_var5.c:13
FLA_Bidiag_UT_u_blk_var3
FLA_Error FLA_Bidiag_UT_u_blk_var3(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition FLA_Bidiag_UT_u_blk_var3.c:13
FLA_Bidiag_UT_u_opt_var1
FLA_Error FLA_Bidiag_UT_u_opt_var1(FLA_Obj A, FLA_Obj T, FLA_Obj S)
Definition FLA_Bidiag_UT_u_opt_var1.c:13
FLA_Bidiag_UT_u_unb_var4
FLA_Error FLA_Bidiag_UT_u_unb_var4(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition FLA_Bidiag_UT_u_unb_var4.c:13
FLA_Bidiag_UT_u_blk_var2
FLA_Error FLA_Bidiag_UT_u_blk_var2(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition FLA_Bidiag_UT_u_blk_var2.c:13
FLA_Bidiag_UT_u_unb_var3
FLA_Error FLA_Bidiag_UT_u_unb_var3(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition FLA_Bidiag_UT_u_unb_var3.c:13
FLA_Bidiag_UT_u_unb_var1
FLA_Error FLA_Bidiag_UT_u_unb_var1(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition FLA_Bidiag_UT_u_unb_var1.c:13
FLA_Bidiag_UT_u_blk_var4
FLA_Error FLA_Bidiag_UT_u_blk_var4(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition FLA_Bidiag_UT_u_blk_var4.c:13
FLA_Bidiag_UT_u_unb_var5
FLA_Error FLA_Bidiag_UT_u_unb_var5(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition FLA_Bidiag_UT_u_unb_var5.c:13
FLA_Bidiag_UT_u_blk_var1
FLA_Error FLA_Bidiag_UT_u_blk_var1(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition FLA_Bidiag_UT_u_blk_var1.c:13

References FLA_Bidiag_UT_u_blf_var2(), FLA_Bidiag_UT_u_blf_var3(), FLA_Bidiag_UT_u_blf_var4(), FLA_Bidiag_UT_u_blk_var1(), FLA_Bidiag_UT_u_blk_var2(), FLA_Bidiag_UT_u_blk_var3(), FLA_Bidiag_UT_u_blk_var4(), FLA_Bidiag_UT_u_blk_var5(), FLA_Bidiag_UT_u_opt_var1(), FLA_Bidiag_UT_u_opt_var2(), FLA_Bidiag_UT_u_opt_var3(), FLA_Bidiag_UT_u_opt_var4(), FLA_Bidiag_UT_u_opt_var5(), FLA_Bidiag_UT_u_unb_var1(), FLA_Bidiag_UT_u_unb_var2(), FLA_Bidiag_UT_u_unb_var3(), FLA_Bidiag_UT_u_unb_var4(), FLA_Bidiag_UT_u_unb_var5(), and i.

Referenced by FLA_Bidiag_UT_internal().

◆ FLA_Bidiag_UT_u_extract_diagonals()

FLA_Error FLA_Bidiag_UT_u_extract_diagonals ( FLA_Obj  A,
FLA_Obj  d,
FLA_Obj  e 
)
31{
32 FLA_Datatype datatype;
33 int n_A;
34 int rs_A, cs_A;
35 int inc_d;
36 int inc_e;
37 int i;
38
39 datatype = FLA_Obj_datatype( A );
40
41 n_A = FLA_Obj_width( A );
42
43 rs_A = FLA_Obj_row_stride( A );
44 cs_A = FLA_Obj_col_stride( A );
45
46 inc_d = FLA_Obj_vector_inc( d );
47
48 if ( n_A != 1 )
49 inc_e = FLA_Obj_vector_inc( e );
50 else
51 inc_e = 0;
52
53 switch ( datatype )
54 {
55 case FLA_FLOAT:
56 {
57 float* buff_A = FLA_FLOAT_PTR( A );
58 float* buff_d = FLA_FLOAT_PTR( d );
59 float* buff_e = ( n_A != 1 ? FLA_FLOAT_PTR( e ) : NULL );
60
61 for ( i = 0; i < n_A; ++i )
62 {
63 float* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
64 float* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
65 float* delta1 = buff_d + (i )*inc_d;
66 float* epsilon1 = buff_e + (i )*inc_e;
67
68 int n_ahead = n_A - i - 1;
69
70 // delta1 = alpha11;
71 *delta1 = *alpha11;
72
73 // epsilon1 = a12t_l;
74 if ( n_ahead > 0 )
75 *epsilon1 = *a12t_l;
76 }
77
78 break;
79 }
80
81 case FLA_DOUBLE:
82 {
83 double* buff_A = FLA_DOUBLE_PTR( A );
84 double* buff_d = FLA_DOUBLE_PTR( d );
85 double* buff_e = ( n_A != 1 ? FLA_DOUBLE_PTR( e ) : NULL );
86
87 for ( i = 0; i < n_A; ++i )
88 {
89 double* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
90 double* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
91 double* delta1 = buff_d + (i )*inc_d;
92 double* epsilon1 = buff_e + (i )*inc_e;
93
94 int n_ahead = n_A - i - 1;
95
96 // delta1 = alpha11;
97 *delta1 = *alpha11;
98
99 // epsilon1 = a12t_l;
100 if ( n_ahead > 0 )
101 *epsilon1 = *a12t_l;
102 }
103
104 break;
105 }
106
107 case FLA_COMPLEX:
108 {
109 scomplex* buff_A = FLA_COMPLEX_PTR( A );
110 scomplex* buff_d = FLA_COMPLEX_PTR( d );
111 scomplex* buff_e = ( n_A != 1 ? FLA_COMPLEX_PTR( e ) : NULL );
112
113 for ( i = 0; i < n_A; ++i )
114 {
115 scomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
116 scomplex* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
117 scomplex* delta1 = buff_d + (i )*inc_d;
118 scomplex* epsilon1 = buff_e + (i )*inc_e;
119
120 int n_ahead = n_A - i - 1;
121
122 // delta1 = alpha11;
123 *delta1 = *alpha11;
124
125 // epsilon1 = a12t_l;
126 if ( n_ahead > 0 )
127 *epsilon1 = *a12t_l;
128 }
129
130 break;
131 }
132
133 case FLA_DOUBLE_COMPLEX:
134 {
135 dcomplex* buff_A = FLA_DOUBLE_COMPLEX_PTR( A );
136 dcomplex* buff_d = FLA_DOUBLE_COMPLEX_PTR( d );
137 dcomplex* buff_e = ( n_A != 1 ? FLA_DOUBLE_COMPLEX_PTR( e ) : NULL );
138
139 for ( i = 0; i < n_A; ++i )
140 {
141 dcomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
142 dcomplex* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
143 dcomplex* delta1 = buff_d + (i )*inc_d;
144 dcomplex* epsilon1 = buff_e + (i )*inc_e;
145
146 int n_ahead = n_A - i - 1;
147
148 // delta1 = alpha11;
149 *delta1 = *alpha11;
150
151 // epsilon1 = a12t_l;
152 if ( n_ahead > 0 )
153 *epsilon1 = *a12t_l;
154 }
155
156 break;
157 }
158 }
159
160 return FLA_SUCCESS;
161}

References FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_row_stride(), FLA_Obj_vector_inc(), FLA_Obj_width(), and i.

Referenced by FLA_Bidiag_UT_extract_diagonals(), and FLA_Tridiag_UT_extract_diagonals().

◆ FLA_Bidiag_UT_u_extract_real_diagonals()

FLA_Error FLA_Bidiag_UT_u_extract_real_diagonals ( FLA_Obj  A,
FLA_Obj  d,
FLA_Obj  e 
)
29{
30 FLA_Datatype datatype;
31 int n_A;
32 int rs_A, cs_A;
33 int inc_d;
34 int inc_e;
35 int i;
36
37 datatype = FLA_Obj_datatype( A );
38
39 n_A = FLA_Obj_width( A );
40
41 rs_A = FLA_Obj_row_stride( A );
42 cs_A = FLA_Obj_col_stride( A );
43
44 inc_d = FLA_Obj_vector_inc( d );
45
46 if ( n_A != 1 )
47 inc_e = FLA_Obj_vector_inc( e );
48 else
49 inc_e = 0;
50
51 switch ( datatype )
52 {
53 case FLA_FLOAT:
54 {
55 float* buff_A = FLA_FLOAT_PTR( A );
56 float* buff_d = FLA_FLOAT_PTR( d );
57 float* buff_e = ( n_A != 1 ? FLA_FLOAT_PTR( e ) : NULL );
58
59 for ( i = 0; i < n_A; ++i )
60 {
61 float* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
62 float* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
63 float* delta1 = buff_d + (i )*inc_d;
64 float* epsilon1 = buff_e + (i )*inc_e;
65
66 int n_ahead = n_A - i - 1;
67
68 // delta1 = alpha11;
69 *delta1 = *alpha11;
70
71 // epsilon1 = a12t_l;
72 if ( n_ahead > 0 )
73 *epsilon1 = *a12t_l;
74 }
75
76 break;
77 }
78
79 case FLA_DOUBLE:
80 {
81 double* buff_A = FLA_DOUBLE_PTR( A );
82 double* buff_d = FLA_DOUBLE_PTR( d );
83 double* buff_e = ( n_A != 1 ? FLA_DOUBLE_PTR( e ) : NULL );
84
85 for ( i = 0; i < n_A; ++i )
86 {
87 double* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
88 double* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
89 double* delta1 = buff_d + (i )*inc_d;
90 double* epsilon1 = buff_e + (i )*inc_e;
91
92 int n_ahead = n_A - i - 1;
93
94 // delta1 = alpha11;
95 *delta1 = *alpha11;
96
97 // epsilon1 = a12t_l;
98 if ( n_ahead > 0 )
99 *epsilon1 = *a12t_l;
100 }
101
102 break;
103 }
104
105 case FLA_COMPLEX:
106 {
107 scomplex* buff_A = FLA_COMPLEX_PTR( A );
108 float* buff_d = FLA_FLOAT_PTR( d );
109 float* buff_e = ( n_A != 1 ? FLA_FLOAT_PTR( e ) : NULL );
110
111 for ( i = 0; i < n_A; ++i )
112 {
113 scomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
114 scomplex* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
115 float* delta1 = buff_d + (i )*inc_d;
116 float* epsilon1 = buff_e + (i )*inc_e;
117
118 int n_ahead = n_A - i - 1;
119
120 // delta1 = alpha11;
121 *delta1 = alpha11->real;
122
123 // epsilon1 = a12t_l;
124 if ( n_ahead > 0 )
125 *epsilon1 = a12t_l->real;
126 }
127
128 break;
129 }
130
131 case FLA_DOUBLE_COMPLEX:
132 {
133 dcomplex* buff_A = FLA_DOUBLE_COMPLEX_PTR( A );
134 double* buff_d = FLA_DOUBLE_PTR( d );
135 double* buff_e = ( n_A != 1 ? FLA_DOUBLE_PTR( e ) : NULL );
136
137 for ( i = 0; i < n_A; ++i )
138 {
139 dcomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
140 dcomplex* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
141 double* delta1 = buff_d + (i )*inc_d;
142 double* epsilon1 = buff_e + (i )*inc_e;
143
144 int n_ahead = n_A - i - 1;
145
146 // delta1 = alpha11;
147 *delta1 = alpha11->real;
148
149 // epsilon1 = a12t_l;
150 if ( n_ahead > 0 )
151 *epsilon1 = a12t_l->real;
152 }
153
154 break;
155 }
156 }
157
158 return FLA_SUCCESS;
159}

References FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_row_stride(), FLA_Obj_vector_inc(), FLA_Obj_width(), i, scomplex::real, and dcomplex::real.

Referenced by FLA_Bidiag_UT_extract_real_diagonals(), and FLA_Tridiag_UT_extract_real_diagonals().

◆ FLA_Bidiag_UT_u_realify_opt()

FLA_Error FLA_Bidiag_UT_u_realify_opt ( FLA_Obj  A,
FLA_Obj  d,
FLA_Obj  e 
)
483{
484 FLA_Datatype datatype;
485 int m_A, n_A;
486 int min_m_n;
487 int rs_A, cs_A;
488 int inc_d;
489 int inc_e;
490 int i;
491
492 datatype = FLA_Obj_datatype( A );
493
494 m_A = FLA_Obj_length( A );
495 n_A = FLA_Obj_width( A );
496 min_m_n = FLA_Obj_min_dim( A );
497
498 rs_A = FLA_Obj_row_stride( A );
499 cs_A = FLA_Obj_col_stride( A );
500
501 inc_d = FLA_Obj_vector_inc( d );
502
503 inc_e = FLA_Obj_vector_inc( e );
504
505
506 switch ( datatype )
507 {
508 case FLA_FLOAT:
509 {
510 float* buff_d = FLA_FLOAT_PTR( d );
511 float* buff_e = FLA_FLOAT_PTR( e );
512 float* buff_1 = FLA_FLOAT_PTR( FLA_ONE );
513
514 bl1_ssetv( min_m_n,
515 buff_1,
516 buff_d, inc_d );
517
518 bl1_ssetv( min_m_n,
519 buff_1,
520 buff_e, inc_e );
521
522 break;
523 }
524
525 case FLA_DOUBLE:
526 {
527 double* buff_d = FLA_DOUBLE_PTR( d );
528 double* buff_e = FLA_DOUBLE_PTR( e );
529 double* buff_1 = FLA_DOUBLE_PTR( FLA_ONE );
530
531 bl1_dsetv( min_m_n,
532 buff_1,
533 buff_d, inc_d );
534
535 bl1_dsetv( min_m_n,
536 buff_1,
537 buff_e, inc_e );
538
539 break;
540 }
541
542 case FLA_COMPLEX:
543 {
544 scomplex* buff_A = FLA_COMPLEX_PTR( A );
545 scomplex* buff_d = FLA_COMPLEX_PTR( d );
546 scomplex* buff_e = FLA_COMPLEX_PTR( e );
547 scomplex* buff_1 = FLA_COMPLEX_PTR( FLA_ONE );
548 float* buff_0 = FLA_FLOAT_PTR( FLA_ZERO );
549
550 for ( i = 0; i < min_m_n; ++i )
551 {
552 scomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
553 scomplex* delta1 = buff_d + (i )*inc_d;
554 scomplex* epsilon1 = buff_e + (i )*inc_e;
555 scomplex absv;
556
557 int n_ahead = n_A - i - 1;
558 int n_behind = i;
559
560 if ( n_behind == 0 )
561 {
562 // FLA_Set( FLA_ONE, epsilon1 );
563 *epsilon1 = *buff_1;
564 }
565 else
566 {
567 scomplex* a01_b = buff_A + (i )*cs_A + (i-1)*rs_A;
568 // FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, a01_b, epsilon1 );
569 // FLA_Copyt( FLA_NO_TRANSPOSE, a01_b, absv );
570 // FLA_Absolute_value( absv );
571 // FLA_Inv_scal( absv, epsilon1 );
572 bl1_ccopys( BLIS1_CONJUGATE, a01_b, epsilon1 );
573 bl1_cabsval2( a01_b, &absv );
574 bl1_cinvscals( &absv, epsilon1 );
575
576 // FLA_Scalc( FLA_NO_CONJUGATE, epsilon1, a01_b );
577 // FLA_Obj_set_imag_part( FLA_ZERO, a01_b );
578 bl1_cscals( epsilon1, a01_b );
579 a01_b->imag = *buff_0;
580
581 // FLA_Scalc( FLA_NO_CONJUGATE, epsilon1, alpha11 );
582 bl1_cscals( epsilon1, alpha11 );
583 }
584
585 // FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, alpha11, delta1 );
586 // FLA_Copyt( FLA_NO_TRANSPOSE, alpha11, absv );
587 // FLA_Absolute_value( absv );
588 // FLA_Inv_scal( absv, delta1 );
589 bl1_ccopys( BLIS1_CONJUGATE, alpha11, delta1 );
590 bl1_cabsval2( alpha11, &absv );
591 bl1_cinvscals( &absv, delta1 );
592
593 // FLA_Scalc( FLA_NO_CONJUGATE, delta1, alpha11 );
594 // FLA_Obj_set_imag_part( FLA_ZERO, alpha11 );
595 bl1_cscals( delta1, alpha11 );
596 alpha11->imag = *buff_0;
597
598 if ( n_ahead > 0 )
599 {
600 scomplex* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
601 // FLA_Scalc( FLA_NO_CONJUGATE, delta1, a12t_l );
602 bl1_cscals( delta1, a12t_l );
603 }
604 }
605
606 break;
607 }
608
609 case FLA_DOUBLE_COMPLEX:
610 {
611 dcomplex* buff_A = FLA_DOUBLE_COMPLEX_PTR( A );
612 dcomplex* buff_d = FLA_DOUBLE_COMPLEX_PTR( d );
613 dcomplex* buff_e = FLA_DOUBLE_COMPLEX_PTR( e );
614 dcomplex* buff_1 = FLA_DOUBLE_COMPLEX_PTR( FLA_ONE );
615 double* buff_0 = FLA_DOUBLE_PTR( FLA_ZERO );
616
617 for ( i = 0; i < min_m_n; ++i )
618 {
619 dcomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
620 dcomplex* delta1 = buff_d + (i )*inc_d;
621 dcomplex* epsilon1 = buff_e + (i )*inc_e;
622 dcomplex absv;
623
624 int n_ahead = n_A - i - 1;
625 int n_behind = i;
626
627 if ( n_behind == 0 )
628 {
629 // FLA_Set( FLA_ONE, epsilon1 );
630 *epsilon1 = *buff_1;
631 }
632 else
633 {
634 dcomplex* a01_b = buff_A + (i )*cs_A + (i-1)*rs_A;
635 // FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, a01_b, epsilon1 );
636 // FLA_Copyt( FLA_NO_TRANSPOSE, a01_b, absv );
637 // FLA_Absolute_value( absv );
638 // FLA_Inv_scal( absv, epsilon1 );
639 bl1_zcopys( BLIS1_CONJUGATE, a01_b, epsilon1 );
640 bl1_zabsval2( a01_b, &absv );
641 bl1_zinvscals( &absv, epsilon1 );
642
643 // FLA_Scalc( FLA_NO_CONJUGATE, epsilon1, a01_b );
644 // FLA_Obj_set_imag_part( FLA_ZERO, a01_b );
645 bl1_zscals( epsilon1, a01_b );
646 a01_b->imag = *buff_0;
647
648 // FLA_Scalc( FLA_NO_CONJUGATE, epsilon1, alpha11 );
649 bl1_zscals( epsilon1, alpha11 );
650 }
651
652 // FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, alpha11, delta1 );
653 // FLA_Copyt( FLA_NO_TRANSPOSE, alpha11, absv );
654 // FLA_Absolute_value( absv );
655 // FLA_Inv_scal( absv, delta1 );
656 bl1_zcopys( BLIS1_CONJUGATE, alpha11, delta1 );
657 bl1_zabsval2( alpha11, &absv );
658 bl1_zinvscals( &absv, delta1 );
659
660 // FLA_Scalc( FLA_NO_CONJUGATE, delta1, alpha11 );
661 // FLA_Obj_set_imag_part( FLA_ZERO, alpha11 );
662 bl1_zscals( delta1, alpha11 );
663 alpha11->imag = *buff_0;
664
665 if ( n_ahead > 0 )
666 {
667 dcomplex* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
668 // FLA_Scalc( FLA_NO_CONJUGATE, delta1, a12t_l );
669 bl1_zscals( delta1, a12t_l );
670 }
671 }
672
673 break;
674 }
675 }
676
677 return FLA_SUCCESS;
678}

References bl1_dsetv(), bl1_ssetv(), bl1_zscals(), BLIS1_CONJUGATE, FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_min_dim(), FLA_Obj_row_stride(), FLA_Obj_vector_inc(), FLA_Obj_width(), FLA_ONE, FLA_ZERO, and i.

Referenced by FLA_Bidiag_UT_realify().

◆ FLA_Bidiag_UT_u_realify_unb()

FLA_Error FLA_Bidiag_UT_u_realify_unb ( FLA_Obj  A,
FLA_Obj  d,
FLA_Obj  e 
)
362{
363 FLA_Obj ATL, ATR, A00, a01, A02,
364 ABL, ABR, a10t, alpha11, a12t,
365 A20, a21, A22;
366
367 FLA_Obj dT, d0,
368 dB, delta1,
369 d2;
370
371 FLA_Obj eT, e0,
372 eB, epsilon1,
373 e2;
374
375 FLA_Obj a01_t,
376 a01_b;
377
378 FLA_Obj a12t_l, a12t_r;
379
380 FLA_Obj absv;
381
382
383 FLA_Obj_create( FLA_Obj_datatype( A ), 1, 1, 0, 0, &absv );
384
385 FLA_Part_2x2( A, &ATL, &ATR,
386 &ABL, &ABR, 0, 0, FLA_TL );
387
388 FLA_Part_2x1( d, &dT,
389 &dB, 0, FLA_TOP );
390
391 FLA_Part_2x1( e, &eT,
392 &eB, 0, FLA_TOP );
393
394 while ( FLA_Obj_min_dim( ABR ) > 0 )
395 {
396 FLA_Repart_2x2_to_3x3( ATL, /**/ ATR, &A00, /**/ &a01, &A02,
397 /* ************* */ /* ************************** */
398 &a10t, /**/ &alpha11, &a12t,
399 ABL, /**/ ABR, &A20, /**/ &a21, &A22,
400 1, 1, FLA_BR );
401
402 FLA_Repart_2x1_to_3x1( dT, &d0,
403 /* ** */ /* ****** */
404 &delta1,
405 dB, &d2, 1, FLA_BOTTOM );
406
407 FLA_Repart_2x1_to_3x1( eT, &e0,
408 /* ** */ /* ******** */
409 &epsilon1,
410 eB, &e2, 1, FLA_BOTTOM );
411
412 /*------------------------------------------------------------*/
413
414 if ( FLA_Obj_length( a01 ) == 0 )
415 {
416 // epsilon1 = 1;
417 FLA_Set( FLA_ONE, epsilon1 );
418 }
419 else
420 {
421 FLA_Part_2x1( a01, &a01_t,
422 &a01_b, 1, FLA_BOTTOM );
423
424 // epsilon1 = conj(a01_b) / abs(a01_b);
425 FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, a01_b, epsilon1 );
426 FLA_Copyt( FLA_NO_TRANSPOSE, a01_b, absv );
427 FLA_Absolute_value( absv );
428 FLA_Inv_scal( absv, epsilon1 );
429
430 // a01_b = epsilon1 * a01_b;
431 // a01_b.imag = 0;
432 FLA_Scalc( FLA_NO_CONJUGATE, epsilon1, a01_b );
433 FLA_Obj_set_imag_part( FLA_ZERO, a01_b );
434
435 // alpha11 = epsilon1 * alpha11;
436 FLA_Scalc( FLA_NO_CONJUGATE, epsilon1, alpha11 );
437 }
438
439 // delta1 = conj(alpha11) / abs(alpha11);
440 FLA_Copyt( FLA_CONJ_NO_TRANSPOSE, alpha11, delta1 );
441 FLA_Copyt( FLA_NO_TRANSPOSE, alpha11, absv );
442 FLA_Absolute_value( absv );
443 FLA_Inv_scal( absv, delta1 );
444
445 // alpha11 = delta1 * alpha11;
446 // alpha11.imag = 0;
447 FLA_Scalc( FLA_NO_CONJUGATE, delta1, alpha11 );
448 FLA_Obj_set_imag_part( FLA_ZERO, alpha11 );
449
450 if ( FLA_Obj_width( a12t ) > 0 )
451 {
452 FLA_Part_1x2( a12t, &a12t_l, &a12t_r, 1, FLA_LEFT );
453
454 // a12t_l = delta1 * a12t_l;
455 FLA_Scalc( FLA_NO_CONJUGATE, delta1, a12t_l );
456 }
457
458 /*------------------------------------------------------------*/
459
460 FLA_Cont_with_3x3_to_2x2( &ATL, /**/ &ATR, A00, a01, /**/ A02,
461 a10t, alpha11, /**/ a12t,
462 /* ************** */ /* ************************ */
463 &ABL, /**/ &ABR, A20, a21, /**/ A22,
464 FLA_TL );
465
466 FLA_Cont_with_3x1_to_2x1( &dT, d0,
467 delta1,
468 /* ** */ /* ****** */
469 &dB, d2, FLA_TOP );
470
471 FLA_Cont_with_3x1_to_2x1( &eT, e0,
472 epsilon1,
473 /* ** */ /* ******** */
474 &eB, e2, FLA_TOP );
475 }
476
477 FLA_Obj_free( &absv );
478
479 return FLA_SUCCESS;
480}

References FLA_Absolute_value(), FLA_Cont_with_3x1_to_2x1(), FLA_Cont_with_3x3_to_2x2(), FLA_Copyt(), FLA_Inv_scal(), FLA_Obj_create(), FLA_Obj_datatype(), FLA_Obj_free(), FLA_Obj_length(), FLA_Obj_min_dim(), FLA_Obj_set_imag_part(), FLA_Obj_width(), FLA_ONE, FLA_Part_1x2(), FLA_Part_2x1(), FLA_Part_2x2(), FLA_Repart_2x1_to_3x1(), FLA_Repart_2x2_to_3x3(), FLA_Scalc(), FLA_Set(), FLA_ZERO, and i.

◆ FLA_Bidiag_UT_u_scale_diagonals()

FLA_Error FLA_Bidiag_UT_u_scale_diagonals ( FLA_Obj  alpha,
FLA_Obj  A 
)
31{
32 FLA_Datatype datatype;
33 int n_A;
34 int rs_A, cs_A;
35 int i;
36
37 datatype = FLA_Obj_datatype( A );
38
39 n_A = FLA_Obj_width( A );
40
41 rs_A = FLA_Obj_row_stride( A );
42 cs_A = FLA_Obj_col_stride( A );
43
44 switch ( datatype )
45 {
46 case FLA_FLOAT:
47 {
48 float* buff_A = FLA_FLOAT_PTR( A );
49 float* buff_alpha = FLA_FLOAT_PTR( alpha );
50 for ( i = 0; i < n_A; ++i )
51 {
52 float* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
53 float* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
54 int n_ahead = n_A - i - 1;
55
56 bl1_sscals( buff_alpha, alpha11 );
57
58 if ( n_ahead > 0 )
59 bl1_sscals( buff_alpha, a12t_l );
60 }
61
62 break;
63 }
64
65 case FLA_DOUBLE:
66 {
67 double* buff_A = FLA_DOUBLE_PTR( A );
68 double* buff_alpha = FLA_DOUBLE_PTR( alpha );
69 for ( i = 0; i < n_A; ++i )
70 {
71 double* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
72 double* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
73 int n_ahead = n_A - i - 1;
74
75 bl1_dscals( buff_alpha, alpha11 );
76
77 if ( n_ahead > 0 )
78 bl1_dscals( buff_alpha, a12t_l );
79 }
80
81 break;
82 }
83
84 case FLA_COMPLEX:
85 {
86 scomplex* buff_A = FLA_COMPLEX_PTR( A );
87 float* buff_alpha = FLA_FLOAT_PTR( alpha );
88 for ( i = 0; i < n_A; ++i )
89 {
90 scomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
91 scomplex* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
92 int n_ahead = n_A - i - 1;
93
94 bl1_csscals( buff_alpha, alpha11 );
95
96 if ( n_ahead > 0 )
97 bl1_csscals( buff_alpha, a12t_l );
98 }
99
100 break;
101 }
102
103 case FLA_DOUBLE_COMPLEX:
104 {
105 dcomplex* buff_A = FLA_DOUBLE_COMPLEX_PTR( A );
106 double* buff_alpha = FLA_DOUBLE_PTR( alpha );
107 for ( i = 0; i < n_A; ++i )
108 {
109 dcomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
110 dcomplex* a12t_l = buff_A + (i+1)*cs_A + (i )*rs_A;
111 int n_ahead = n_A - i - 1;
112
113 bl1_zdscals( buff_alpha, alpha11 );
114
115 if ( n_ahead > 0 )
116 bl1_zdscals( buff_alpha, a12t_l );
117 }
118
119 break;
120 }
121 }
122
123 return FLA_SUCCESS;
124}

References FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_row_stride(), FLA_Obj_width(), and i.

Referenced by FLA_Bidiag_UT_scale_diagonals(), and FLA_Tridiag_UT_scale_diagonals().

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