libflame  revision_anchor
Functions
FLA_Hev_2x2.c File Reference

(r)

Functions

FLA_Error FLA_Hev_2x2 (FLA_Obj alpha11, FLA_Obj alpha21, FLA_Obj alpha22, FLA_Obj lambda1, FLA_Obj lambda2)
 
FLA_Error FLA_Hev_2x2_ops (float *alpha11, float *alpha21, float *alpha22, float *lambda1, float *lambda2)
 
FLA_Error FLA_Hev_2x2_opd (double *alpha11, double *alpha21, double *alpha22, double *lambda1, double *lambda2)
 

Function Documentation

◆ FLA_Hev_2x2()

FLA_Error FLA_Hev_2x2 ( FLA_Obj  alpha11,
FLA_Obj  alpha21,
FLA_Obj  alpha22,
FLA_Obj  lambda1,
FLA_Obj  lambda2 
)

References FLA_Hev_2x2_opd(), FLA_Hev_2x2_ops(), and FLA_Obj_datatype().

29 {
30  FLA_Datatype datatype;
31 
32  datatype = FLA_Obj_datatype( alpha11 );
33 
34  switch ( datatype )
35  {
36  case FLA_FLOAT:
37  {
38  float* buff_alpha11 = FLA_FLOAT_PTR( alpha11 );
39  float* buff_alpha21 = FLA_FLOAT_PTR( alpha21 );
40  float* buff_alpha22 = FLA_FLOAT_PTR( alpha22 );
41  float* buff_lambda1 = FLA_FLOAT_PTR( lambda1 );
42  float* buff_lambda2 = FLA_FLOAT_PTR( lambda2 );
43 
44  FLA_Hev_2x2_ops( buff_alpha11,
45  buff_alpha21,
46  buff_alpha22,
47  buff_lambda1,
48  buff_lambda2 );
49 
50  break;
51  }
52 
53  case FLA_DOUBLE:
54  {
55  double* buff_alpha11 = FLA_DOUBLE_PTR( alpha11 );
56  double* buff_alpha21 = FLA_DOUBLE_PTR( alpha21 );
57  double* buff_alpha22 = FLA_DOUBLE_PTR( alpha22 );
58  double* buff_lambda1 = FLA_DOUBLE_PTR( lambda1 );
59  double* buff_lambda2 = FLA_DOUBLE_PTR( lambda2 );
60 
61  FLA_Hev_2x2_opd( buff_alpha11,
62  buff_alpha21,
63  buff_alpha22,
64  buff_lambda1,
65  buff_lambda2 );
66 
67  break;
68  }
69 
70  case FLA_COMPLEX:
71  {
72  FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
73 
74  break;
75  }
76 
77  case FLA_DOUBLE_COMPLEX:
78  {
79  FLA_Check_error_code( FLA_NOT_YET_IMPLEMENTED );
80 
81  break;
82  }
83  }
84 
85  return FLA_SUCCESS;
86 }
FLA_Datatype FLA_Obj_datatype(FLA_Obj obj)
Definition: FLA_Query.c:13
int FLA_Datatype
Definition: FLA_type_defs.h:49
FLA_Error FLA_Hev_2x2_ops(float *alpha11, float *alpha21, float *alpha22, float *lambda1, float *lambda2)
Definition: FLA_Hev_2x2.c:90
FLA_Error FLA_Hev_2x2_opd(double *alpha11, double *alpha21, double *alpha22, double *lambda1, double *lambda2)
Definition: FLA_Hev_2x2.c:149

◆ FLA_Hev_2x2_opd()

FLA_Error FLA_Hev_2x2_opd ( double *  alpha11,
double *  alpha21,
double *  alpha22,
double *  lambda1,
double *  lambda2 
)

Referenced by FLA_Hev_2x2(), and FLA_Tevd_iteracc_n_opd_var1().

154 {
155  double a11, a21, a22;
156  double l1, l2;
157  double ab, acmn, acmx, adf, df, rt, sm, tb;
158 
159  a11 = *alpha11;
160  a21 = *alpha21;
161  a22 = *alpha22;
162 
163  sm = a11 + a22;
164  df = a11 - a22;
165  adf = fabs( df );
166  tb = a21 + a21;
167  ab = fabs( tb );
168 
169  if ( fabs( a11 ) > fabs( a22 ) )
170  {
171  acmx = a11;
172  acmn = a22;
173  }
174  else
175  {
176  acmx = a22;
177  acmn = a11;
178  }
179 
180  if ( adf > ab ) rt = adf * sqrt( 1.0 + ( ab / adf ) * ( ab / adf ) );
181  else if ( adf < ab ) rt = ab * sqrt( 1.0 + ( adf / ab ) * ( adf / ab ) );
182  else rt = ab * sqrt( 2.0 );
183 
184  if ( sm < 0.0 )
185  {
186  l1 = 0.5 * ( sm - rt );
187  l2 = ( acmx / l1 ) * acmn - ( a21 / l1 ) * a21;
188  }
189  else if ( sm > 0.0 )
190  {
191  l1 = 0.5 * ( sm + rt );
192  l2 = ( acmx / l1 ) * acmn - ( a21 / l1 ) * a21;
193  }
194  else
195  {
196  l1 = 0.5 * rt;
197  l2 = -0.5 * rt;
198  }
199 
200  *lambda1 = l1;
201  *lambda2 = l2;
202 
203  return FLA_SUCCESS;
204 }

◆ FLA_Hev_2x2_ops()

FLA_Error FLA_Hev_2x2_ops ( float *  alpha11,
float *  alpha21,
float *  alpha22,
float *  lambda1,
float *  lambda2 
)

Referenced by FLA_Hev_2x2().

95 {
96  float a11, a21, a22;
97  float l1, l2;
98  float ab, acmn, acmx, adf, df, rt, sm, tb;
99 
100  a11 = *alpha11;
101  a21 = *alpha21;
102  a22 = *alpha22;
103 
104  sm = a11 + a22;
105  df = a11 - a22;
106  adf = fabs( df );
107  tb = a21 + a21;
108  ab = fabs( tb );
109 
110  if ( fabs( a11 ) > fabs( a22 ) )
111  {
112  acmx = a11;
113  acmn = a22;
114  }
115  else
116  {
117  acmx = a22;
118  acmn = a11;
119  }
120 
121  if ( adf > ab ) rt = adf * sqrt( 1.0F + ( ab / adf ) * ( ab / adf ) );
122  else if ( adf < ab ) rt = ab * sqrt( 1.0F + ( adf / ab ) * ( adf / ab ) );
123  else rt = ab * sqrt( 2.0F );
124 
125  if ( sm < 0.0F )
126  {
127  l1 = 0.5F * ( sm - rt );
128  l2 = ( acmx / l1 ) * acmn - ( a21 / l1 ) * a21;
129  }
130  else if ( sm > 0.0F )
131  {
132  l1 = 0.5F * ( sm + rt );
133  l2 = ( acmx / l1 ) * acmn - ( a21 / l1 ) * a21;
134  }
135  else
136  {
137  l1 = 0.5F * rt;
138  l2 = -0.5F * rt;
139  }
140 
141  *lambda1 = l1;
142  *lambda2 = l2;
143 
144  return FLA_SUCCESS;
145 }