libflame  revision_anchor
Functions
FLA_Sv_2x2.c File Reference

(r)

Functions

FLA_Error FLA_Sv_2x2 (FLA_Obj alpha11, FLA_Obj alpha12, FLA_Obj alpha22, FLA_Obj sigma1, FLA_Obj sigma2)
 
FLA_Error FLA_Sv_2x2_ops (float *alpha11, float *alpha12, float *alpha22, float *sigma1, float *sigma2)
 
FLA_Error FLA_Sv_2x2_opd (double *alpha11, double *alpha12, double *alpha22, double *sigma1, double *sigma2)
 

Function Documentation

◆ FLA_Sv_2x2()

FLA_Error FLA_Sv_2x2 ( FLA_Obj  alpha11,
FLA_Obj  alpha12,
FLA_Obj  alpha22,
FLA_Obj  sigma1,
FLA_Obj  sigma2 
)
36 {
37  FLA_Datatype datatype;
38 
39  datatype = FLA_Obj_datatype( alpha11 );
40 
41  switch ( datatype )
42  {
43  case FLA_FLOAT:
44  {
45  float* buff_alpha11 = FLA_FLOAT_PTR( alpha11 );
46  float* buff_alpha12 = FLA_FLOAT_PTR( alpha12 );
47  float* buff_alpha22 = FLA_FLOAT_PTR( alpha22 );
48  float* buff_sigma1 = FLA_FLOAT_PTR( sigma1 );
49  float* buff_sigma2 = FLA_FLOAT_PTR( sigma2 );
50 
51  FLA_Sv_2x2_ops( buff_alpha11,
52  buff_alpha12,
53  buff_alpha22,
54  buff_sigma1,
55  buff_sigma2 );
56 
57  break;
58  }
59 
60  case FLA_DOUBLE:
61  {
62  double* buff_alpha11 = FLA_DOUBLE_PTR( alpha11 );
63  double* buff_alpha12 = FLA_DOUBLE_PTR( alpha12 );
64  double* buff_alpha22 = FLA_DOUBLE_PTR( alpha22 );
65  double* buff_sigma1 = FLA_DOUBLE_PTR( sigma1 );
66  double* buff_sigma2 = FLA_DOUBLE_PTR( sigma2 );
67 
68  FLA_Sv_2x2_opd( buff_alpha11,
69  buff_alpha12,
70  buff_alpha22,
71  buff_sigma1,
72  buff_sigma2 );
73 
74  break;
75  }
76  }
77 
78  return FLA_SUCCESS;
79 }
FLA_Error FLA_Sv_2x2_opd(double *alpha11, double *alpha12, double *alpha22, double *sigma1, double *sigma2)
Definition: FLA_Sv_2x2.c:166
FLA_Error FLA_Sv_2x2_ops(float *alpha11, float *alpha12, float *alpha22, float *sigma1, float *sigma2)
Definition: FLA_Sv_2x2.c:83
FLA_Datatype FLA_Obj_datatype(FLA_Obj obj)
Definition: FLA_Query.c:13
int FLA_Datatype
Definition: FLA_type_defs.h:49

References FLA_Obj_datatype(), FLA_Sv_2x2_opd(), and FLA_Sv_2x2_ops().

◆ FLA_Sv_2x2_opd()

FLA_Error FLA_Sv_2x2_opd ( double *  alpha11,
double *  alpha12,
double *  alpha22,
double *  sigma1,
double *  sigma2 
)
171 {
172  double zero = 0.0;
173  double one = 1.0;
174  double two = 2.0;
175 
176  double f, g, h;
177  double as, at, au, c, fa, fhmin, fhmax, ga, ha;
178  double ssmin, ssmax;
179  double temp, temp2;
180 
181  f = *alpha11;
182  g = *alpha12;
183  h = *alpha22;
184 
185  fa = fabs( f );
186  ga = fabs( g );
187  ha = fabs( h );
188 
189  fhmin = min( fa, ha );
190  fhmax = max( fa, ha );
191 
192  if ( fhmin == zero )
193  {
194  ssmin = zero;
195 
196  if ( fhmax == zero )
197  ssmax = ga;
198  else
199  {
200  temp = min( fhmax, ga ) / max( fhmax, ga );
201  ssmax = max( fhmax, ga ) * sqrt( one + temp * temp );
202  }
203  }
204  else
205  {
206  if ( ga < fhmax )
207  {
208  as = one + fhmin / fhmax;
209  at = ( fhmax - fhmin ) / fhmax;
210  au = ( ga / fhmax ) * ( ga / fhmax );
211  c = two / ( sqrt( as * as + au ) + sqrt( at * at + au ) );
212  ssmin = fhmin * c;
213  ssmax = fhmax / c;
214  }
215  else
216  {
217  au = fhmax / ga;
218 
219  if ( au == zero )
220  {
221  ssmin = ( fhmin * fhmax ) / ga;
222  ssmax = ga;
223  }
224  else
225  {
226  as = one + fhmin / fhmax;
227  at = ( fhmax - fhmin ) / fhmax;
228  temp = as * au;
229  temp2 = at * au;
230  c = one / ( sqrt( one + temp * temp ) +
231  sqrt( one + temp2 * temp2 ) );
232  ssmin = ( fhmin * c ) * au;
233  ssmin = ssmin + ssmin;
234  ssmax = ga / ( c + c );
235  }
236  }
237  }
238 
239  // Save the output values.
240 
241  *sigma1 = ssmin;
242  *sigma2 = ssmax;
243 
244  return FLA_SUCCESS;
245 }
double temp2
Definition: bl1_axpyv2b.c:147
dcomplex temp
Definition: bl1_axpyv2b.c:301

References temp, and temp2.

Referenced by FLA_Bsvd_compute_shift_opd(), and FLA_Sv_2x2().

◆ FLA_Sv_2x2_ops()

FLA_Error FLA_Sv_2x2_ops ( float *  alpha11,
float *  alpha12,
float *  alpha22,
float *  sigma1,
float *  sigma2 
)
88 {
89  float zero = 0.0F;
90  float one = 1.0F;
91  float two = 2.0F;
92 
93  float f, g, h;
94  float as, at, au, c, fa, fhmin, fhmax, ga, ha;
95  float ssmin, ssmax;
96  float temp, temp2;
97 
98  f = *alpha11;
99  g = *alpha12;
100  h = *alpha22;
101 
102  fa = fabsf( f );
103  ga = fabsf( g );
104  ha = fabsf( h );
105 
106  fhmin = min( fa, ha );
107  fhmax = max( fa, ha );
108 
109  if ( fhmin == zero )
110  {
111  ssmin = zero;
112 
113  if ( fhmax == zero )
114  ssmax = ga;
115  else
116  {
117  temp = min( fhmax, ga ) / max( fhmax, ga );
118  ssmax = max( fhmax, ga ) * sqrtf( one + temp * temp );
119  }
120  }
121  else
122  {
123  if ( ga < fhmax )
124  {
125  as = one + fhmin / fhmax;
126  at = ( fhmax - fhmin ) / fhmax;
127  au = ( ga / fhmax ) * ( ga / fhmax );
128  c = two / ( sqrtf( as * as + au ) + sqrtf( at * at + au ) );
129  ssmin = fhmin * c;
130  ssmax = fhmax / c;
131  }
132  else
133  {
134  au = fhmax / ga;
135 
136  if ( au == zero )
137  {
138  ssmin = ( fhmin * fhmax ) / ga;
139  ssmax = ga;
140  }
141  else
142  {
143  as = one + fhmin / fhmax;
144  at = ( fhmax - fhmin ) / fhmax;
145  temp = as * au;
146  temp2 = at * au;
147  c = one / ( sqrtf( one + temp * temp ) +
148  sqrtf( one + temp2 * temp2 ) );
149  ssmin = ( fhmin * c ) * au;
150  ssmin = ssmin + ssmin;
151  ssmax = ga / ( c + c );
152  }
153  }
154  }
155 
156  // Save the output values.
157 
158  *sigma1 = ssmin;
159  *sigma2 = ssmax;
160 
161  return FLA_SUCCESS;
162 }

References temp, and temp2.

Referenced by FLA_Bsvd_compute_shift_ops(), and FLA_Sv_2x2().