libflame  revision_anchor
Functions
sormqr.c File Reference

(r)

Functions

int sormqr_fla (char *side, char *trans, integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, real *work, integer *lwork, integer *info)
 

Function Documentation

◆ sormqr_fla()

int sormqr_fla ( char *  side,
char *  trans,
integer m,
integer n,
integer k,
real a,
integer lda,
real tau,
real c__,
integer ldc,
real work,
integer lwork,
integer info 
)
170 {
171  /* System generated locals */
172  integer a_dim1, a_offset, c_dim1, c_offset, i__1, i__2, i__4, i__5;
173  char ch__1[2];
174  /* Builtin functions */
175  /* Subroutine */
176 
177  /* Local variables */
178  integer i__;
179  real t[4160] /* was [65][64] */
180  ;
181  integer i1, i2, i3, ib, ic, jc, nb, mi, ni, nq, nw, iws;
182  logical left;
183  extern logical lsame_(char *, char *);
184  integer nbmin, iinfo;
185  extern /* Subroutine */
186  int sorm2r_fla(char *, char *, integer *, integer *, integer *, real *, integer *, real *, real *, integer *, real *, integer *), slarfb_(char *, char *, char *, char * , integer *, integer *, integer *, real *, integer *, real *, integer *, real *, integer *, real *, integer *), xerbla_(char *, integer *);
187  extern integer ilaenv_(integer *, char *, char *, integer *, integer *, integer *, integer *);
188  extern /* Subroutine */
189  int slarft_(char *, char *, integer *, integer *, real *, integer *, real *, real *, integer *);
190  logical notran;
191  integer ldwork, lwkopt;
192  logical lquery;
193  /* -- LAPACK computational routine (version 3.4.0) -- */
194  /* -- LAPACK is a software package provided by Univ. of Tennessee, -- */
195  /* -- Univ. of California Berkeley, Univ. of Colorado Denver and NAG Ltd..-- */
196  /* November 2011 */
197  /* .. Scalar Arguments .. */
198  /* .. */
199  /* .. Array Arguments .. */
200  /* .. */
201  /* ===================================================================== */
202  /* .. Parameters .. */
203  /* .. */
204  /* .. Local Scalars .. */
205  /* .. */
206  /* .. Local Arrays .. */
207  /* .. */
208  /* .. External Functions .. */
209  /* .. */
210  /* .. External Subroutines .. */
211  /* .. */
212  /* .. Intrinsic Functions .. */
213  /* .. */
214  /* .. Executable Statements .. */
215  /* Test the input arguments */
216  /* Parameter adjustments */
217  a_dim1 = *lda;
218  a_offset = 1 + a_dim1;
219  a -= a_offset;
220  --tau;
221  c_dim1 = *ldc;
222  c_offset = 1 + c_dim1;
223  c__ -= c_offset;
224  --work;
225  /* Function Body */
226  *info = 0;
227  left = lsame_(side, "L");
228  notran = lsame_(trans, "N");
229  lquery = *lwork == -1;
230  /* NQ is the order of Q and NW is the minimum dimension of WORK */
231  if (left)
232  {
233  nq = *m;
234  nw = *n;
235  }
236  else
237  {
238  nq = *n;
239  nw = *m;
240  }
241  if (! left && ! lsame_(side, "R"))
242  {
243  *info = -1;
244  }
245  else if (! notran && ! lsame_(trans, "T"))
246  {
247  *info = -2;
248  }
249  else if (*m < 0)
250  {
251  *info = -3;
252  }
253  else if (*n < 0)
254  {
255  *info = -4;
256  }
257  else if (*k < 0 || *k > nq)
258  {
259  *info = -5;
260  }
261  else if (*lda < max(1,nq))
262  {
263  *info = -7;
264  }
265  else if (*ldc < max(1,*m))
266  {
267  *info = -10;
268  }
269  else if (*lwork < max(1,nw) && ! lquery)
270  {
271  *info = -12;
272  }
273  if (*info == 0)
274  {
275  /* Determine the block size. NB may be at most NBMAX, where NBMAX */
276  /* is used to define the local array T. */
277  /* Computing MIN */
278  i__1 = 64;
279  i__2 = ilaenv_(&c__1, "SORMQR", ch__1, m, n, k, &c_n1); // , expr subst
280  nb = min(i__1,i__2);
281  lwkopt = max(1,nw) * nb;
282  work[1] = (real) lwkopt;
283  }
284  if (*info != 0)
285  {
286  i__1 = -(*info);
287  xerbla_("SORMQR", &i__1);
288  return 0;
289  }
290  else if (lquery)
291  {
292  return 0;
293  }
294  /* Quick return if possible */
295  if (*m == 0 || *n == 0 || *k == 0)
296  {
297  work[1] = 1.f;
298  return 0;
299  }
300  nbmin = 2;
301  ldwork = nw;
302  if (nb > 1 && nb < *k)
303  {
304  iws = nw * nb;
305  if (*lwork < iws)
306  {
307  nb = *lwork / ldwork;
308  /* Computing MAX */
309  i__1 = 2;
310  i__2 = ilaenv_(&c__2, "SORMQR", ch__1, m, n, k, &c_n1); // , expr subst
311  nbmin = max(i__1,i__2);
312  }
313  }
314  else
315  {
316  iws = nw;
317  }
318  if (nb < nbmin || nb >= *k)
319  {
320  /* Use unblocked code */
321  sorm2r_fla(side, trans, m, n, k, &a[a_offset], lda, &tau[1], &c__[ c_offset], ldc, &work[1], &iinfo);
322  }
323  else
324  {
325  /* Use blocked code */
326  if (left && ! notran || ! left && notran)
327  {
328  i1 = 1;
329  i2 = *k;
330  i3 = nb;
331  }
332  else
333  {
334  i1 = (*k - 1) / nb * nb + 1;
335  i2 = 1;
336  i3 = -nb;
337  }
338  if (left)
339  {
340  ni = *n;
341  jc = 1;
342  }
343  else
344  {
345  mi = *m;
346  ic = 1;
347  }
348  i__1 = i2;
349  i__2 = i3;
350  for (i__ = i1;
351  i__2 < 0 ? i__ >= i__1 : i__ <= i__1;
352  i__ += i__2)
353  {
354  /* Computing MIN */
355  i__4 = nb;
356  i__5 = *k - i__ + 1; // , expr subst
357  ib = min(i__4,i__5);
358  /* Form the triangular factor of the block reflector */
359  /* H = H(i) H(i+1) . . . H(i+ib-1) */
360  i__4 = nq - i__ + 1;
361  slarft_("Forward", "Columnwise", &i__4, &ib, &a[i__ + i__ * a_dim1], lda, &tau[i__], t, &c__65) ;
362  if (left)
363  {
364  /* H or H**T is applied to C(i:m,1:n) */
365  mi = *m - i__ + 1;
366  ic = i__;
367  }
368  else
369  {
370  /* H or H**T is applied to C(1:m,i:n) */
371  ni = *n - i__ + 1;
372  jc = i__;
373  }
374  /* Apply H or H**T */
375  slarfb_(side, trans, "Forward", "Columnwise", &mi, &ni, &ib, &a[ i__ + i__ * a_dim1], lda, t, &c__65, &c__[ic + jc * c_dim1], ldc, &work[1], &ldwork);
376  /* L10: */
377  }
378  }
379  work[1] = (real) lwkopt;
380  return 0;
381  /* End of SORMQR */
382 }
int integer
Definition: FLA_f2c.h:25
int logical
Definition: FLA_f2c.h:36
float real
Definition: FLA_f2c.h:30
int sorm2r_fla(char *side, char *trans, integer *m, integer *n, integer *k, real *a, integer *lda, real *tau, real *c__, integer *ldc, real *work, integer *info)
Definition: sorm2r.c:151

References sorm2r_fla().

Referenced by sormhr_(), and sormtr_fla().