libflame  revision_anchor
Functions
FLA_LQ_UT_opt_var1.c File Reference

(r)

Functions

FLA_Error FLA_LQ_UT_opt_var1 (FLA_Obj A, FLA_Obj t)
 
FLA_Error FLA_LQ_UT_ops_var1 (int m_A, int n_A, float *buff_A, int rs_A, int cs_A, float *buff_t, int inc_t)
 
FLA_Error FLA_LQ_UT_opd_var1 (int m_A, int n_A, double *buff_A, int rs_A, int cs_A, double *buff_t, int inc_t)
 
FLA_Error FLA_LQ_UT_opc_var1 (int m_A, int n_A, scomplex *buff_A, int rs_A, int cs_A, scomplex *buff_t, int inc_t)
 
FLA_Error FLA_LQ_UT_opz_var1 (int m_A, int n_A, dcomplex *buff_A, int rs_A, int cs_A, dcomplex *buff_t, int inc_t)
 

Function Documentation

◆ FLA_LQ_UT_opc_var1()

FLA_Error FLA_LQ_UT_opc_var1 ( int  m_A,
int  n_A,
scomplex buff_A,
int  rs_A,
int  cs_A,
scomplex buff_t,
int  inc_t 
)
186 {
187  int min_m_n = min( m_A, n_A );
188  int i;
189 
190  for ( i = 0; i < min_m_n; ++i )
191  {
192  scomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
193  scomplex* a21 = buff_A + (i )*cs_A + (i+1)*rs_A;
194  scomplex* a12t = buff_A + (i+1)*cs_A + (i )*rs_A;
195  scomplex* A22 = buff_A + (i+1)*cs_A + (i+1)*rs_A;
196 
197  scomplex* tau1 = buff_t + (i )*inc_t;
198 
199  int m_ahead = m_A - i - 1;
200  int n_ahead = n_A - i - 1;
201 
202  /*------------------------------------------------------------*/
203 
204  // FLA_Househ2_UT( FLA_RIGHT, alpha11, a12t
205  // tau1 );
206  FLA_Househ2_UT_r_opc( n_ahead,
207  alpha11,
208  a12t, cs_A,
209  tau1 );
210 
211  // FLA_Apply_H2_UT( FLA_RIGHT, tau1, a12t, a21, A22 );
213  n_ahead,
214  tau1,
215  a12t, cs_A,
216  a21, rs_A,
217  A22, rs_A, cs_A );
218 
219  /*------------------------------------------------------------*/
220 
221  }
222 
223  return FLA_SUCCESS;
224 }
FLA_Error FLA_Apply_H2_UT_r_opc_var1(int n_u2h_A2, int m_a1, scomplex *tau, scomplex *u2h, int inc_u2h, scomplex *a1, int inc_a1, scomplex *A2, int rs_A2, int cs_A2)
Definition: FLA_Apply_H2_UT_r_opt_var1.c:254
FLA_Error FLA_Househ2_UT_r_opc(int m_x2, scomplex *chi_1, scomplex *x2, int inc_x2, scomplex *tau)
Definition: FLA_Househ2_UT.c:677
int i
Definition: bl1_axmyv2.c:145
Definition: blis_type_defs.h:133

References FLA_Apply_H2_UT_r_opc_var1(), FLA_Househ2_UT_r_opc(), and i.

Referenced by FLA_LQ_UT_opt_var1().

◆ FLA_LQ_UT_opd_var1()

FLA_Error FLA_LQ_UT_opd_var1 ( int  m_A,
int  n_A,
double *  buff_A,
int  rs_A,
int  cs_A,
double *  buff_t,
int  inc_t 
)
140 {
141  int min_m_n = min( m_A, n_A );
142  int i;
143 
144  for ( i = 0; i < min_m_n; ++i )
145  {
146  double* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
147  double* a21 = buff_A + (i )*cs_A + (i+1)*rs_A;
148  double* a12t = buff_A + (i+1)*cs_A + (i )*rs_A;
149  double* A22 = buff_A + (i+1)*cs_A + (i+1)*rs_A;
150 
151  double* tau1 = buff_t + (i )*inc_t;
152 
153  int m_ahead = m_A - i - 1;
154  int n_ahead = n_A - i - 1;
155 
156  /*------------------------------------------------------------*/
157 
158  // FLA_Househ2_UT( FLA_RIGHT, alpha11, a12t
159  // tau1 );
160  FLA_Househ2_UT_r_opd( n_ahead,
161  alpha11,
162  a12t, cs_A,
163  tau1 );
164 
165  // FLA_Apply_H2_UT( FLA_RIGHT, tau1, a12t, a21, A22 );
167  n_ahead,
168  tau1,
169  a12t, cs_A,
170  a21, rs_A,
171  A22, rs_A, cs_A );
172 
173  /*------------------------------------------------------------*/
174 
175  }
176 
177  return FLA_SUCCESS;
178 }
FLA_Error FLA_Apply_H2_UT_r_opd_var1(int n_u2h_A2, int m_a1, double *tau, double *u2h, int inc_u2h, double *a1, int inc_a1, double *A2, int rs_A2, int cs_A2)
Definition: FLA_Apply_H2_UT_r_opt_var1.c:181
FLA_Error FLA_Househ2_UT_r_opd(int m_x2, double *chi_1, double *x2, int inc_x2, double *tau)
Definition: FLA_Househ2_UT.c:664

References FLA_Apply_H2_UT_r_opd_var1(), FLA_Househ2_UT_r_opd(), and i.

Referenced by FLA_LQ_UT_opt_var1().

◆ FLA_LQ_UT_ops_var1()

FLA_Error FLA_LQ_UT_ops_var1 ( int  m_A,
int  n_A,
float *  buff_A,
int  rs_A,
int  cs_A,
float *  buff_t,
int  inc_t 
)
94 {
95  int min_m_n = min( m_A, n_A );
96  int i;
97 
98  for ( i = 0; i < min_m_n; ++i )
99  {
100  float* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
101  float* a21 = buff_A + (i )*cs_A + (i+1)*rs_A;
102  float* a12t = buff_A + (i+1)*cs_A + (i )*rs_A;
103  float* A22 = buff_A + (i+1)*cs_A + (i+1)*rs_A;
104 
105  float* tau1 = buff_t + (i )*inc_t;
106 
107  int m_ahead = m_A - i - 1;
108  int n_ahead = n_A - i - 1;
109 
110  /*------------------------------------------------------------*/
111 
112  // FLA_Househ2_UT( FLA_RIGHT, alpha11, a12t
113  // tau1 );
114  FLA_Househ2_UT_r_ops( n_ahead,
115  alpha11,
116  a12t, cs_A,
117  tau1 );
118 
119  // FLA_Apply_H2_UT( FLA_RIGHT, tau1, a12t, a21, A22 );
121  n_ahead,
122  tau1,
123  a12t, cs_A,
124  a21, rs_A,
125  A22, rs_A, cs_A );
126 
127  /*------------------------------------------------------------*/
128 
129  }
130 
131  return FLA_SUCCESS;
132 }
FLA_Error FLA_Apply_H2_UT_r_ops_var1(int n_u2h_A2, int m_a1, float *tau, float *u2h, int inc_u2h, float *a1, int inc_a1, float *A2, int rs_A2, int cs_A2)
Definition: FLA_Apply_H2_UT_r_opt_var1.c:108
FLA_Error FLA_Househ2_UT_r_ops(int m_x2, float *chi_1, float *x2, int inc_x2, float *tau)
Definition: FLA_Househ2_UT.c:651

References FLA_Apply_H2_UT_r_ops_var1(), FLA_Househ2_UT_r_ops(), and i.

Referenced by FLA_LQ_UT_opt_var1().

◆ FLA_LQ_UT_opt_var1()

FLA_Error FLA_LQ_UT_opt_var1 ( FLA_Obj  A,
FLA_Obj  t 
)
14 {
15  FLA_Datatype datatype;
16  int m_A, n_A;
17  int rs_A, cs_A;
18  int inc_t;
19 
20  datatype = FLA_Obj_datatype( A );
21 
22  m_A = FLA_Obj_length( A );
23  n_A = FLA_Obj_width( A );
24  rs_A = FLA_Obj_row_stride( A );
25  cs_A = FLA_Obj_col_stride( A );
26 
27  inc_t = FLA_Obj_vector_inc( t );
28 
29 
30  switch ( datatype )
31  {
32  case FLA_FLOAT:
33  {
34  float* buff_A = FLA_FLOAT_PTR( A );
35  float* buff_t = FLA_FLOAT_PTR( t );
36 
37  FLA_LQ_UT_ops_var1( m_A,
38  n_A,
39  buff_A, rs_A, cs_A,
40  buff_t, inc_t );
41 
42  break;
43  }
44 
45  case FLA_DOUBLE:
46  {
47  double* buff_A = FLA_DOUBLE_PTR( A );
48  double* buff_t = FLA_DOUBLE_PTR( t );
49 
50  FLA_LQ_UT_opd_var1( m_A,
51  n_A,
52  buff_A, rs_A, cs_A,
53  buff_t, inc_t );
54 
55  break;
56  }
57 
58  case FLA_COMPLEX:
59  {
60  scomplex* buff_A = FLA_COMPLEX_PTR( A );
61  scomplex* buff_t = FLA_COMPLEX_PTR( t );
62 
63  FLA_LQ_UT_opc_var1( m_A,
64  n_A,
65  buff_A, rs_A, cs_A,
66  buff_t, inc_t );
67 
68  break;
69  }
70 
71  case FLA_DOUBLE_COMPLEX:
72  {
73  dcomplex* buff_A = FLA_DOUBLE_COMPLEX_PTR( A );
74  dcomplex* buff_t = FLA_DOUBLE_COMPLEX_PTR( t );
75 
76  FLA_LQ_UT_opz_var1( m_A,
77  n_A,
78  buff_A, rs_A, cs_A,
79  buff_t, inc_t );
80 
81  break;
82  }
83  }
84 
85  return FLA_SUCCESS;
86 }
FLA_Error FLA_LQ_UT_ops_var1(int m_A, int n_A, float *buff_A, int rs_A, int cs_A, float *buff_t, int inc_t)
Definition: FLA_LQ_UT_opt_var1.c:90
FLA_Error FLA_LQ_UT_opz_var1(int m_A, int n_A, dcomplex *buff_A, int rs_A, int cs_A, dcomplex *buff_t, int inc_t)
Definition: FLA_LQ_UT_opt_var1.c:228
FLA_Error FLA_LQ_UT_opd_var1(int m_A, int n_A, double *buff_A, int rs_A, int cs_A, double *buff_t, int inc_t)
Definition: FLA_LQ_UT_opt_var1.c:136
FLA_Error FLA_LQ_UT_opc_var1(int m_A, int n_A, scomplex *buff_A, int rs_A, int cs_A, scomplex *buff_t, int inc_t)
Definition: FLA_LQ_UT_opt_var1.c:182
dim_t FLA_Obj_width(FLA_Obj obj)
Definition: FLA_Query.c:123
dim_t FLA_Obj_row_stride(FLA_Obj obj)
Definition: FLA_Query.c:167
dim_t FLA_Obj_length(FLA_Obj obj)
Definition: FLA_Query.c:116
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
FLA_Datatype FLA_Obj_datatype(FLA_Obj obj)
Definition: FLA_Query.c:13
int FLA_Datatype
Definition: FLA_type_defs.h:49
Definition: blis_type_defs.h:138

References FLA_LQ_UT_opc_var1(), FLA_LQ_UT_opd_var1(), FLA_LQ_UT_ops_var1(), FLA_LQ_UT_opz_var1(), FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_Obj_vector_inc(), and FLA_Obj_width().

Referenced by FLA_LQ_UT_internal().

◆ FLA_LQ_UT_opz_var1()

FLA_Error FLA_LQ_UT_opz_var1 ( int  m_A,
int  n_A,
dcomplex buff_A,
int  rs_A,
int  cs_A,
dcomplex buff_t,
int  inc_t 
)
232 {
233  int min_m_n = min( m_A, n_A );
234  int i;
235 
236  for ( i = 0; i < min_m_n; ++i )
237  {
238  dcomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
239  dcomplex* a21 = buff_A + (i )*cs_A + (i+1)*rs_A;
240  dcomplex* a12t = buff_A + (i+1)*cs_A + (i )*rs_A;
241  dcomplex* A22 = buff_A + (i+1)*cs_A + (i+1)*rs_A;
242 
243  dcomplex* tau1 = buff_t + (i )*inc_t;
244 
245  int m_ahead = m_A - i - 1;
246  int n_ahead = n_A - i - 1;
247 
248  /*------------------------------------------------------------*/
249 
250  // FLA_Househ2_UT( FLA_RIGHT, alpha11, a12t
251  // tau1 );
252  FLA_Househ2_UT_r_opz( n_ahead,
253  alpha11,
254  a12t, cs_A,
255  tau1 );
256 
257  // FLA_Apply_H2_UT( FLA_RIGHT, tau1, a12t, a21, A22 );
259  n_ahead,
260  tau1,
261  a12t, cs_A,
262  a21, rs_A,
263  A22, rs_A, cs_A );
264 
265  /*------------------------------------------------------------*/
266 
267  }
268 
269  return FLA_SUCCESS;
270 }
FLA_Error FLA_Apply_H2_UT_r_opz_var1(int n_u2h_A2, int m_a1, dcomplex *tau, dcomplex *u2h, int inc_u2h, dcomplex *a1, int inc_a1, dcomplex *A2, int rs_A2, int cs_A2)
Definition: FLA_Apply_H2_UT_r_opt_var1.c:327
FLA_Error FLA_Househ2_UT_r_opz(int m_x2, dcomplex *chi_1, dcomplex *x2, int inc_x2, dcomplex *tau)
Definition: FLA_Househ2_UT.c:693

References FLA_Apply_H2_UT_r_opz_var1(), FLA_Househ2_UT_r_opz(), and i.

Referenced by FLA_LQ_UT_opt_var1().