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 auxiliary routine (version 3.1) --
  21:      /// Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
  22:      /// November 2006
  23:      /// Purpose
  24:      /// =======
  25:      /// 
  26:      /// DLANST  returns the value of the one norm,  or the Frobenius norm, or
  27:      /// the  infinity norm,  or the  element of  largest absolute value  of a
  28:      /// real symmetric tridiagonal matrix A.
  29:      /// 
  30:      /// Description
  31:      /// ===========
  32:      /// 
  33:      /// DLANST returns the value
  34:      /// 
  35:      /// DLANST = ( max(abs(A(i,j))), NORM = 'M' or 'm'
  36:      /// (
  37:      /// ( norm1(A),         NORM = '1', 'O' or 'o'
  38:      /// (
  39:      /// ( normI(A),         NORM = 'I' or 'i'
  40:      /// (
  41:      /// ( normF(A),         NORM = 'F', 'f', 'E' or 'e'
  42:      /// 
  43:      /// where  norm1  denotes the  one norm of a matrix (maximum column sum),
  44:      /// normI  denotes the  infinity norm  of a matrix  (maximum row sum) and
  45:      /// normF  denotes the  Frobenius norm of a matrix (square root of sum of
  46:      /// squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm.
  47:      /// 
  48:      ///</summary>
  49:      public class DLANST
  50:      {
  51:      
  52:   
  53:          #region Dependencies
  54:          
  55:          LSAME _lsame; DLASSQ _dlassq; 
  56:   
  57:          #endregion
  58:   
  59:   
  60:          #region Fields
  61:          
  62:          const double ONE = 1.0E+0; const double ZERO = 0.0E+0; int I = 0; double ANORM = 0; double SCALE = 0; double SUM = 0; 
  63:   
  64:          #endregion
  65:   
  66:          public DLANST(LSAME lsame, DLASSQ dlassq)
  67:          {
  68:      
  69:   
  70:              #region Set Dependencies
  71:              
  72:              this._lsame = lsame; this._dlassq = dlassq; 
  73:   
  74:              #endregion
  75:   
  76:          }
  77:      
  78:          public DLANST()
  79:          {
  80:      
  81:   
  82:              #region Dependencies (Initialization)
  83:              
  84:              LSAME lsame = new LSAME();
  85:              DLASSQ dlassq = new DLASSQ();
  86:   
  87:              #endregion
  88:   
  89:   
  90:              #region Set Dependencies
  91:              
  92:              this._lsame = lsame; this._dlassq = dlassq; 
  93:   
  94:              #endregion
  95:   
  96:          }
  97:          /// <summary>
  98:          /// Purpose
  99:          /// =======
 100:          /// 
 101:          /// DLANST  returns the value of the one norm,  or the Frobenius norm, or
 102:          /// the  infinity norm,  or the  element of  largest absolute value  of a
 103:          /// real symmetric tridiagonal matrix A.
 104:          /// 
 105:          /// Description
 106:          /// ===========
 107:          /// 
 108:          /// DLANST returns the value
 109:          /// 
 110:          /// DLANST = ( max(abs(A(i,j))), NORM = 'M' or 'm'
 111:          /// (
 112:          /// ( norm1(A),         NORM = '1', 'O' or 'o'
 113:          /// (
 114:          /// ( normI(A),         NORM = 'I' or 'i'
 115:          /// (
 116:          /// ( normF(A),         NORM = 'F', 'f', 'E' or 'e'
 117:          /// 
 118:          /// where  norm1  denotes the  one norm of a matrix (maximum column sum),
 119:          /// normI  denotes the  infinity norm  of a matrix  (maximum row sum) and
 120:          /// normF  denotes the  Frobenius norm of a matrix (square root of sum of
 121:          /// squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm.
 122:          /// 
 123:          ///</summary>
 124:          /// <param name="NORM">
 125:          /// (input) CHARACTER*1
 126:          /// Specifies the value to be returned in DLANST as described
 127:          /// above.
 128:          ///</param>
 129:          /// <param name="N">
 130:          /// (input) INTEGER
 131:          /// The order of the matrix A.  N .GE. 0.  When N = 0, DLANST is
 132:          /// set to zero.
 133:          ///</param>
 134:          /// <param name="D">
 135:          /// (input) DOUBLE PRECISION array, dimension (N)
 136:          /// The diagonal elements of A.
 137:          ///</param>
 138:          /// <param name="E">
 139:          /// (input) DOUBLE PRECISION array, dimension (N-1)
 140:          /// The (n-1) sub-diagonal or super-diagonal elements of A.
 141:          ///</param>
 142:          public double Run(string NORM, int N, double[] D, int offset_d, double[] E, int offset_e)
 143:          {
 144:          double dlanst = 0;
 145:   
 146:              #region Array Index Correction
 147:              
 148:               int o_d = -1 + offset_d;  int o_e = -1 + offset_e; 
 149:   
 150:              #endregion
 151:   
 152:   
 153:              #region Strings
 154:              
 155:              NORM = NORM.Substring(0, 1);  
 156:   
 157:              #endregion
 158:   
 159:   
 160:              #region Prolog
 161:              
 162:              // *
 163:              // *  -- LAPACK auxiliary routine (version 3.1) --
 164:              // *     Univ. of Tennessee, Univ. of California Berkeley and NAG Ltd..
 165:              // *     November 2006
 166:              // *
 167:              // *     .. Scalar Arguments ..
 168:              // *     ..
 169:              // *     .. Array Arguments ..
 170:              // *     ..
 171:              // *
 172:              // *  Purpose
 173:              // *  =======
 174:              // *
 175:              // *  DLANST  returns the value of the one norm,  or the Frobenius norm, or
 176:              // *  the  infinity norm,  or the  element of  largest absolute value  of a
 177:              // *  real symmetric tridiagonal matrix A.
 178:              // *
 179:              // *  Description
 180:              // *  ===========
 181:              // *
 182:              // *  DLANST returns the value
 183:              // *
 184:              // *     DLANST = ( max(abs(A(i,j))), NORM = 'M' or 'm'
 185:              // *              (
 186:              // *              ( norm1(A),         NORM = '1', 'O' or 'o'
 187:              // *              (
 188:              // *              ( normI(A),         NORM = 'I' or 'i'
 189:              // *              (
 190:              // *              ( normF(A),         NORM = 'F', 'f', 'E' or 'e'
 191:              // *
 192:              // *  where  norm1  denotes the  one norm of a matrix (maximum column sum),
 193:              // *  normI  denotes the  infinity norm  of a matrix  (maximum row sum) and
 194:              // *  normF  denotes the  Frobenius norm of a matrix (square root of sum of
 195:              // *  squares).  Note that  max(abs(A(i,j)))  is not a consistent matrix norm.
 196:              // *
 197:              // *  Arguments
 198:              // *  =========
 199:              // *
 200:              // *  NORM    (input) CHARACTER*1
 201:              // *          Specifies the value to be returned in DLANST as described
 202:              // *          above.
 203:              // *
 204:              // *  N       (input) INTEGER
 205:              // *          The order of the matrix A.  N >= 0.  When N = 0, DLANST is
 206:              // *          set to zero.
 207:              // *
 208:              // *  D       (input) DOUBLE PRECISION array, dimension (N)
 209:              // *          The diagonal elements of A.
 210:              // *
 211:              // *  E       (input) DOUBLE PRECISION array, dimension (N-1)
 212:              // *          The (n-1) sub-diagonal or super-diagonal elements of A.
 213:              // *
 214:              // *  =====================================================================
 215:              // *
 216:              // *     .. Parameters ..
 217:              // *     ..
 218:              // *     .. Local Scalars ..
 219:              // *     ..
 220:              // *     .. External Functions ..
 221:              // *     ..
 222:              // *     .. External Subroutines ..
 223:              // *     ..
 224:              // *     .. Intrinsic Functions ..
 225:              //      INTRINSIC          ABS, MAX, SQRT;
 226:              // *     ..
 227:              // *     .. Executable Statements ..
 228:              // *
 229:   
 230:              #endregion
 231:   
 232:   
 233:              #region Body
 234:              
 235:              if (N <= 0)
 236:              {
 237:                  ANORM = ZERO;
 238:              }
 239:              else
 240:              {
 241:                  if (this._lsame.Run(NORM, "M"))
 242:                  {
 243:                      // *
 244:                      // *        Find max(abs(A(i,j))).
 245:                      // *
 246:                      ANORM = Math.Abs(D[N + o_d]);
 247:                      for (I = 1; I <= N - 1; I++)
 248:                      {
 249:                          ANORM = Math.Max(ANORM, Math.Abs(D[I + o_d]));
 250:                          ANORM = Math.Max(ANORM, Math.Abs(E[I + o_e]));
 251:                      }
 252:                  }
 253:                  else
 254:                  {
 255:                      if (this._lsame.Run(NORM, "O") || NORM == "1" || this._lsame.Run(NORM, "I"))
 256:                      {
 257:                          // *
 258:                          // *        Find norm1(A).
 259:                          // *
 260:                          if (N == 1)
 261:                          {
 262:                              ANORM = Math.Abs(D[1 + o_d]);
 263:                          }
 264:                          else
 265:                          {
 266:                              ANORM = Math.Max(Math.Abs(D[1 + o_d]) + Math.Abs(E[1 + o_e]), Math.Abs(E[N - 1 + o_e]) + Math.Abs(D[N + o_d]));
 267:                              for (I = 2; I <= N - 1; I++)
 268:                              {
 269:                                  ANORM = Math.Max(ANORM, Math.Abs(D[I + o_d]) + Math.Abs(E[I + o_e]) + Math.Abs(E[I - 1 + o_e]));
 270:                              }
 271:                          }
 272:                      }
 273:                      else
 274:                      {
 275:                          if ((this._lsame.Run(NORM, "F")) || (this._lsame.Run(NORM, "E")))
 276:                          {
 277:                              // *
 278:                              // *        Find normF(A).
 279:                              // *
 280:                              SCALE = ZERO;
 281:                              SUM = ONE;
 282:                              if (N > 1)
 283:                              {
 284:                                  this._dlassq.Run(N - 1, E, offset_e, 1, ref SCALE, ref SUM);
 285:                                  SUM = 2 * SUM;
 286:                              }
 287:                              this._dlassq.Run(N, D, offset_d, 1, ref SCALE, ref SUM);
 288:                              ANORM = SCALE * Math.Sqrt(SUM);
 289:                          }
 290:                      }
 291:                  }
 292:              }
 293:              // *
 294:              dlanst = ANORM;
 295:              return dlanst;
 296:              // *
 297:              // *     End of DLANST
 298:              // *
 299:   
 300:              #endregion
 301:   
 302:          }
 303:      }
 304:  }