libflame revision_anchor
Functions
FLA_Hevv_2x2.c File Reference

(r)

Functions

FLA_Error FLA_Hevv_2x2 (FLA_Obj alpha11, FLA_Obj alpha21, FLA_Obj alpha22, FLA_Obj lambda1, FLA_Obj lambda2, FLA_Obj gamma1, FLA_Obj sigma1)
 
FLA_Error FLA_Hevv_2x2_ops (float *alpha11, float *alpha21, float *alpha22, float *lambda1, float *lambda2, float *gamma1, float *sigma1)
 
FLA_Error FLA_Hevv_2x2_opd (double *alpha11, double *alpha21, double *alpha22, double *lambda1, double *lambda2, double *gamma1, double *sigma1)
 
FLA_Error FLA_Hevv_2x2_opc (scomplex *alpha11, scomplex *alpha21, scomplex *alpha22, float *lambda1, float *lambda2, float *gamma1, scomplex *sigma1)
 
FLA_Error FLA_Hevv_2x2_opz (dcomplex *alpha11, dcomplex *alpha21, dcomplex *alpha22, double *lambda1, double *lambda2, double *gamma1, dcomplex *sigma1)
 

Function Documentation

◆ FLA_Hevv_2x2()

FLA_Error FLA_Hevv_2x2 ( FLA_Obj alpha11,
FLA_Obj alpha21,
FLA_Obj alpha22,
FLA_Obj lambda1,
FLA_Obj lambda2,
FLA_Obj gamma1,
FLA_Obj sigma1 )
38{
39 FLA_Datatype datatype;
40
41 datatype = FLA_Obj_datatype( alpha11 );
42
43 switch ( datatype )
44 {
45 case FLA_FLOAT:
46 {
47 float* buff_alpha11 = FLA_FLOAT_PTR( alpha11 );
48 float* buff_alpha21 = FLA_FLOAT_PTR( alpha21 );
49 float* buff_alpha22 = FLA_FLOAT_PTR( alpha22 );
50 float* buff_lambda1 = FLA_FLOAT_PTR( lambda1 );
51 float* buff_lambda2 = FLA_FLOAT_PTR( lambda2 );
52 float* buff_gamma1 = FLA_FLOAT_PTR( gamma1 );
53 float* buff_sigma1 = FLA_FLOAT_PTR( sigma1 );
54
55 FLA_Hevv_2x2_ops( buff_alpha11,
56 buff_alpha21,
57 buff_alpha22,
58 buff_lambda1,
59 buff_lambda2,
60 buff_gamma1,
61 buff_sigma1 );
62
63 break;
64 }
65
66 case FLA_DOUBLE:
67 {
68 double* buff_alpha11 = FLA_DOUBLE_PTR( alpha11 );
69 double* buff_alpha21 = FLA_DOUBLE_PTR( alpha21 );
70 double* buff_alpha22 = FLA_DOUBLE_PTR( alpha22 );
71 double* buff_lambda1 = FLA_DOUBLE_PTR( lambda1 );
72 double* buff_lambda2 = FLA_DOUBLE_PTR( lambda2 );
73 double* buff_gamma1 = FLA_DOUBLE_PTR( gamma1 );
74 double* buff_sigma1 = FLA_DOUBLE_PTR( sigma1 );
75
76 FLA_Hevv_2x2_opd( buff_alpha11,
77 buff_alpha21,
78 buff_alpha22,
79 buff_lambda1,
80 buff_lambda2,
81 buff_gamma1,
82 buff_sigma1 );
83
84 break;
85 }
86
87 case FLA_COMPLEX:
88 {
89 scomplex* buff_alpha11 = FLA_COMPLEX_PTR( alpha11 );
90 scomplex* buff_alpha21 = FLA_COMPLEX_PTR( alpha21 );
91 scomplex* buff_alpha22 = FLA_COMPLEX_PTR( alpha22 );
92 float* buff_lambda1 = FLA_FLOAT_PTR( lambda1 );
93 float* buff_lambda2 = FLA_FLOAT_PTR( lambda2 );
94 float* buff_gamma1 = FLA_FLOAT_PTR( gamma1 );
95 scomplex* buff_sigma1 = FLA_COMPLEX_PTR( sigma1 );
96
97 FLA_Hevv_2x2_opc( buff_alpha11,
98 buff_alpha21,
99 buff_alpha22,
100 buff_lambda1,
101 buff_lambda2,
102 buff_gamma1,
103 buff_sigma1 );
104
105 break;
106 }
107
108 case FLA_DOUBLE_COMPLEX:
109 {
110 dcomplex* buff_alpha11 = FLA_DOUBLE_COMPLEX_PTR( alpha11 );
111 dcomplex* buff_alpha21 = FLA_DOUBLE_COMPLEX_PTR( alpha21 );
112 dcomplex* buff_alpha22 = FLA_DOUBLE_COMPLEX_PTR( alpha22 );
113 double* buff_lambda1 = FLA_DOUBLE_PTR( lambda1 );
114 double* buff_lambda2 = FLA_DOUBLE_PTR( lambda2 );
115 double* buff_gamma1 = FLA_DOUBLE_PTR( gamma1 );
116 dcomplex* buff_sigma1 = FLA_DOUBLE_COMPLEX_PTR( sigma1 );
117
118 FLA_Hevv_2x2_opz( buff_alpha11,
119 buff_alpha21,
120 buff_alpha22,
121 buff_lambda1,
122 buff_lambda2,
123 buff_gamma1,
124 buff_sigma1 );
125
126 break;
127 }
128 }
129
130 return FLA_SUCCESS;
131}
FLA_Hevv_2x2_opd
FLA_Error FLA_Hevv_2x2_opd(double *alpha11, double *alpha21, double *alpha22, double *lambda1, double *lambda2, double *gamma1, double *sigma1)
Definition FLA_Hevv_2x2.c:249
FLA_Hevv_2x2_opc
FLA_Error FLA_Hevv_2x2_opc(scomplex *alpha11, scomplex *alpha21, scomplex *alpha22, float *lambda1, float *lambda2, float *gamma1, scomplex *sigma1)
Definition FLA_Hevv_2x2.c:363
FLA_Hevv_2x2_ops
FLA_Error FLA_Hevv_2x2_ops(float *alpha11, float *alpha21, float *alpha22, float *lambda1, float *lambda2, float *gamma1, float *sigma1)
Definition FLA_Hevv_2x2.c:135
FLA_Hevv_2x2_opz
FLA_Error FLA_Hevv_2x2_opz(dcomplex *alpha11, dcomplex *alpha21, dcomplex *alpha22, double *lambda1, double *lambda2, double *gamma1, dcomplex *sigma1)
Definition FLA_Hevv_2x2.c:378
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
scomplex
Definition blis_type_defs.h:133

References FLA_Hevv_2x2_opc(), FLA_Hevv_2x2_opd(), FLA_Hevv_2x2_ops(), FLA_Hevv_2x2_opz(), and FLA_Obj_datatype().

◆ FLA_Hevv_2x2_opc()

FLA_Error FLA_Hevv_2x2_opc ( scomplex * alpha11,
scomplex * alpha21,
scomplex * alpha22,
float * lambda1,
float * lambda2,
float * gamma1,
scomplex * sigma1 )
370{
371 FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
372
373 return FLA_SUCCESS;
374}

Referenced by FLA_Hevv_2x2().

◆ FLA_Hevv_2x2_opd()

FLA_Error FLA_Hevv_2x2_opd ( double * alpha11,
double * alpha21,
double * alpha22,
double * lambda1,
double * lambda2,
double * gamma1,
double * sigma1 )
256{
257 double a11, a21, a22;
258 double l1, l2;
259 double g1, s1;
260 double ab, acmn, acmx, acs, adf, cs, ct, df, rt, sm, tb, tn;
261 int sgn1, sgn2;
262
263 a11 = *alpha11;
264 a21 = *alpha21;
265 a22 = *alpha22;
266
267 // Compute the eigenvalues.
268
269 sm = a11 + a22;
270 df = a11 - a22;
271 adf = fabs( df );
272 tb = a21 + a21;
273 ab = fabs( tb );
274
275 if ( fabs( a11 ) > fabs( a22 ) )
276 {
277 acmx = a11;
278 acmn = a22;
279 }
280 else
281 {
282 acmx = a22;
283 acmn = a11;
284 }
285
286 if ( adf > ab ) rt = adf * sqrt( 1.0 + pow( ( ab / adf ), 2.0 ) );
287 else if ( adf < ab ) rt = ab * sqrt( 1.0 + pow( ( adf / ab ), 2.0 ) );
288 else rt = ab * sqrt( 2.0 );
289
290 if ( sm < 0.0 )
291 {
292 l1 = 0.5 * ( sm - rt );
293 l2 = ( acmx / l1 ) * acmn - ( a21 / l1 ) * a21;
294 sgn1 = -1;
295 }
296 else if ( sm > 0.0 )
297 {
298 l1 = 0.5 * ( sm + rt );
299 l2 = ( acmx / l1 ) * acmn - ( a21 / l1 ) * a21;
300 sgn1 = 1;
301 }
302 else
303 {
304 l1 = 0.5 * rt;
305 l2 = -0.5 * rt;
306 sgn1 = 1;
307 }
308
309 *lambda1 = l1;
310 *lambda2 = l2;
311
312 // Compute the eigenvector.
313
314 if ( df >= 0.0 )
315 {
316 cs = df + rt;
317 sgn2 = 1;
318 }
319 else
320 {
321 cs = df - rt;
322 sgn2 = -1;
323 }
324
325 acs = fabs( cs );
326
327 if ( acs > ab )
328 {
329 ct = -tb / cs;
330 s1 = 1.0 / sqrt( 1.0 + ct*ct );
331 g1 = ct * s1;
332 }
333 else
334 {
335 if ( ab == 0.0 )
336 {
337 g1 = 1.0;
338 s1 = 0.0;
339 }
340 else
341 {
342 tn = -cs / tb;
343 g1 = 1.0 / sqrt( 1.0 + tn*tn );
344 s1 = tn * g1;
345 }
346 }
347
348 if ( sgn1 == sgn2 )
349 {
350 tn = g1;
351 g1 = -s1;
352 s1 = tn;
353 }
354
355 *gamma1 = g1;
356 *sigma1 = s1;
357
358 return FLA_SUCCESS;
359}

Referenced by FLA_Hevv_2x2(), FLA_Tevd_iteracc_v_opd_var1(), and FLA_Tevd_iteracc_v_opd_var3().

◆ FLA_Hevv_2x2_ops()

FLA_Error FLA_Hevv_2x2_ops ( float * alpha11,
float * alpha21,
float * alpha22,
float * lambda1,
float * lambda2,
float * gamma1,
float * sigma1 )
142{
143 float a11, a21, a22;
144 float l1, l2;
145 float g1, s1;
146 float ab, acmn, acmx, acs, adf, cs, ct, df, rt, sm, tb, tn;
147 int sgn1, sgn2;
148
149 a11 = *alpha11;
150 a21 = *alpha21;
151 a22 = *alpha22;
152
153 // Compute the eigenvalues.
154
155 sm = a11 + a22;
156 df = a11 - a22;
157 adf = fabs( df );
158 tb = a21 + a21;
159 ab = fabs( tb );
160
161 if ( fabs( a11 ) > fabs( a22 ) )
162 {
163 acmx = a11;
164 acmn = a22;
165 }
166 else
167 {
168 acmx = a22;
169 acmn = a11;
170 }
171
172 if ( adf > ab ) rt = adf * sqrt( 1.0F + ( ab / adf ) * ( ab / adf ) );
173 else if ( adf < ab ) rt = ab * sqrt( 1.0F + ( adf / ab ) * ( adf / ab ) );
174 else rt = ab * sqrt( 2.0F );
175
176 if ( sm < 0.0F )
177 {
178 l1 = 0.5F * ( sm - rt );
179 l2 = ( acmx / l1 ) * acmn - ( a21 / l1 ) * a21;
180 sgn1 = -1;
181 }
182 else if ( sm > 0.0F )
183 {
184 l1 = 0.5F * ( sm + rt );
185 l2 = ( acmx / l1 ) * acmn - ( a21 / l1 ) * a21;
186 sgn1 = 1;
187 }
188 else
189 {
190 l1 = 0.5F * rt;
191 l2 = -0.5F * rt;
192 sgn1 = 1;
193 }
194
195 *lambda1 = l1;
196 *lambda2 = l2;
197
198 // Compute the eigenvector.
199
200 if ( df >= 0.0F )
201 {
202 cs = df + rt;
203 sgn2 = 1;
204 }
205 else
206 {
207 cs = df - rt;
208 sgn2 = -1;
209 }
210
211 acs = fabs( cs );
212
213 if ( acs > ab )
214 {
215 ct = -tb / cs;
216 s1 = 1.0F / sqrt( 1.0F + ct*ct );
217 g1 = ct * s1;
218 }
219 else
220 {
221 if ( ab == 0.0F )
222 {
223 g1 = 1.0F;
224 s1 = 0.0F;
225 }
226 else
227 {
228 tn = -cs / tb;
229 g1 = 1.0F / sqrt( 1.0F + tn*tn );
230 s1 = tn * g1;
231 }
232 }
233
234 if ( sgn1 == sgn2 )
235 {
236 tn = g1;
237 g1 = -s1;
238 s1 = tn;
239 }
240
241 *gamma1 = g1;
242 *sigma1 = s1;
243
244 return FLA_SUCCESS;
245}

Referenced by FLA_Hevv_2x2().

◆ FLA_Hevv_2x2_opz()

FLA_Error FLA_Hevv_2x2_opz ( dcomplex * alpha11,
dcomplex * alpha21,
dcomplex * alpha22,
double * lambda1,
double * lambda2,
double * gamma1,
dcomplex * sigma1 )
385{
386 FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
387
388 return FLA_SUCCESS;
389}

Referenced by FLA_Hevv_2x2().

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