libflame  revision_anchor
Functions
sormlq.c File Reference

(r)

Functions

int sormlq_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

◆ sormlq_fla()

int sormlq_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 
)

References sorml2_fla().

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