Skip Navigation Links
Numerical Libraries
Linear Algebra
Differential Equations
Optimization
Samples
Skip Navigation Links
Linear Algebra
CSLapack
CSBlas
   1:  #region Translated by Jose Antonio De Santiago-Castillo.
   2:   
   3:  //Translated by Jose Antonio De Santiago-Castillo. 
   4:  //E-mail:JAntonioDeSantiago@gmail.com
   5:  //Web: www.DotNumerics.com
   6:  //
   7:  //Fortran to C# Translation.
   8:  //Translated by:
   9:  //F2CSharp Version 0.71 (November 10, 2009)
  10:  //Code Optimizations: None
  11:  //
  12:  #endregion
  13:   
  14:  using System;
  15:  using DotNumerics.FortranLibrary;
  16:   
  17:  namespace DotNumerics.CSLapack
  18:  {
  19:      /// <summary>
  20:      /// -- LAPACK routine (version 3.1) --
  21:      /// Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
  22:      /// November 2006
  23:      /// Purpose
  24:      /// =======
  25:      /// 
  26:      /// DTREXC reorders the real Schur factorization of a real matrix
  27:      /// A = Q*T*Q**T, so that the diagonal block of T with row index IFST is
  28:      /// moved to row ILST.
  29:      /// 
  30:      /// The real Schur form T is reordered by an orthogonal similarity
  31:      /// transformation Z**T*T*Z, and optionally the matrix Q of Schur vectors
  32:      /// is updated by postmultiplying it with Z.
  33:      /// 
  34:      /// T must be in Schur canonical form (as returned by DHSEQR), that is,
  35:      /// block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each
  36:      /// 2-by-2 diagonal block has its diagonal elements equal and its
  37:      /// off-diagonal elements of opposite sign.
  38:      /// 
  39:      ///</summary>
  40:      public class DTREXC
  41:      {
  42:      
  43:   
  44:          #region Dependencies
  45:          
  46:          LSAME _lsame; DLAEXC _dlaexc; XERBLA _xerbla; 
  47:   
  48:          #endregion
  49:   
  50:   
  51:          #region Fields
  52:          
  53:          const double ZERO = 0.0E+0; bool WANTQ = false; int HERE = 0; int NBF = 0; int NBL = 0; int NBNEXT = 0; 
  54:   
  55:          #endregion
  56:   
  57:          public DTREXC(LSAME lsame, DLAEXC dlaexc, XERBLA xerbla)
  58:          {
  59:      
  60:   
  61:              #region Set Dependencies
  62:              
  63:              this._lsame = lsame; this._dlaexc = dlaexc; this._xerbla = xerbla; 
  64:   
  65:              #endregion
  66:   
  67:          }
  68:      
  69:          public DTREXC()
  70:          {
  71:      
  72:   
  73:              #region Dependencies (Initialization)
  74:              
  75:              LSAME lsame = new LSAME();
  76:              DLAMC3 dlamc3 = new DLAMC3();
  77:              DLASSQ dlassq = new DLASSQ();
  78:              DLAPY2 dlapy2 = new DLAPY2();
  79:              DNRM2 dnrm2 = new DNRM2();
  80:              DSCAL dscal = new DSCAL();
  81:              XERBLA xerbla = new XERBLA();
  82:              IDAMAX idamax = new IDAMAX();
  83:              DCOPY dcopy = new DCOPY();
  84:              DSWAP dswap = new DSWAP();
  85:              DROT drot = new DROT();
  86:              DLAMC1 dlamc1 = new DLAMC1(dlamc3);
  87:              DLAMC4 dlamc4 = new DLAMC4(dlamc3);
  88:              DLAMC5 dlamc5 = new DLAMC5(dlamc3);
  89:              DLAMC2 dlamc2 = new DLAMC2(dlamc3, dlamc1, dlamc4, dlamc5);
  90:              DLAMCH dlamch = new DLAMCH(lsame, dlamc2);
  91:              DLANGE dlange = new DLANGE(dlassq, lsame);
  92:              DLACPY dlacpy = new DLACPY(lsame);
  93:              DLANV2 dlanv2 = new DLANV2(dlamch, dlapy2);
  94:              DLARFG dlarfg = new DLARFG(dlamch, dlapy2, dnrm2, dscal);
  95:              DGEMV dgemv = new DGEMV(lsame, xerbla);
  96:              DGER dger = new DGER(xerbla);
  97:              DLARFX dlarfx = new DLARFX(lsame, dgemv, dger);
  98:              DLARTG dlartg = new DLARTG(dlamch);
  99:              DLASY2 dlasy2 = new DLASY2(idamax, dlamch, dcopy, dswap);
 100:              DLAEXC dlaexc = new DLAEXC(dlamch, dlange, dlacpy, dlanv2, dlarfg, dlarfx, dlartg, dlasy2, drot);
 101:   
 102:              #endregion
 103:   
 104:   
 105:              #region Set Dependencies
 106:              
 107:              this._lsame = lsame; this._dlaexc = dlaexc; this._xerbla = xerbla; 
 108:   
 109:              #endregion
 110:   
 111:          }
 112:          /// <summary>
 113:          /// Purpose
 114:          /// =======
 115:          /// 
 116:          /// DTREXC reorders the real Schur factorization of a real matrix
 117:          /// A = Q*T*Q**T, so that the diagonal block of T with row index IFST is
 118:          /// moved to row ILST.
 119:          /// 
 120:          /// The real Schur form T is reordered by an orthogonal similarity
 121:          /// transformation Z**T*T*Z, and optionally the matrix Q of Schur vectors
 122:          /// is updated by postmultiplying it with Z.
 123:          /// 
 124:          /// T must be in Schur canonical form (as returned by DHSEQR), that is,
 125:          /// block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each
 126:          /// 2-by-2 diagonal block has its diagonal elements equal and its
 127:          /// off-diagonal elements of opposite sign.
 128:          /// 
 129:          ///</summary>
 130:          /// <param name="COMPQ">
 131:          /// (input) CHARACTER*1
 132:          /// = 'V':  update the matrix Q of Schur vectors;
 133:          /// = 'N':  do not update Q.
 134:          ///</param>
 135:          /// <param name="N">
 136:          /// (input) INTEGER
 137:          /// The order of the matrix T. N .GE. 0.
 138:          ///</param>
 139:          /// <param name="T">
 140:          /// must be in Schur canonical form (as returned by DHSEQR), that is,
 141:          ///</param>
 142:          /// <param name="LDT">
 143:          /// (input) INTEGER
 144:          /// The leading dimension of the array T. LDT .GE. max(1,N).
 145:          ///</param>
 146:          /// <param name="Q">
 147:          /// (input/output) DOUBLE PRECISION array, dimension (LDQ,N)
 148:          /// On entry, if COMPQ = 'V', the matrix Q of Schur vectors.
 149:          /// On exit, if COMPQ = 'V', Q has been postmultiplied by the
 150:          /// orthogonal transformation matrix Z which reorders T.
 151:          /// If COMPQ = 'N', Q is not referenced.
 152:          ///</param>
 153:          /// <param name="LDQ">
 154:          /// (input) INTEGER
 155:          /// The leading dimension of the array Q.  LDQ .GE. max(1,N).
 156:          ///</param>
 157:          /// <param name="IFST">
 158:          /// (input/output) INTEGER
 159:          ///</param>
 160:          /// <param name="ILST">
 161:          /// (input/output) INTEGER
 162:          /// Specify the reordering of the diagonal blocks of T.
 163:          /// The block with row index IFST is moved to row ILST, by a
 164:          /// sequence of transpositions between adjacent blocks.
 165:          /// On exit, if IFST pointed on entry to the second row of a
 166:          /// 2-by-2 block, it is changed to point to the first row; ILST
 167:          /// always points to the first row of the block in its final
 168:          /// position (which may differ from its input value by +1 or -1).
 169:          /// 1 .LE. IFST .LE. N; 1 .LE. ILST .LE. N.
 170:          ///</param>
 171:          /// <param name="WORK">
 172:          /// (workspace) DOUBLE PRECISION array, dimension (N)
 173:          ///</param>
 174:          /// <param name="INFO">
 175:          /// (output) INTEGER
 176:          /// = 0:  successful exit
 177:          /// .LT. 0:  if INFO = -i, the i-th argument had an illegal value
 178:          /// = 1:  two adjacent blocks were too close to swap (the problem
 179:          /// is very ill-conditioned); T may have been partially
 180:          /// reordered, and ILST points to the first row of the
 181:          /// current position of the block being moved.
 182:          ///</param>
 183:          public void Run(string COMPQ, int N, ref double[] T, int offset_t, int LDT, ref double[] Q, int offset_q, int LDQ
 184:                           , ref int IFST, ref int ILST, ref double[] WORK, int offset_work, ref int INFO)
 185:          {
 186:   
 187:              #region Array Index Correction
 188:              
 189:               int o_t = -1 - LDT + offset_t;  int o_q = -1 - LDQ + offset_q;  int o_work = -1 + offset_work; 
 190:   
 191:              #endregion
 192:   
 193:   
 194:              #region Strings
 195:              
 196:              COMPQ = COMPQ.Substring(0, 1);  
 197:   
 198:              #endregion
 199:   
 200:   
 201:              #region Prolog
 202:              
 203:              // *
 204:              // *  -- LAPACK routine (version 3.1) --
 205:              // *     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
 206:              // *     November 2006
 207:              // *
 208:              // *     .. Scalar Arguments ..
 209:              // *     ..
 210:              // *     .. Array Arguments ..
 211:              // *     ..
 212:              // *
 213:              // *  Purpose
 214:              // *  =======
 215:              // *
 216:              // *  DTREXC reorders the real Schur factorization of a real matrix
 217:              // *  A = Q*T*Q**T, so that the diagonal block of T with row index IFST is
 218:              // *  moved to row ILST.
 219:              // *
 220:              // *  The real Schur form T is reordered by an orthogonal similarity
 221:              // *  transformation Z**T*T*Z, and optionally the matrix Q of Schur vectors
 222:              // *  is updated by postmultiplying it with Z.
 223:              // *
 224:              // *  T must be in Schur canonical form (as returned by DHSEQR), that is,
 225:              // *  block upper triangular with 1-by-1 and 2-by-2 diagonal blocks; each
 226:              // *  2-by-2 diagonal block has its diagonal elements equal and its
 227:              // *  off-diagonal elements of opposite sign.
 228:              // *
 229:              // *  Arguments
 230:              // *  =========
 231:              // *
 232:              // *  COMPQ   (input) CHARACTER*1
 233:              // *          = 'V':  update the matrix Q of Schur vectors;
 234:              // *          = 'N':  do not update Q.
 235:              // *
 236:              // *  N       (input) INTEGER
 237:              // *          The order of the matrix T. N >= 0.
 238:              // *
 239:              // *  T       (input/output) DOUBLE PRECISION array, dimension (LDT,N)
 240:              // *          On entry, the upper quasi-triangular matrix T, in Schur
 241:              // *          Schur canonical form.
 242:              // *          On exit, the reordered upper quasi-triangular matrix, again
 243:              // *          in Schur canonical form.
 244:              // *
 245:              // *  LDT     (input) INTEGER
 246:              // *          The leading dimension of the array T. LDT >= max(1,N).
 247:              // *
 248:              // *  Q       (input/output) DOUBLE PRECISION array, dimension (LDQ,N)
 249:              // *          On entry, if COMPQ = 'V', the matrix Q of Schur vectors.
 250:              // *          On exit, if COMPQ = 'V', Q has been postmultiplied by the
 251:              // *          orthogonal transformation matrix Z which reorders T.
 252:              // *          If COMPQ = 'N', Q is not referenced.
 253:              // *
 254:              // *  LDQ     (input) INTEGER
 255:              // *          The leading dimension of the array Q.  LDQ >= max(1,N).
 256:              // *
 257:              // *  IFST    (input/output) INTEGER
 258:              // *  ILST    (input/output) INTEGER
 259:              // *          Specify the reordering of the diagonal blocks of T.
 260:              // *          The block with row index IFST is moved to row ILST, by a
 261:              // *          sequence of transpositions between adjacent blocks.
 262:              // *          On exit, if IFST pointed on entry to the second row of a
 263:              // *          2-by-2 block, it is changed to point to the first row; ILST
 264:              // *          always points to the first row of the block in its final
 265:              // *          position (which may differ from its input value by +1 or -1).
 266:              // *          1 <= IFST <= N; 1 <= ILST <= N.
 267:              // *
 268:              // *  WORK    (workspace) DOUBLE PRECISION array, dimension (N)
 269:              // *
 270:              // *  INFO    (output) INTEGER
 271:              // *          = 0:  successful exit
 272:              // *          < 0:  if INFO = -i, the i-th argument had an illegal value
 273:              // *          = 1:  two adjacent blocks were too close to swap (the problem
 274:              // *                is very ill-conditioned); T may have been partially
 275:              // *                reordered, and ILST points to the first row of the
 276:              // *                current position of the block being moved.
 277:              // *
 278:              // *  =====================================================================
 279:              // *
 280:              // *     .. Parameters ..
 281:              // *     ..
 282:              // *     .. Local Scalars ..
 283:              // *     ..
 284:              // *     .. External Functions ..
 285:              // *     ..
 286:              // *     .. External Subroutines ..
 287:              // *     ..
 288:              // *     .. Intrinsic Functions ..
 289:              //      INTRINSIC          MAX;
 290:              // *     ..
 291:              // *     .. Executable Statements ..
 292:              // *
 293:              // *     Decode and test the input arguments.
 294:              // *
 295:   
 296:              #endregion
 297:   
 298:   
 299:              #region Body
 300:              
 301:              INFO = 0;
 302:              WANTQ = this._lsame.Run(COMPQ, "V");
 303:              if (!WANTQ && !this._lsame.Run(COMPQ, "N"))
 304:              {
 305:                  INFO =  - 1;
 306:              }
 307:              else
 308:              {
 309:                  if (N < 0)
 310:                  {
 311:                      INFO =  - 2;
 312:                  }
 313:                  else
 314:                  {
 315:                      if (LDT < Math.Max(1, N))
 316:                      {
 317:                          INFO =  - 4;
 318:                      }
 319:                      else
 320:                      {
 321:                          if (LDQ < 1 || (WANTQ && LDQ < Math.Max(1, N)))
 322:                          {
 323:                              INFO =  - 6;
 324:                          }
 325:                          else
 326:                          {
 327:                              if (IFST < 1 || IFST > N)
 328:                              {
 329:                                  INFO =  - 7;
 330:                              }
 331:                              else
 332:                              {
 333:                                  if (ILST < 1 || ILST > N)
 334:                                  {
 335:                                      INFO =  - 8;
 336:                                  }
 337:                              }
 338:                          }
 339:                      }
 340:                  }
 341:              }
 342:              if (INFO != 0)
 343:              {
 344:                  this._xerbla.Run("DTREXC",  - INFO);
 345:                  return;
 346:              }
 347:              // *
 348:              // *     Quick return if possible
 349:              // *
 350:              if (N <= 1) return;
 351:              // *
 352:              // *     Determine the first row of specified block
 353:              // *     and find out it is 1 by 1 or 2 by 2.
 354:              // *
 355:              if (IFST > 1)
 356:              {
 357:                  if (T[IFST+(IFST - 1) * LDT + o_t] != ZERO) IFST = IFST - 1;
 358:              }
 359:              NBF = 1;
 360:              if (IFST < N)
 361:              {
 362:                  if (T[IFST + 1+IFST * LDT + o_t] != ZERO) NBF = 2;
 363:              }
 364:              // *
 365:              // *     Determine the first row of the final block
 366:              // *     and find out it is 1 by 1 or 2 by 2.
 367:              // *
 368:              if (ILST > 1)
 369:              {
 370:                  if (T[ILST+(ILST - 1) * LDT + o_t] != ZERO) ILST = ILST - 1;
 371:              }
 372:              NBL = 1;
 373:              if (ILST < N)
 374:              {
 375:                  if (T[ILST + 1+ILST * LDT + o_t] != ZERO) NBL = 2;
 376:              }
 377:              // *
 378:              if (IFST == ILST) return;
 379:              // *
 380:              if (IFST < ILST)
 381:              {
 382:                  // *
 383:                  // *        Update ILST
 384:                  // *
 385:                  if (NBF == 2 && NBL == 1) ILST = ILST - 1;
 386:                  if (NBF == 1 && NBL == 2) ILST = ILST + 1;
 387:                  // *
 388:                  HERE = IFST;
 389:                  // *
 390:              LABEL10:;
 391:                  // *
 392:                  // *        Swap block with next one below
 393:                  // *
 394:                  if (NBF == 1 || NBF == 2)
 395:                  {
 396:                      // *
 397:                      // *           Current block either 1 by 1 or 2 by 2
 398:                      // *
 399:                      NBNEXT = 1;
 400:                      if (HERE + NBF + 1 <= N)
 401:                      {
 402:                          if (T[HERE + NBF + 1+(HERE + NBF) * LDT + o_t] != ZERO) NBNEXT = 2;
 403:                      }
 404:                      this._dlaexc.Run(WANTQ, N, ref T, offset_t, LDT, ref Q, offset_q, LDQ
 405:                                       , HERE, NBF, NBNEXT, ref WORK, offset_work, ref INFO);
 406:                      if (INFO != 0)
 407:                      {
 408:                          ILST = HERE;
 409:                          return;
 410:                      }
 411:                      HERE = HERE + NBNEXT;
 412:                      // *
 413:                      // *           Test if 2 by 2 block breaks into two 1 by 1 blocks
 414:                      // *
 415:                      if (NBF == 2)
 416:                      {
 417:                          if (T[HERE + 1+HERE * LDT + o_t] == ZERO) NBF = 3;
 418:                      }
 419:                      // *
 420:                  }
 421:                  else
 422:                  {
 423:                      // *
 424:                      // *           Current block consists of two 1 by 1 blocks each of which
 425:                      // *           must be swapped individually
 426:                      // *
 427:                      NBNEXT = 1;
 428:                      if (HERE + 3 <= N)
 429:                      {
 430:                          if (T[HERE + 3+(HERE + 2) * LDT + o_t] != ZERO) NBNEXT = 2;
 431:                      }
 432:                      this._dlaexc.Run(WANTQ, N, ref T, offset_t, LDT, ref Q, offset_q, LDQ
 433:                                       , HERE + 1, 1, NBNEXT, ref WORK, offset_work, ref INFO);
 434:                      if (INFO != 0)
 435:                      {
 436:                          ILST = HERE;
 437:                          return;
 438:                      }
 439:                      if (NBNEXT == 1)
 440:                      {
 441:                          // *
 442:                          // *              Swap two 1 by 1 blocks, no problems possible
 443:                          // *
 444:                          this._dlaexc.Run(WANTQ, N, ref T, offset_t, LDT, ref Q, offset_q, LDQ
 445:                                           , HERE, 1, NBNEXT, ref WORK, offset_work, ref INFO);
 446:                          HERE = HERE + 1;
 447:                      }
 448:                      else
 449:                      {
 450:                          // *
 451:                          // *              Recompute NBNEXT in case 2 by 2 split
 452:                          // *
 453:                          if (T[HERE + 2+(HERE + 1) * LDT + o_t] == ZERO) NBNEXT = 1;
 454:                          if (NBNEXT == 2)
 455:                          {
 456:                              // *
 457:                              // *                 2 by 2 Block did not split
 458:                              // *
 459:                              this._dlaexc.Run(WANTQ, N, ref T, offset_t, LDT, ref Q, offset_q, LDQ
 460:                                               , HERE, 1, NBNEXT, ref WORK, offset_work, ref INFO);
 461:                              if (INFO != 0)
 462:                              {
 463:                                  ILST = HERE;
 464:                                  return;
 465:                              }
 466:                              HERE = HERE + 2;
 467:                          }
 468:                          else
 469:                          {
 470:                              // *
 471:                              // *                 2 by 2 Block did split
 472:                              // *
 473:                              this._dlaexc.Run(WANTQ, N, ref T, offset_t, LDT, ref Q, offset_q, LDQ
 474:                                               , HERE, 1, 1, ref WORK, offset_work, ref INFO);
 475:                              this._dlaexc.Run(WANTQ, N, ref T, offset_t, LDT, ref Q, offset_q, LDQ
 476:                                               , HERE + 1, 1, 1, ref WORK, offset_work, ref INFO);
 477:                              HERE = HERE + 2;
 478:                          }
 479:                      }
 480:                  }
 481:                  if (HERE < ILST) goto LABEL10;
 482:                  // *
 483:              }
 484:              else
 485:              {
 486:                  // *
 487:                  HERE = IFST;
 488:              LABEL20:;
 489:                  // *
 490:                  // *        Swap block with next one above
 491:                  // *
 492:                  if (NBF == 1 || NBF == 2)
 493:                  {
 494:                      // *
 495:                      // *           Current block either 1 by 1 or 2 by 2
 496:                      // *
 497:                      NBNEXT = 1;
 498:                      if (HERE >= 3)
 499:                      {
 500:                          if (T[HERE - 1+(HERE - 2) * LDT + o_t] != ZERO) NBNEXT = 2;
 501:                      }
 502:                      this._dlaexc.Run(WANTQ, N, ref T, offset_t, LDT, ref Q, offset_q, LDQ
 503:                                       , HERE - NBNEXT, NBNEXT, NBF, ref WORK, offset_work, ref INFO);
 504:                      if (INFO != 0)
 505:                      {
 506:                          ILST = HERE;
 507:                          return;
 508:                      }
 509:                      HERE = HERE - NBNEXT;
 510:                      // *
 511:                      // *           Test if 2 by 2 block breaks into two 1 by 1 blocks
 512:                      // *
 513:                      if (NBF == 2)
 514:                      {
 515:                          if (T[HERE + 1+HERE * LDT + o_t] == ZERO) NBF = 3;
 516:                      }
 517:                      // *
 518:                  }
 519:                  else
 520:                  {
 521:                      // *
 522:                      // *           Current block consists of two 1 by 1 blocks each of which
 523:                      // *           must be swapped individually
 524:                      // *
 525:                      NBNEXT = 1;
 526:                      if (HERE >= 3)
 527:                      {
 528:                          if (T[HERE - 1+(HERE - 2) * LDT + o_t] != ZERO) NBNEXT = 2;
 529:                      }
 530:                      this._dlaexc.Run(WANTQ, N, ref T, offset_t, LDT, ref Q, offset_q, LDQ
 531:                                       , HERE - NBNEXT, NBNEXT, 1, ref WORK, offset_work, ref INFO);
 532:                      if (INFO != 0)
 533:                      {
 534:                          ILST = HERE;
 535:                          return;
 536:                      }
 537:                      if (NBNEXT == 1)
 538:                      {
 539:                          // *
 540:                          // *              Swap two 1 by 1 blocks, no problems possible
 541:                          // *
 542:                          this._dlaexc.Run(WANTQ, N, ref T, offset_t, LDT, ref Q, offset_q, LDQ
 543:                                           , HERE, NBNEXT, 1, ref WORK, offset_work, ref INFO);
 544:                          HERE = HERE - 1;
 545:                      }
 546:                      else
 547:                      {
 548:                          // *
 549:                          // *              Recompute NBNEXT in case 2 by 2 split
 550:                          // *
 551:                          if (T[HERE+(HERE - 1) * LDT + o_t] == ZERO) NBNEXT = 1;
 552:                          if (NBNEXT == 2)
 553:                          {
 554:                              // *
 555:                              // *                 2 by 2 Block did not split
 556:                              // *
 557:                              this._dlaexc.Run(WANTQ, N, ref T, offset_t, LDT, ref Q, offset_q, LDQ
 558:                                               , HERE - 1, 2, 1, ref WORK, offset_work, ref INFO);
 559:                              if (INFO != 0)
 560:                              {
 561:                                  ILST = HERE;
 562:                                  return;
 563:                              }
 564:                              HERE = HERE - 2;
 565:                          }
 566:                          else
 567:                          {
 568:                              // *
 569:                              // *                 2 by 2 Block did split
 570:                              // *
 571:                              this._dlaexc.Run(WANTQ, N, ref T, offset_t, LDT, ref Q, offset_q, LDQ
 572:                                               , HERE, 1, 1, ref WORK, offset_work, ref INFO);
 573:                              this._dlaexc.Run(WANTQ, N, ref T, offset_t, LDT, ref Q, offset_q, LDQ
 574:                                               , HERE - 1, 1, 1, ref WORK, offset_work, ref INFO);
 575:                              HERE = HERE - 2;
 576:                          }
 577:                      }
 578:                  }
 579:                  if (HERE > ILST) goto LABEL20;
 580:              }
 581:              ILST = HERE;
 582:              // *
 583:              return;
 584:              // *
 585:              // *     End of DTREXC
 586:              // *
 587:   
 588:              #endregion
 589:   
 590:          }
 591:      }
 592:  }