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 
)

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

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_Datatype FLA_Obj_datatype(FLA_Obj obj)
Definition: FLA_Query.c:13
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
Definition: blis_type_defs.h:132
int FLA_Datatype
Definition: FLA_type_defs.h:49
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_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
Definition: blis_type_defs.h:137
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_opc()

FLA_Error FLA_Hevv_2x2_opc ( scomplex alpha11,
scomplex alpha21,
scomplex alpha22,
float *  lambda1,
float *  lambda2,
float *  gamma1,
scomplex sigma1 
)

Referenced by FLA_Hevv_2x2().

370 {
371  FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
372 
373  return FLA_SUCCESS;
374 }

◆ FLA_Hevv_2x2_opd()

FLA_Error FLA_Hevv_2x2_opd ( double *  alpha11,
double *  alpha21,
double *  alpha22,
double *  lambda1,
double *  lambda2,
double *  gamma1,
double *  sigma1 
)

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

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 }

◆ FLA_Hevv_2x2_ops()

FLA_Error FLA_Hevv_2x2_ops ( float *  alpha11,
float *  alpha21,
float *  alpha22,
float *  lambda1,
float *  lambda2,
float *  gamma1,
float *  sigma1 
)

Referenced by FLA_Hevv_2x2().

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 }

◆ FLA_Hevv_2x2_opz()

FLA_Error FLA_Hevv_2x2_opz ( dcomplex alpha11,
dcomplex alpha21,
dcomplex alpha22,
double *  lambda1,
double *  lambda2,
double *  gamma1,
dcomplex sigma1 
)

Referenced by FLA_Hevv_2x2().

385 {
386  FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
387 
388  return FLA_SUCCESS;
389 }