libflame revision_anchor
Functions
FLA_Trinv_ln_opt_var3.c File Reference

(r)

Functions

FLA_Error FLA_Trinv_ln_opt_var3 (FLA_Obj A)
 
FLA_Error FLA_Trinv_ln_ops_var3 (int mn_A, float *buff_A, int rs_A, int cs_A)
 
FLA_Error FLA_Trinv_ln_opd_var3 (int mn_A, double *buff_A, int rs_A, int cs_A)
 
FLA_Error FLA_Trinv_ln_opc_var3 (int mn_A, scomplex *buff_A, int rs_A, int cs_A)
 
FLA_Error FLA_Trinv_ln_opz_var3 (int mn_A, dcomplex *buff_A, int rs_A, int cs_A)
 

Function Documentation

◆ FLA_Trinv_ln_opc_var3()

FLA_Error FLA_Trinv_ln_opc_var3 ( int  mn_A,
scomplex *  buff_A,
int  rs_A,
int  cs_A 
)
188{
189 scomplex* buff_1 = FLA_COMPLEX_PTR( FLA_ONE );
190 scomplex alpha11_m1;
191 int i;
192
193 for ( i = 0; i < mn_A; ++i )
194 {
195 scomplex* a10t = buff_A + (0 )*cs_A + (i )*rs_A;
196 scomplex* A20 = buff_A + (0 )*cs_A + (i+1)*rs_A;
197 scomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
198 scomplex* a21 = buff_A + (i )*cs_A + (i+1)*rs_A;
199
200 int mn_ahead = mn_A - i - 1;
201 int mn_behind = i;
202
203 /*------------------------------------------------------------*/
204
205 // FLA_Scal_external( FLA_MINUS_ONE, a21 );
206 // FLA_Inv_scal_external( alpha11, a21 );
207 bl1_cneg2( alpha11, &alpha11_m1 );
208 bl1_cinvscalv( BLIS1_NO_CONJUGATE,
209 mn_ahead,
210 &alpha11_m1,
211 a21, rs_A );
212
213 // FLA_Ger_external( FLA_ONE, a21, a10t, A20 );
214 bl1_cger( BLIS1_NO_CONJUGATE,
215 BLIS1_NO_CONJUGATE,
216 mn_ahead,
217 mn_behind,
218 buff_1,
219 a21, rs_A,
220 a10t, cs_A,
221 A20, rs_A, cs_A );
222
223 // FLA_Inv_scal_external( alpha11, a10t );
224 bl1_cinvscalv( BLIS1_NO_CONJUGATE,
225 mn_behind,
226 alpha11,
227 a10t, cs_A );
228
229 // FLA_Invert( FLA_NO_CONJUGATE, alpha11 );
230 bl1_cinverts( BLIS1_NO_CONJUGATE,
231 alpha11 );
232
233 /*------------------------------------------------------------*/
234
235 }
236
237 return FLA_SUCCESS;
238}
FLA_ONE
FLA_Obj FLA_ONE
Definition FLA_Init.c:18
i
int i
Definition bl1_axmyv2.c:145
bl1_cger
void bl1_cger(conj1_t conjx, conj1_t conjy, int m, int n, scomplex *alpha, scomplex *x, int incx, scomplex *y, int incy, scomplex *a, int a_rs, int a_cs)
Definition bl1_ger.c:111
bl1_cinvscalv
void bl1_cinvscalv(conj1_t conj, int n, scomplex *alpha, scomplex *x, int incx)
Definition bl1_invscalv.c:52
bl1_cinverts
void bl1_cinverts(conj1_t conj, scomplex *alpha)
Definition bl1_inverts.c:27
BLIS1_NO_CONJUGATE
@ BLIS1_NO_CONJUGATE
Definition blis_type_defs.h:81
scomplex
Definition blis_type_defs.h:133

References bl1_cger(), bl1_cinverts(), bl1_cinvscalv(), BLIS1_NO_CONJUGATE, FLA_ONE, and i.

Referenced by FLA_Trinv_ln_opt_var3().

◆ FLA_Trinv_ln_opd_var3()

FLA_Error FLA_Trinv_ln_opd_var3 ( int  mn_A,
double *  buff_A,
int  rs_A,
int  cs_A 
)
132{
133 double* buff_1 = FLA_DOUBLE_PTR( FLA_ONE );
134 double alpha11_m1;
135 int i;
136
137 for ( i = 0; i < mn_A; ++i )
138 {
139 double* a10t = buff_A + (0 )*cs_A + (i )*rs_A;
140 double* A20 = buff_A + (0 )*cs_A + (i+1)*rs_A;
141 double* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
142 double* a21 = buff_A + (i )*cs_A + (i+1)*rs_A;
143
144 int mn_ahead = mn_A - i - 1;
145 int mn_behind = i;
146
147 /*------------------------------------------------------------*/
148
149 // FLA_Scal_external( FLA_MINUS_ONE, a21 );
150 // FLA_Inv_scal_external( alpha11, a21 );
151 bl1_dneg2( alpha11, &alpha11_m1 );
152 bl1_dinvscalv( BLIS1_NO_CONJUGATE,
153 mn_ahead,
154 &alpha11_m1,
155 a21, rs_A );
156
157 // FLA_Ger_external( FLA_ONE, a21, a10t, A20 );
158 bl1_dger( BLIS1_NO_CONJUGATE,
159 BLIS1_NO_CONJUGATE,
160 mn_ahead,
161 mn_behind,
162 buff_1,
163 a21, rs_A,
164 a10t, cs_A,
165 A20, rs_A, cs_A );
166
167 // FLA_Inv_scal_external( alpha11, a10t );
168 bl1_dinvscalv( BLIS1_NO_CONJUGATE,
169 mn_behind,
170 alpha11,
171 a10t, cs_A );
172
173 // FLA_Invert( FLA_NO_CONJUGATE, alpha11 );
174 bl1_dinverts( BLIS1_NO_CONJUGATE,
175 alpha11 );
176
177 /*------------------------------------------------------------*/
178
179 }
180
181 return FLA_SUCCESS;
182}
bl1_dger
void bl1_dger(conj1_t conjx, conj1_t conjy, int m, int n, double *alpha, double *x, int incx, double *y, int incy, double *a, int a_rs, int a_cs)
Definition bl1_ger.c:62
bl1_dinvscalv
void bl1_dinvscalv(conj1_t conj, int n, double *alpha, double *x, int incx)
Definition bl1_invscalv.c:26
bl1_dinverts
void bl1_dinverts(conj1_t conj, double *alpha)
Definition bl1_inverts.c:20

References bl1_dger(), bl1_dinverts(), bl1_dinvscalv(), BLIS1_NO_CONJUGATE, FLA_ONE, and i.

Referenced by FLA_Trinv_ln_opt_var3().

◆ FLA_Trinv_ln_ops_var3()

FLA_Error FLA_Trinv_ln_ops_var3 ( int  mn_A,
float *  buff_A,
int  rs_A,
int  cs_A 
)
76{
77 float* buff_1 = FLA_FLOAT_PTR( FLA_ONE );
78 float alpha11_m1;
79 int i;
80
81 for ( i = 0; i < mn_A; ++i )
82 {
83 float* a10t = buff_A + (0 )*cs_A + (i )*rs_A;
84 float* A20 = buff_A + (0 )*cs_A + (i+1)*rs_A;
85 float* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
86 float* a21 = buff_A + (i )*cs_A + (i+1)*rs_A;
87
88 int mn_ahead = mn_A - i - 1;
89 int mn_behind = i;
90
91 /*------------------------------------------------------------*/
92
93 // FLA_Scal_external( FLA_MINUS_ONE, a21 );
94 // FLA_Inv_scal_external( alpha11, a21 );
95 bl1_sneg2( alpha11, &alpha11_m1 );
96 bl1_sinvscalv( BLIS1_NO_CONJUGATE,
97 mn_ahead,
98 &alpha11_m1,
99 a21, rs_A );
100
101 // FLA_Ger_external( FLA_ONE, a21, a10t, A20 );
102 bl1_sger( BLIS1_NO_CONJUGATE,
103 BLIS1_NO_CONJUGATE,
104 mn_ahead,
105 mn_behind,
106 buff_1,
107 a21, rs_A,
108 a10t, cs_A,
109 A20, rs_A, cs_A );
110
111 // FLA_Inv_scal_external( alpha11, a10t );
112 bl1_sinvscalv( BLIS1_NO_CONJUGATE,
113 mn_behind,
114 alpha11,
115 a10t, cs_A );
116
117 // FLA_Invert( FLA_NO_CONJUGATE, alpha11 );
118 bl1_sinverts( BLIS1_NO_CONJUGATE,
119 alpha11 );
120
121 /*------------------------------------------------------------*/
122
123 }
124
125 return FLA_SUCCESS;
126}
bl1_sger
void bl1_sger(conj1_t conjx, conj1_t conjy, int m, int n, float *alpha, float *x, int incx, float *y, int incy, float *a, int a_rs, int a_cs)
Definition bl1_ger.c:13
bl1_sinvscalv
void bl1_sinvscalv(conj1_t conj, int n, float *alpha, float *x, int incx)
Definition bl1_invscalv.c:13
bl1_sinverts
void bl1_sinverts(conj1_t conj, float *alpha)
Definition bl1_inverts.c:13

References bl1_sger(), bl1_sinverts(), bl1_sinvscalv(), BLIS1_NO_CONJUGATE, FLA_ONE, and i.

Referenced by FLA_Trinv_ln_opt_var3().

◆ FLA_Trinv_ln_opt_var3()

FLA_Error FLA_Trinv_ln_opt_var3 ( FLA_Obj  A)
14{
15 FLA_Datatype datatype;
16 int mn_A;
17 int rs_A, cs_A;
18
19 datatype = FLA_Obj_datatype( A );
20
21 mn_A = FLA_Obj_length( A );
22 rs_A = FLA_Obj_row_stride( A );
23 cs_A = FLA_Obj_col_stride( A );
24
25
26 switch ( datatype )
27 {
28 case FLA_FLOAT:
29 {
30 float* buff_A = FLA_FLOAT_PTR( A );
31
32 FLA_Trinv_ln_ops_var3( mn_A,
33 buff_A, rs_A, cs_A );
34
35 break;
36 }
37
38 case FLA_DOUBLE:
39 {
40 double* buff_A = FLA_DOUBLE_PTR( A );
41
42 FLA_Trinv_ln_opd_var3( mn_A,
43 buff_A, rs_A, cs_A );
44
45 break;
46 }
47
48 case FLA_COMPLEX:
49 {
50 scomplex* buff_A = FLA_COMPLEX_PTR( A );
51
52 FLA_Trinv_ln_opc_var3( mn_A,
53 buff_A, rs_A, cs_A );
54
55 break;
56 }
57
58 case FLA_DOUBLE_COMPLEX:
59 {
60 dcomplex* buff_A = FLA_DOUBLE_COMPLEX_PTR( A );
61
62 FLA_Trinv_ln_opz_var3( mn_A,
63 buff_A, rs_A, cs_A );
64
65 break;
66 }
67 }
68
69 return FLA_SUCCESS;
70}
FLA_Trinv_ln_opd_var3
FLA_Error FLA_Trinv_ln_opd_var3(int mn_A, double *buff_A, int rs_A, int cs_A)
Definition FLA_Trinv_ln_opt_var3.c:130
FLA_Trinv_ln_opz_var3
FLA_Error FLA_Trinv_ln_opz_var3(int mn_A, dcomplex *buff_A, int rs_A, int cs_A)
Definition FLA_Trinv_ln_opt_var3.c:242
FLA_Trinv_ln_opc_var3
FLA_Error FLA_Trinv_ln_opc_var3(int mn_A, scomplex *buff_A, int rs_A, int cs_A)
Definition FLA_Trinv_ln_opt_var3.c:186
FLA_Trinv_ln_ops_var3
FLA_Error FLA_Trinv_ln_ops_var3(int mn_A, float *buff_A, int rs_A, int cs_A)
Definition FLA_Trinv_ln_opt_var3.c:74
FLA_Obj_row_stride
dim_t FLA_Obj_row_stride(FLA_Obj obj)
Definition FLA_Query.c:167
FLA_Obj_length
dim_t FLA_Obj_length(FLA_Obj obj)
Definition FLA_Query.c:116
FLA_Obj_col_stride
dim_t FLA_Obj_col_stride(FLA_Obj obj)
Definition FLA_Query.c:174
FLA_Obj_datatype
FLA_Datatype FLA_Obj_datatype(FLA_Obj obj)
Definition FLA_Query.c:13
FLA_Datatype
int FLA_Datatype
Definition FLA_type_defs.h:49
dcomplex
Definition blis_type_defs.h:138

References FLA_Obj_col_stride(), FLA_Obj_datatype(), FLA_Obj_length(), FLA_Obj_row_stride(), FLA_Trinv_ln_opc_var3(), FLA_Trinv_ln_opd_var3(), FLA_Trinv_ln_ops_var3(), FLA_Trinv_ln_opz_var3(), and i.

Referenced by FLA_Trinv_ln().

◆ FLA_Trinv_ln_opz_var3()

FLA_Error FLA_Trinv_ln_opz_var3 ( int  mn_A,
dcomplex *  buff_A,
int  rs_A,
int  cs_A 
)
244{
245 dcomplex* buff_1 = FLA_DOUBLE_COMPLEX_PTR( FLA_ONE );
246 dcomplex alpha11_m1;
247 int i;
248
249 for ( i = 0; i < mn_A; ++i )
250 {
251 dcomplex* a10t = buff_A + (0 )*cs_A + (i )*rs_A;
252 dcomplex* A20 = buff_A + (0 )*cs_A + (i+1)*rs_A;
253 dcomplex* alpha11 = buff_A + (i )*cs_A + (i )*rs_A;
254 dcomplex* a21 = buff_A + (i )*cs_A + (i+1)*rs_A;
255
256 int mn_ahead = mn_A - i - 1;
257 int mn_behind = i;
258
259 /*------------------------------------------------------------*/
260
261 // FLA_Scal_external( FLA_MINUS_ONE, a21 );
262 // FLA_Inv_scal_external( alpha11, a21 );
263 bl1_zneg2( alpha11, &alpha11_m1 );
264 bl1_zinvscalv( BLIS1_NO_CONJUGATE,
265 mn_ahead,
266 &alpha11_m1,
267 a21, rs_A );
268
269 // FLA_Ger_external( FLA_ONE, a21, a10t, A20 );
270 bl1_zger( BLIS1_NO_CONJUGATE,
271 BLIS1_NO_CONJUGATE,
272 mn_ahead,
273 mn_behind,
274 buff_1,
275 a21, rs_A,
276 a10t, cs_A,
277 A20, rs_A, cs_A );
278
279 // FLA_Inv_scal_external( alpha11, a10t );
280 bl1_zinvscalv( BLIS1_NO_CONJUGATE,
281 mn_behind,
282 alpha11,
283 a10t, cs_A );
284
285 // FLA_Invert( FLA_NO_CONJUGATE, alpha11 );
286 bl1_zinverts( BLIS1_NO_CONJUGATE,
287 alpha11 );
288
289 /*------------------------------------------------------------*/
290
291 }
292
293 return FLA_SUCCESS;
294}
bl1_zger
void bl1_zger(conj1_t conjx, conj1_t conjy, int m, int n, dcomplex *alpha, dcomplex *x, int incx, dcomplex *y, int incy, dcomplex *a, int a_rs, int a_cs)
Definition bl1_ger.c:194
bl1_zinvscalv
void bl1_zinvscalv(conj1_t conj, int n, dcomplex *alpha, dcomplex *x, int incx)
Definition bl1_invscalv.c:78
bl1_zinverts
void bl1_zinverts(conj1_t conj, dcomplex *alpha)
Definition bl1_inverts.c:44

References bl1_zger(), bl1_zinverts(), bl1_zinvscalv(), BLIS1_NO_CONJUGATE, FLA_ONE, and i.

Referenced by FLA_Trinv_ln_opt_var3().

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