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 &&
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_t * fla_bidiagut_cntl_plain
Definition: FLA_Bidiag_UT_cntl_init.c:15
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_Error FLA_Bidiag_UT_check(FLA_Obj A, FLA_Obj TU, FLA_Obj TV)
Definition: FLA_Bidiag_UT_check.c:13
dim_t FLA_Obj_row_stride(FLA_Obj obj)
Definition: FLA_Query.c:167
unsigned int FLA_Check_error_level(void)
Definition: FLA_Check.c:18
FLA_Bool FLA_Obj_is_double_precision(FLA_Obj A)
Definition: FLA_Query.c:358
int FLA_Error
Definition: FLA_type_defs.h:47

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

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_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
dim_t FLA_Query_blocksize(FLA_Datatype dt, FLA_Dimension dim)
Definition: FLA_Blocksize.c:161
dim_t FLA_Obj_min_dim(FLA_Obj obj)
Definition: FLA_Query.c:153
FLA_Datatype FLA_Obj_datatype(FLA_Obj obj)
Definition: FLA_Query.c:13
int FLA_Datatype
Definition: FLA_type_defs.h:49
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(), and FLA_Query_blocksize().

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 )
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_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_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_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
dim_t FLA_Obj_width(FLA_Obj obj)
Definition: FLA_Query.c:123
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(), and FLA_Obj_width().

◆ 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 )
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_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_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_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(), and FLA_Obj_width().

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_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_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
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(), and FLA_Obj_width().

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_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_Error FLA_QR_UT_form_Q(FLA_Obj A, FLA_Obj T, FLA_Obj Q)
Definition: FLA_QR_UT_form_Q.c:13
FLA_Obj FLA_ZERO
Definition: FLA_Init.c:20
FLA_Obj FLA_ONE
Definition: FLA_Init.c:18
FLA_Error FLA_Apply_pivots(FLA_Side side, FLA_Trans trans, FLA_Obj p, FLA_Obj A)
Definition: FLA_Apply_pivots.c:15
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_Error FLA_Obj_flip_view(FLA_Obj *obj)
Definition: FLA_Obj.c:669
FLA_Error FLA_Obj_flip_base(FLA_Obj *obj)
Definition: FLA_Obj.c:647
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_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_Bool FLA_Obj_is(FLA_Obj A, FLA_Obj B)
Definition: FLA_Query.c:460
FLA_Error FLA_Obj_free(FLA_Obj *obj)
Definition: FLA_Obj.c:588
FLA_Error FLA_Set(FLA_Obj alpha, FLA_Obj A)
Definition: FLA_Set.c:13
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(), and FLA_ZERO.

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_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(), and FLA_Obj_width().

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_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(), and FLA_ZERO.

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_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_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_Bool FLA_Obj_is_complex(FLA_Obj A)
Definition: FLA_Query.c:324
FLA_Error FLA_Conjugate_r(FLA_Uplo uplo, FLA_Obj A)
Definition: FLA_Conjugate_r.c:13
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(), and FLA_Part_2x2().

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 }
dim_t FLA_Obj_col_stride(FLA_Obj obj)
Definition: FLA_Query.c:174
dim_t FLA_Obj_vector_inc(FLA_Obj obj)
Definition: FLA_Query.c:145
int i
Definition: bl1_axmyv2.c:145
Definition: blis_type_defs.h:138
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 }
double real
Definition: blis_type_defs.h:139
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(beta, rho_yz)
void bl1_dsetv(int m, double *sigma, double *x, int incx)
Definition: bl1_setv.c:39
void bl1_ssetv(int m, float *sigma, float *x, int incx)
Definition: bl1_setv.c:26
@ BLIS1_CONJUGATE
Definition: blis_type_defs.h:82
double imag
Definition: blis_type_defs.h:139
float imag
Definition: blis_type_defs.h:134

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, i, scomplex::imag, and dcomplex::imag.

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_Error FLA_Scalc(FLA_Conj conjalpha, FLA_Obj alpha, FLA_Obj A)
Definition: FLA_Scalc.c:13
FLA_Error FLA_Inv_scal(FLA_Obj alpha, FLA_Obj A)
Definition: FLA_Inv_scal.c:13
FLA_Error FLA_Copyt(FLA_Trans trans, FLA_Obj A, FLA_Obj B)
Definition: FLA_Copyt.c:15
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_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_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
void FLA_Obj_set_imag_part(FLA_Obj alpha, FLA_Obj beta)
Definition: FLA_Misc.c:229
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_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(), and FLA_ZERO.

◆ 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_Error FLA_Bidiag_UT_u_realify_opt(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition: FLA_Bidiag_UT_realify.c:482
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_Error FLA_Bidiag_UT_realify_check(FLA_Obj A, FLA_Obj d, FLA_Obj e)
Definition: FLA_Bidiag_UT_realify_check.c:13
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, and FLA_Set().

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_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_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(), and FLA_Check_error_level().

◆ 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 }
dim_t FLA_Obj_vector_dim(FLA_Obj obj)
Definition: FLA_Query.c:137
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, i, scomplex::imag, and dcomplex::imag.

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 
23 
24  return FLA_SUCCESS;
25 }
FLA_Error FLA_Bidiag_UT_recover_tau_panel(FLA_Obj T, FLA_Obj t)
Definition: FLA_Bidiag_UT_recover_tau.c:27
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(), and FLA_Check_error_level().

◆ 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 )
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_Error FLA_Bidiag_UT_u_scale_diagonals(FLA_Obj alpha, FLA_Obj A)
Definition: FLA_Bidiag_UT_scale_diagonals.c:30
FLA_Error FLA_Bidiag_UT_l_scale_diagonals(FLA_Obj alpha, FLA_Obj A)
Definition: FLA_Bidiag_UT_scale_diagonals.c:126
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(), and FLA_Obj_width().

◆ 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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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(), and FLA_Bidiag_UT_u_unb_var5().

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, i, scomplex::imag, and dcomplex::imag.

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 );
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(), and FLA_ZERO.

◆ 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().