text: /* zunghr.f -- translated by f2c (version 20061008).
     You must link the resulting object file with libf2c:
  	on Microsoft Windows system, link with libf2c.lib;
  	on Linux or Unix systems, link with .../path/to/libf2c.a -lm
  	or, if you install libf2c.a in a standard place, with -lf2c -lm
  	-- in that order, at the end of the command line, as in
  		cc *.o -lf2c -lm
  	Source for libf2c is in /netlib/f2c/libf2c.zip, e.g.,
  
  		http://www.netlib.org/f2c/libf2c.zip
  */
  
  #include "f2c.h"
  #include "blaswrap.h"
  
  /* Table of constant values */
  
  static integer c__1 = 1;
  static integer c_n1 = -1;
  
  /* Subroutine */ int zunghr_(integer *n, integer *ilo, integer *ihi, 
  	doublecomplex *a, integer *lda, doublecomplex *tau, doublecomplex *
  	work, integer *lwork, integer *info)
  {
      /* System generated locals */
      integer a_dim1, a_offset, i__1, i__2, i__3, i__4;
  
      /* Local variables */
      integer i__, j, nb, nh, iinfo;
      extern /* Subroutine */ int xerbla_(char *, integer *);
      extern integer ilaenv_(integer *, char *, char *, integer *, integer *, 
  	    integer *, integer *);
      integer lwkopt;
      logical lquery;
      extern /* Subroutine */ int zungqr_(integer *, integer *, integer *, 
  	    doublecomplex *, integer *, doublecomplex *, doublecomplex *, 
  	    integer *, integer *);
  
  
  /*  -- LAPACK routine (version 3.2) -- */
  /*     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd.. */
  /*     November 2006 */
  
  /*     .. Scalar Arguments .. */
  /*     .. */
  /*     .. Array Arguments .. */
  /*     .. */
  
  /*  Purpose */
  /*  ======= */
  
  /*  ZUNGHR generates a complex unitary matrix Q which is defined as the */
  /*  product of IHI-ILO elementary reflectors of order N, as returned by */
  /*  ZGEHRD: */
  
  /*  Q = H(ilo) H(ilo+1) . . . H(ihi-1). */
  
  /*  Arguments */
  /*  ========= */
  
  /*  N       (input) INTEGER */
  /*          The order of the matrix Q. N >= 0. */
  
  /*  ILO     (input) INTEGER */
  /*  IHI     (input) INTEGER */
  /*          ILO and IHI must have the same values as in the previous call */
  /*          of ZGEHRD. Q is equal to the unit matrix except in the */
  /*          submatrix Q(ilo+1:ihi,ilo+1:ihi). */
  /*          1 <= ILO <= IHI <= N, if N > 0; ILO=1 and IHI=0, if N=0. */
  
  /*  A       (input/output) COMPLEX*16 array, dimension (LDA,N) */
  /*          On entry, the vectors which define the elementary reflectors, */
  /*          as returned by ZGEHRD. */
  /*          On exit, the N-by-N unitary matrix Q. */
  
  /*  LDA     (input) INTEGER */
  /*          The leading dimension of the array A. LDA >= max(1,N). */
  
  /*  TAU     (input) COMPLEX*16 array, dimension (N-1) */
  /*          TAU(i) must contain the scalar factor of the elementary */
  /*          reflector H(i), as returned by ZGEHRD. */
  
  /*  WORK    (workspace/output) COMPLEX*16 array, dimension (MAX(1,LWORK)) */
  /*          On exit, if INFO = 0, WORK(1) returns the optimal LWORK. */
  
  /*  LWORK   (input) INTEGER */
  /*          The dimension of the array WORK. LWORK >= IHI-ILO. */
  /*          For optimum performance LWORK >= (IHI-ILO)*NB, where NB is */
  /*          the optimal blocksize. */
  
  /*          If LWORK = -1, then a workspace query is assumed; the routine */
  /*          only calculates the optimal size of the WORK array, returns */
  /*          this value as the first entry of the WORK array, and no error */
  /*          message related to LWORK is issued by XERBLA. */
  
  /*  INFO    (output) INTEGER */
  /*          = 0:  successful exit */
  /*          < 0:  if INFO = -i, the i-th argument had an illegal value */
  
  /*  ===================================================================== */
  
  /*     .. Parameters .. */
  /*     .. */
  /*     .. Local Scalars .. */
  /*     .. */
  /*     .. External Subroutines .. */
  /*     .. */
  /*     .. External Functions .. */
  /*     .. */
  /*     .. Intrinsic Functions .. */
  /*     .. */
  /*     .. Executable Statements .. */
  
  /*     Test the input arguments */
  
      /* Parameter adjustments */
      a_dim1 = *lda;
      a_offset = 1 + a_dim1;
      a -= a_offset;
      --tau;
      --work;
  
      /* Function Body */
      *info = 0;
      nh = *ihi - *ilo;
      lquery = *lwork == -1;
      if (*n < 0) {
  	*info = -1;
      } else if (*ilo < 1 || *ilo > max(1,*n)) {
  	*info = -2;
      } else if (*ihi < min(*ilo,*n) || *ihi > *n) {
  	*info = -3;
      } else if (*lda < max(1,*n)) {
  	*info = -5;
      } else if (*lwork < max(1,nh) && ! lquery) {
  	*info = -8;
      }
  
      if (*info == 0) {
  	nb = ilaenv_(&c__1, "ZUNGQR", " ", &nh, &nh, &nh, &c_n1);
  	lwkopt = max(1,nh) * nb;
  	work[1].r = (doublereal) lwkopt, work[1].i = 0.;
      }
  
      if (*info != 0) {
  	i__1 = -(*info);
  	xerbla_("ZUNGHR", &i__1);
  	return 0;
      } else if (lquery) {
  	return 0;
      }
  
  /*     Quick return if possible */
  
      if (*n == 0) {
  	work[1].r = 1., work[1].i = 0.;
  	return 0;
      }
  
  /*     Shift the vectors which define the elementary reflectors one */
  /*     column to the right, and set the first ilo and the last n-ihi */
  /*     rows and columns to those of the unit matrix */
  
      i__1 = *ilo + 1;
      for (j = *ihi; j >= i__1; --j) {
  	i__2 = j - 1;
  	for (i__ = 1; i__ <= i__2; ++i__) {
  	    i__3 = i__ + j * a_dim1;
  	    a[i__3].r = 0., a[i__3].i = 0.;
  /* L10: */
  	}
  	i__2 = *ihi;
  	for (i__ = j + 1; i__ <= i__2; ++i__) {
  	    i__3 = i__ + j * a_dim1;
  	    i__4 = i__ + (j - 1) * a_dim1;
  	    a[i__3].r = a[i__4].r, a[i__3].i = a[i__4].i;
  /* L20: */
  	}
  	i__2 = *n;
  	for (i__ = *ihi + 1; i__ <= i__2; ++i__) {
  	    i__3 = i__ + j * a_dim1;
  	    a[i__3].r = 0., a[i__3].i = 0.;
  /* L30: */
  	}
  /* L40: */
      }
      i__1 = *ilo;
      for (j = 1; j <= i__1; ++j) {
  	i__2 = *n;
  	for (i__ = 1; i__ <= i__2; ++i__) {
  	    i__3 = i__ + j * a_dim1;
  	    a[i__3].r = 0., a[i__3].i = 0.;
  /* L50: */
  	}
  	i__2 = j + j * a_dim1;
  	a[i__2].r = 1., a[i__2].i = 0.;
  /* L60: */
      }
      i__1 = *n;
      for (j = *ihi + 1; j <= i__1; ++j) {
  	i__2 = *n;
  	for (i__ = 1; i__ <= i__2; ++i__) {
  	    i__3 = i__ + j * a_dim1;
  	    a[i__3].r = 0., a[i__3].i = 0.;
  /* L70: */
  	}
  	i__2 = j + j * a_dim1;
  	a[i__2].r = 1., a[i__2].i = 0.;
  /* L80: */
      }
  
      if (nh > 0) {
  
  /*        Generate Q(ilo+1:ihi,ilo+1:ihi) */
  
  	zungqr_(&nh, &nh, &nh, &a[*ilo + 1 + (*ilo + 1) * a_dim1], lda, &tau[*
  		ilo], &work[1], lwork, &iinfo);
      }
      work[1].r = (doublereal) lwkopt, work[1].i = 0.;
      return 0;
  
  /*     End of ZUNGHR */
  
  } /* zunghr_ */
  