ruby-lapack 1.3

data/dev/defs/dlacon

@@ -0,0 +1,80 @@
+--- 
+:name: dlacon
+:md5sum: 7ed7cddcc0aa7b3a8a541f6acef383f1
+:category: :subroutine
+:arguments: 
+- n: 
+    :type: integer
+    :intent: input
+- v: 
+    :type: doublereal
+    :intent: workspace
+    :dims: 
+    - n
+- x: 
+    :type: doublereal
+    :intent: input/output
+    :dims: 
+    - n
+- isgn: 
+    :type: integer
+    :intent: workspace
+    :dims: 
+    - n
+- est: 
+    :type: doublereal
+    :intent: input/output
+- kase: 
+    :type: integer
+    :intent: input/output
+:substitutions: {}
+
+:fortran_help: "      SUBROUTINE DLACON( N, V, X, ISGN, EST, KASE )\n\n\
+  *  Purpose\n\
+  *  =======\n\
+  *\n\
+  *  DLACON estimates the 1-norm of a square, real matrix A.\n\
+  *  Reverse communication is used for evaluating matrix-vector products.\n\
+  *\n\n\
+  *  Arguments\n\
+  *  =========\n\
+  *\n\
+  *  N      (input) INTEGER\n\
+  *         The order of the matrix.  N >= 1.\n\
+  *\n\
+  *  V      (workspace) DOUBLE PRECISION array, dimension (N)\n\
+  *         On the final return, V = A*W,  where  EST = norm(V)/norm(W)\n\
+  *         (W is not returned).\n\
+  *\n\
+  *  X      (input/output) DOUBLE PRECISION array, dimension (N)\n\
+  *         On an intermediate return, X should be overwritten by\n\
+  *               A * X,   if KASE=1,\n\
+  *               A' * X,  if KASE=2,\n\
+  *         and DLACON must be re-called with all the other parameters\n\
+  *         unchanged.\n\
+  *\n\
+  *  ISGN   (workspace) INTEGER array, dimension (N)\n\
+  *\n\
+  *  EST    (input/output) DOUBLE PRECISION\n\
+  *         On entry with KASE = 1 or 2 and JUMP = 3, EST should be\n\
+  *         unchanged from the previous call to DLACON.\n\
+  *         On exit, EST is an estimate (a lower bound) for norm(A). \n\
+  *\n\
+  *  KASE   (input/output) INTEGER\n\
+  *         On the initial call to DLACON, KASE should be 0.\n\
+  *         On an intermediate return, KASE will be 1 or 2, indicating\n\
+  *         whether X should be overwritten by A * X  or A' * X.\n\
+  *         On the final return from DLACON, KASE will again be 0.\n\
+  *\n\n\
+  *  Further Details\n\
+  *  ======= =======\n\
+  *\n\
+  *  Contributed by Nick Higham, University of Manchester.\n\
+  *  Originally named SONEST, dated March 16, 1988.\n\
+  *\n\
+  *  Reference: N.J. Higham, \"FORTRAN codes for estimating the one-norm of\n\
+  *  a real or complex matrix, with applications to condition estimation\",\n\
+  *  ACM Trans. Math. Soft., vol. 14, no. 4, pp. 381-396, December 1988.\n\
+  *\n\
+  *  =====================================================================\n\
+  *\n"

data/dev/defs/dlacpy

@@ -0,0 +1,78 @@
+--- 
+:name: dlacpy
+:md5sum: 10366fbf2a10d962bba69e321b7c3c7b
+:category: :subroutine
+:arguments: 
+- uplo: 
+    :type: char
+    :intent: input
+- m: 
+    :type: integer
+    :intent: input
+- n: 
+    :type: integer
+    :intent: input
+- a: 
+    :type: doublereal
+    :intent: input
+    :dims: 
+    - lda
+    - n
+- lda: 
+    :type: integer
+    :intent: input
+- b: 
+    :type: doublereal
+    :intent: output
+    :dims: 
+    - ldb
+    - n
+- ldb: 
+    :type: integer
+    :intent: input
+:substitutions: 
+  ldb: MAX(1,m)
+:fortran_help: "      SUBROUTINE DLACPY( UPLO, M, N, A, LDA, B, LDB )\n\n\
+  *  Purpose\n\
+  *  =======\n\
+  *\n\
+  *  DLACPY copies all or part of a two-dimensional matrix A to another\n\
+  *  matrix B.\n\
+  *\n\n\
+  *  Arguments\n\
+  *  =========\n\
+  *\n\
+  *  UPLO    (input) CHARACTER*1\n\
+  *          Specifies the part of the matrix A to be copied to B.\n\
+  *          = 'U':      Upper triangular part\n\
+  *          = 'L':      Lower triangular part\n\
+  *          Otherwise:  All of the matrix A\n\
+  *\n\
+  *  M       (input) INTEGER\n\
+  *          The number of rows of the matrix A.  M >= 0.\n\
+  *\n\
+  *  N       (input) INTEGER\n\
+  *          The number of columns of the matrix A.  N >= 0.\n\
+  *\n\
+  *  A       (input) DOUBLE PRECISION array, dimension (LDA,N)\n\
+  *          The m by n matrix A.  If UPLO = 'U', only the upper triangle\n\
+  *          or trapezoid is accessed; if UPLO = 'L', only the lower\n\
+  *          triangle or trapezoid is accessed.\n\
+  *\n\
+  *  LDA     (input) INTEGER\n\
+  *          The leading dimension of the array A.  LDA >= max(1,M).\n\
+  *\n\
+  *  B       (output) DOUBLE PRECISION array, dimension (LDB,N)\n\
+  *          On exit, B = A in the locations specified by UPLO.\n\
+  *\n\
+  *  LDB     (input) INTEGER\n\
+  *          The leading dimension of the array B.  LDB >= max(1,M).\n\
+  *\n\n\
+  *  =====================================================================\n\
+  *\n\
+  *     .. Local Scalars ..\n      INTEGER            I, J\n\
+  *     ..\n\
+  *     .. External Functions ..\n      LOGICAL            LSAME\n      EXTERNAL           LSAME\n\
+  *     ..\n\
+  *     .. Intrinsic Functions ..\n      INTRINSIC          MIN\n\
+  *     ..\n"

data/dev/defs/dladiv

@@ -0,0 +1,57 @@
+--- 
+:name: dladiv
+:md5sum: 41da7dda9474acb9983598430ee07a80
+:category: :subroutine
+:arguments: 
+- a: 
+    :type: doublereal
+    :intent: input
+- b: 
+    :type: doublereal
+    :intent: input
+- c: 
+    :type: doublereal
+    :intent: input
+- d: 
+    :type: doublereal
+    :intent: input
+- p: 
+    :type: doublereal
+    :intent: output
+- q: 
+    :type: doublereal
+    :intent: output
+:substitutions: {}
+
+:fortran_help: "      SUBROUTINE DLADIV( A, B, C, D, P, Q )\n\n\
+  *  Purpose\n\
+  *  =======\n\
+  *\n\
+  *  DLADIV performs complex division in  real arithmetic\n\
+  *\n\
+  *                        a + i*b\n\
+  *             p + i*q = ---------\n\
+  *                        c + i*d\n\
+  *\n\
+  *  The algorithm is due to Robert L. Smith and can be found\n\
+  *  in D. Knuth, The art of Computer Programming, Vol.2, p.195\n\
+  *\n\n\
+  *  Arguments\n\
+  *  =========\n\
+  *\n\
+  *  A       (input) DOUBLE PRECISION\n\
+  *  B       (input) DOUBLE PRECISION\n\
+  *  C       (input) DOUBLE PRECISION\n\
+  *  D       (input) DOUBLE PRECISION\n\
+  *          The scalars a, b, c, and d in the above expression.\n\
+  *\n\
+  *  P       (output) DOUBLE PRECISION\n\
+  *  Q       (output) DOUBLE PRECISION\n\
+  *          The scalars p and q in the above expression.\n\
+  *\n\n\
+  *  =====================================================================\n\
+  *\n\
+  *     .. Local Scalars ..\n      DOUBLE PRECISION   E, F\n\
+  *     ..\n\
+  *     .. Intrinsic Functions ..\n      INTRINSIC          ABS\n\
+  *     ..\n"

data/dev/defs/dlae2

@@ -0,0 +1,66 @@
+--- 
+:name: dlae2
+:md5sum: 6634a79d68e158282cf44e0eded12a8d
+:category: :subroutine
+:arguments: 
+- a: 
+    :type: doublereal
+    :intent: input
+- b: 
+    :type: doublereal
+    :intent: input
+- c: 
+    :type: doublereal
+    :intent: input
+- rt1: 
+    :type: doublereal
+    :intent: output
+- rt2: 
+    :type: doublereal
+    :intent: output
+:substitutions: {}
+
+:fortran_help: "      SUBROUTINE DLAE2( A, B, C, RT1, RT2 )\n\n\
+  *  Purpose\n\
+  *  =======\n\
+  *\n\
+  *  DLAE2  computes the eigenvalues of a 2-by-2 symmetric matrix\n\
+  *     [  A   B  ]\n\
+  *     [  B   C  ].\n\
+  *  On return, RT1 is the eigenvalue of larger absolute value, and RT2\n\
+  *  is the eigenvalue of smaller absolute value.\n\
+  *\n\n\
+  *  Arguments\n\
+  *  =========\n\
+  *\n\
+  *  A       (input) DOUBLE PRECISION\n\
+  *          The (1,1) element of the 2-by-2 matrix.\n\
+  *\n\
+  *  B       (input) DOUBLE PRECISION\n\
+  *          The (1,2) and (2,1) elements of the 2-by-2 matrix.\n\
+  *\n\
+  *  C       (input) DOUBLE PRECISION\n\
+  *          The (2,2) element of the 2-by-2 matrix.\n\
+  *\n\
+  *  RT1     (output) DOUBLE PRECISION\n\
+  *          The eigenvalue of larger absolute value.\n\
+  *\n\
+  *  RT2     (output) DOUBLE PRECISION\n\
+  *          The eigenvalue of smaller absolute value.\n\
+  *\n\n\
+  *  Further Details\n\
+  *  ===============\n\
+  *\n\
+  *  RT1 is accurate to a few ulps barring over/underflow.\n\
+  *\n\
+  *  RT2 may be inaccurate if there is massive cancellation in the\n\
+  *  determinant A*C-B*B; higher precision or correctly rounded or\n\
+  *  correctly truncated arithmetic would be needed to compute RT2\n\
+  *  accurately in all cases.\n\
+  *\n\
+  *  Overflow is possible only if RT1 is within a factor of 5 of overflow.\n\
+  *  Underflow is harmless if the input data is 0 or exceeds\n\
+  *     underflow_threshold / macheps.\n\
+  *\n\
+  * =====================================================================\n\
+  *\n"

data/dev/defs/dlaebz

@@ -0,0 +1,292 @@
+--- 
+:name: dlaebz
+:md5sum: 667b9d1d21f6f805330766d1f74f173b
+:category: :subroutine
+:arguments: 
+- ijob: 
+    :type: integer
+    :intent: input
+- nitmax: 
+    :type: integer
+    :intent: input
+- n: 
+    :type: integer
+    :intent: input
+- mmax: 
+    :type: integer
+    :intent: input
+- minp: 
+    :type: integer
+    :intent: input
+- nbmin: 
+    :type: integer
+    :intent: input
+- abstol: 
+    :type: doublereal
+    :intent: input
+- reltol: 
+    :type: doublereal
+    :intent: input
+- pivmin: 
+    :type: doublereal
+    :intent: input
+- d: 
+    :type: doublereal
+    :intent: input
+    :dims: 
+    - n
+- e: 
+    :type: doublereal
+    :intent: input
+    :dims: 
+    - n
+- e2: 
+    :type: doublereal
+    :intent: input
+    :dims: 
+    - n
+- nval: 
+    :type: integer
+    :intent: input/output
+    :dims: 
+    - "(ijob==1||ijob==2) ? 0 : ijob==3 ? minp : 0"
+- ab: 
+    :type: doublereal
+    :intent: input/output
+    :dims: 
+    - mmax
+    - "2"
+- c: 
+    :type: doublereal
+    :intent: input/output
+    :dims: 
+    - "ijob==1 ? 0 : (ijob==2||ijob==3) ? mmax : 0"
+- mout: 
+    :type: integer
+    :intent: output
+- nab: 
+    :type: integer
+    :intent: input/output
+    :dims: 
+    - mmax
+    - "2"
+- work: 
+    :type: doublereal
+    :intent: workspace
+    :dims: 
+    - mmax
+- iwork: 
+    :type: integer
+    :intent: workspace
+    :dims: 
+    - mmax
+- info: 
+    :type: integer
+    :intent: output
+:substitutions: {}
+
+:fortran_help: "      SUBROUTINE DLAEBZ( IJOB, NITMAX, N, MMAX, MINP, NBMIN, ABSTOL, RELTOL, PIVMIN, D, E, E2, NVAL, AB, C, MOUT, NAB, WORK, IWORK, INFO )\n\n\
+  *  Purpose\n\
+  *  =======\n\
+  *\n\
+  *  DLAEBZ contains the iteration loops which compute and use the\n\
+  *  function N(w), which is the count of eigenvalues of a symmetric\n\
+  *  tridiagonal matrix T less than or equal to its argument  w.  It\n\
+  *  performs a choice of two types of loops:\n\
+  *\n\
+  *  IJOB=1, followed by\n\
+  *  IJOB=2: It takes as input a list of intervals and returns a list of\n\
+  *          sufficiently small intervals whose union contains the same\n\
+  *          eigenvalues as the union of the original intervals.\n\
+  *          The input intervals are (AB(j,1),AB(j,2)], j=1,...,MINP.\n\
+  *          The output interval (AB(j,1),AB(j,2)] will contain\n\
+  *          eigenvalues NAB(j,1)+1,...,NAB(j,2), where 1 <= j <= MOUT.\n\
+  *\n\
+  *  IJOB=3: It performs a binary search in each input interval\n\
+  *          (AB(j,1),AB(j,2)] for a point  w(j)  such that\n\
+  *          N(w(j))=NVAL(j), and uses  C(j)  as the starting point of\n\
+  *          the search.  If such a w(j) is found, then on output\n\
+  *          AB(j,1)=AB(j,2)=w.  If no such w(j) is found, then on output\n\
+  *          (AB(j,1),AB(j,2)] will be a small interval containing the\n\
+  *          point where N(w) jumps through NVAL(j), unless that point\n\
+  *          lies outside the initial interval.\n\
+  *\n\
+  *  Note that the intervals are in all cases half-open intervals,\n\
+  *  i.e., of the form  (a,b] , which includes  b  but not  a .\n\
+  *\n\
+  *  To avoid underflow, the matrix should be scaled so that its largest\n\
+  *  element is no greater than  overflow**(1/2) * underflow**(1/4)\n\
+  *  in absolute value.  To assure the most accurate computation\n\
+  *  of small eigenvalues, the matrix should be scaled to be\n\
+  *  not much smaller than that, either.\n\
+  *\n\
+  *  See W. Kahan \"Accurate Eigenvalues of a Symmetric Tridiagonal\n\
+  *  Matrix\", Report CS41, Computer Science Dept., Stanford\n\
+  *  University, July 21, 1966\n\
+  *\n\
+  *  Note: the arguments are, in general, *not* checked for unreasonable\n\
+  *  values.\n\
+  *\n\n\
+  *  Arguments\n\
+  *  =========\n\
+  *\n\
+  *  IJOB    (input) INTEGER\n\
+  *          Specifies what is to be done:\n\
+  *          = 1:  Compute NAB for the initial intervals.\n\
+  *          = 2:  Perform bisection iteration to find eigenvalues of T.\n\
+  *          = 3:  Perform bisection iteration to invert N(w), i.e.,\n\
+  *                to find a point which has a specified number of\n\
+  *                eigenvalues of T to its left.\n\
+  *          Other values will cause DLAEBZ to return with INFO=-1.\n\
+  *\n\
+  *  NITMAX  (input) INTEGER\n\
+  *          The maximum number of \"levels\" of bisection to be\n\
+  *          performed, i.e., an interval of width W will not be made\n\
+  *          smaller than 2^(-NITMAX) * W.  If not all intervals\n\
+  *          have converged after NITMAX iterations, then INFO is set\n\
+  *          to the number of non-converged intervals.\n\
+  *\n\
+  *  N       (input) INTEGER\n\
+  *          The dimension n of the tridiagonal matrix T.  It must be at\n\
+  *          least 1.\n\
+  *\n\
+  *  MMAX    (input) INTEGER\n\
+  *          The maximum number of intervals.  If more than MMAX intervals\n\
+  *          are generated, then DLAEBZ will quit with INFO=MMAX+1.\n\
+  *\n\
+  *  MINP    (input) INTEGER\n\
+  *          The initial number of intervals.  It may not be greater than\n\
+  *          MMAX.\n\
+  *\n\
+  *  NBMIN   (input) INTEGER\n\
+  *          The smallest number of intervals that should be processed\n\
+  *          using a vector loop.  If zero, then only the scalar loop\n\
+  *          will be used.\n\
+  *\n\
+  *  ABSTOL  (input) DOUBLE PRECISION\n\
+  *          The minimum (absolute) width of an interval.  When an\n\
+  *          interval is narrower than ABSTOL, or than RELTOL times the\n\
+  *          larger (in magnitude) endpoint, then it is considered to be\n\
+  *          sufficiently small, i.e., converged.  This must be at least\n\
+  *          zero.\n\
+  *\n\
+  *  RELTOL  (input) DOUBLE PRECISION\n\
+  *          The minimum relative width of an interval.  When an interval\n\
+  *          is narrower than ABSTOL, or than RELTOL times the larger (in\n\
+  *          magnitude) endpoint, then it is considered to be\n\
+  *          sufficiently small, i.e., converged.  Note: this should\n\
+  *          always be at least radix*machine epsilon.\n\
+  *\n\
+  *  PIVMIN  (input) DOUBLE PRECISION\n\
+  *          The minimum absolute value of a \"pivot\" in the Sturm\n\
+  *          sequence loop.  This *must* be at least  max |e(j)**2| *\n\
+  *          safe_min  and at least safe_min, where safe_min is at least\n\
+  *          the smallest number that can divide one without overflow.\n\
+  *\n\
+  *  D       (input) DOUBLE PRECISION array, dimension (N)\n\
+  *          The diagonal elements of the tridiagonal matrix T.\n\
+  *\n\
+  *  E       (input) DOUBLE PRECISION array, dimension (N)\n\
+  *          The offdiagonal elements of the tridiagonal matrix T in\n\
+  *          positions 1 through N-1.  E(N) is arbitrary.\n\
+  *\n\
+  *  E2      (input) DOUBLE PRECISION array, dimension (N)\n\
+  *          The squares of the offdiagonal elements of the tridiagonal\n\
+  *          matrix T.  E2(N) is ignored.\n\
+  *\n\
+  *  NVAL    (input/output) INTEGER array, dimension (MINP)\n\
+  *          If IJOB=1 or 2, not referenced.\n\
+  *          If IJOB=3, the desired values of N(w).  The elements of NVAL\n\
+  *          will be reordered to correspond with the intervals in AB.\n\
+  *          Thus, NVAL(j) on output will not, in general be the same as\n\
+  *          NVAL(j) on input, but it will correspond with the interval\n\
+  *          (AB(j,1),AB(j,2)] on output.\n\
+  *\n\
+  *  AB      (input/output) DOUBLE PRECISION array, dimension (MMAX,2)\n\
+  *          The endpoints of the intervals.  AB(j,1) is  a(j), the left\n\
+  *          endpoint of the j-th interval, and AB(j,2) is b(j), the\n\
+  *          right endpoint of the j-th interval.  The input intervals\n\
+  *          will, in general, be modified, split, and reordered by the\n\
+  *          calculation.\n\
+  *\n\
+  *  C       (input/output) DOUBLE PRECISION array, dimension (MMAX)\n\
+  *          If IJOB=1, ignored.\n\
+  *          If IJOB=2, workspace.\n\
+  *          If IJOB=3, then on input C(j) should be initialized to the\n\
+  *          first search point in the binary search.\n\
+  *\n\
+  *  MOUT    (output) INTEGER\n\
+  *          If IJOB=1, the number of eigenvalues in the intervals.\n\
+  *          If IJOB=2 or 3, the number of intervals output.\n\
+  *          If IJOB=3, MOUT will equal MINP.\n\
+  *\n\
+  *  NAB     (input/output) INTEGER array, dimension (MMAX,2)\n\
+  *          If IJOB=1, then on output NAB(i,j) will be set to N(AB(i,j)).\n\
+  *          If IJOB=2, then on input, NAB(i,j) should be set.  It must\n\
+  *             satisfy the condition:\n\
+  *             N(AB(i,1)) <= NAB(i,1) <= NAB(i,2) <= N(AB(i,2)),\n\
+  *             which means that in interval i only eigenvalues\n\
+  *             NAB(i,1)+1,...,NAB(i,2) will be considered.  Usually,\n\
+  *             NAB(i,j)=N(AB(i,j)), from a previous call to DLAEBZ with\n\
+  *             IJOB=1.\n\
+  *             On output, NAB(i,j) will contain\n\
+  *             max(na(k),min(nb(k),N(AB(i,j)))), where k is the index of\n\
+  *             the input interval that the output interval\n\
+  *             (AB(j,1),AB(j,2)] came from, and na(k) and nb(k) are the\n\
+  *             the input values of NAB(k,1) and NAB(k,2).\n\
+  *          If IJOB=3, then on output, NAB(i,j) contains N(AB(i,j)),\n\
+  *             unless N(w) > NVAL(i) for all search points  w , in which\n\
+  *             case NAB(i,1) will not be modified, i.e., the output\n\
+  *             value will be the same as the input value (modulo\n\
+  *             reorderings -- see NVAL and AB), or unless N(w) < NVAL(i)\n\
+  *             for all search points  w , in which case NAB(i,2) will\n\
+  *             not be modified.  Normally, NAB should be set to some\n\
+  *             distinctive value(s) before DLAEBZ is called.\n\
+  *\n\
+  *  WORK    (workspace) DOUBLE PRECISION array, dimension (MMAX)\n\
+  *          Workspace.\n\
+  *\n\
+  *  IWORK   (workspace) INTEGER array, dimension (MMAX)\n\
+  *          Workspace.\n\
+  *\n\
+  *  INFO    (output) INTEGER\n\
+  *          = 0:       All intervals converged.\n\
+  *          = 1--MMAX: The last INFO intervals did not converge.\n\
+  *          = MMAX+1:  More than MMAX intervals were generated.\n\
+  *\n\n\
+  *  Further Details\n\
+  *  ===============\n\
+  *\n\
+  *      This routine is intended to be called only by other LAPACK\n\
+  *  routines, thus the interface is less user-friendly.  It is intended\n\
+  *  for two purposes:\n\
+  *\n\
+  *  (a) finding eigenvalues.  In this case, DLAEBZ should have one or\n\
+  *      more initial intervals set up in AB, and DLAEBZ should be called\n\
+  *      with IJOB=1.  This sets up NAB, and also counts the eigenvalues.\n\
+  *      Intervals with no eigenvalues would usually be thrown out at\n\
+  *      this point.  Also, if not all the eigenvalues in an interval i\n\
+  *      are desired, NAB(i,1) can be increased or NAB(i,2) decreased.\n\
+  *      For example, set NAB(i,1)=NAB(i,2)-1 to get the largest\n\
+  *      eigenvalue.  DLAEBZ is then called with IJOB=2 and MMAX\n\
+  *      no smaller than the value of MOUT returned by the call with\n\
+  *      IJOB=1.  After this (IJOB=2) call, eigenvalues NAB(i,1)+1\n\
+  *      through NAB(i,2) are approximately AB(i,1) (or AB(i,2)) to the\n\
+  *      tolerance specified by ABSTOL and RELTOL.\n\
+  *\n\
+  *  (b) finding an interval (a',b'] containing eigenvalues w(f),...,w(l).\n\
+  *      In this case, start with a Gershgorin interval  (a,b).  Set up\n\
+  *      AB to contain 2 search intervals, both initially (a,b).  One\n\
+  *      NVAL element should contain  f-1  and the other should contain  l\n\
+  *      , while C should contain a and b, resp.  NAB(i,1) should be -1\n\
+  *      and NAB(i,2) should be N+1, to flag an error if the desired\n\
+  *      interval does not lie in (a,b).  DLAEBZ is then called with\n\
+  *      IJOB=3.  On exit, if w(f-1) < w(f), then one of the intervals --\n\
+  *      j -- will have AB(j,1)=AB(j,2) and NAB(j,1)=NAB(j,2)=f-1, while\n\
+  *      if, to the specified tolerance, w(f-k)=...=w(f+r), k > 0 and r\n\
+  *      >= 0, then the interval will have  N(AB(j,1))=NAB(j,1)=f-k and\n\
+  *      N(AB(j,2))=NAB(j,2)=f+r.  The cases w(l) < w(l+1) and\n\
+  *      w(l-r)=...=w(l+k) are handled similarly.\n\
+  *\n\
+  *  =====================================================================\n\
+  *\n"