vendor/gonum.org/v1/gonum/lapack/gonum/ilaenv.go

   1 // Copyright ©2015 The Gonum Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 package gonum
   6
   7 // Ilaenv returns algorithm tuning parameters for the algorithm given by the
   8 // input string. ispec specifies the parameter to return:
   9 //  1: The optimal block size for a blocked algorithm.
  10 //  2: The minimum block size for a blocked algorithm.
  11 //  3: The block size of unprocessed data at which a blocked algorithm should
  12 //     crossover to an unblocked version.
  13 //  4: The number of shifts.
  14 //  5: The minimum column dimension for blocking to be used.
  15 //  6: The crossover point for SVD (to use QR factorization or not).
  16 //  7: The number of processors.
  17 //  8: The crossover point for multi-shift in QR and QZ methods for non-symmetric eigenvalue problems.
  18 //  9: Maximum size of the subproblems in divide-and-conquer algorithms.
  19 //  10: ieee NaN arithmetic can be trusted not to trap.
  20 //  11: infinity arithmetic can be trusted not to trap.
  21 //  12...16: parameters for Dhseqr and related functions. See Iparmq for more
  22 //           information.
  23 //
  24 // Ilaenv is an internal routine. It is exported for testing purposes.
  25 func (impl Implementation) Ilaenv(ispec int, s string, opts string, n1, n2, n3, n4 int) int {
  26         // TODO(btracey): Replace this with a constant lookup? A list of constants?
  27         sname := s[0] == 'S' || s[0] == 'D'
  28         cname := s[0] == 'C' || s[0] == 'Z'
  29         if !sname && !cname {
  30                 panic("lapack: bad name")
  31         }
  32         c2 := s[1:3]
  33         c3 := s[3:6]
  34         c4 := c3[1:3]
  35
  36         switch ispec {
  37         default:
  38                 panic("lapack: bad ispec")
  39         case 1:
  40                 switch c2 {
  41                 default:
  42                         panic("lapack: bad function name")
  43                 case "GE":
  44                         switch c3 {
  45                         default:
  46                                 panic("lapack: bad function name")
  47                         case "TRF":
  48                                 if sname {
  49                                         return 64
  50                                 }
  51                                 return 64
  52                         case "QRF", "RQF", "LQF", "QLF":
  53                                 if sname {
  54                                         return 32
  55                                 }
  56                                 return 32
  57                         case "HRD":
  58                                 if sname {
  59                                         return 32
  60                                 }
  61                                 return 32
  62                         case "BRD":
  63                                 if sname {
  64                                         return 32
  65                                 }
  66                                 return 32
  67                         case "TRI":
  68                                 if sname {
  69                                         return 64
  70                                 }
  71                                 return 64
  72                         }
  73                 case "PO":
  74                         switch c3 {
  75                         default:
  76                                 panic("lapack: bad function name")
  77                         case "TRF":
  78                                 if sname {
  79                                         return 64
  80                                 }
  81                                 return 64
  82                         }
  83                 case "SY":
  84                         switch c3 {
  85                         default:
  86                                 panic("lapack: bad function name")
  87                         case "TRF":
  88                                 if sname {
  89                                         return 64
  90                                 }
  91                                 return 64
  92                         case "TRD":
  93                                 return 32
  94                         case "GST":
  95                                 return 64
  96                         }
  97                 case "HE":
  98                         switch c3 {
  99                         default:
 100                                 panic("lapack: bad function name")
 101                         case "TRF":
 102                                 return 64
 103                         case "TRD":
 104                                 return 32
 105                         case "GST":
 106                                 return 64
 107                         }
 108                 case "OR":
 109                         switch c3[0] {
 110                         default:
 111                                 panic("lapack: bad function name")
 112                         case 'G':
 113                                 switch c3[1:] {
 114                                 default:
 115                                         panic("lapack: bad function name")
 116                                 case "QR", "RQ", "LQ", "QL", "HR", "TR", "BR":
 117                                         return 32
 118                                 }
 119                         case 'M':
 120                                 switch c3[1:] {
 121                                 default:
 122                                         panic("lapack: bad function name")
 123                                 case "QR", "RQ", "LQ", "QL", "HR", "TR", "BR":
 124                                         return 32
 125                                 }
 126                         }
 127                 case "UN":
 128                         switch c3[0] {
 129                         default:
 130                                 panic("lapack: bad function name")
 131                         case 'G':
 132                                 switch c3[1:] {
 133                                 default:
 134                                         panic("lapack: bad function name")
 135                                 case "QR", "RQ", "LQ", "QL", "HR", "TR", "BR":
 136                                         return 32
 137                                 }
 138                         case 'M':
 139                                 switch c3[1:] {
 140                                 default:
 141                                         panic("lapack: bad function name")
 142                                 case "QR", "RQ", "LQ", "QL", "HR", "TR", "BR":
 143                                         return 32
 144                                 }
 145                         }
 146                 case "GB":
 147                         switch c3 {
 148                         default:
 149                                 panic("lapack: bad function name")
 150                         case "TRF":
 151                                 if sname {
 152                                         if n4 <= 64 {
 153                                                 return 1
 154                                         }
 155                                         return 32
 156                                 }
 157                                 if n4 <= 64 {
 158                                         return 1
 159                                 }
 160                                 return 32
 161                         }
 162                 case "PB":
 163                         switch c3 {
 164                         default:
 165                                 panic("lapack: bad function name")
 166                         case "TRF":
 167                                 if sname {
 168                                         if n4 <= 64 {
 169                                                 return 1
 170                                         }
 171                                         return 32
 172                                 }
 173                                 if n4 <= 64 {
 174                                         return 1
 175                                 }
 176                                 return 32
 177                         }
 178                 case "TR":
 179                         switch c3 {
 180                         default:
 181                                 panic("lapack: bad function name")
 182                         case "TRI":
 183                                 if sname {
 184                                         return 64
 185                                 }
 186                                 return 64
 187                         case "EVC":
 188                                 if sname {
 189                                         return 64
 190                                 }
 191                                 return 64
 192                         }
 193                 case "LA":
 194                         switch c3 {
 195                         default:
 196                                 panic("lapack: bad function name")
 197                         case "UUM":
 198                                 if sname {
 199                                         return 64
 200                                 }
 201                                 return 64
 202                         }
 203                 case "ST":
 204                         if sname && c3 == "EBZ" {
 205                                 return 1
 206                         }
 207                         panic("lapack: bad function name")
 208                 }
 209         case 2:
 210                 switch c2 {
 211                 default:
 212                         panic("lapack: bad function name")
 213                 case "GE":
 214                         switch c3 {
 215                         default:
 216                                 panic("lapack: bad function name")
 217                         case "QRF", "RQF", "LQF", "QLF":
 218                                 if sname {
 219                                         return 2
 220                                 }
 221                                 return 2
 222                         case "HRD":
 223                                 if sname {
 224                                         return 2
 225                                 }
 226                                 return 2
 227                         case "BRD":
 228                                 if sname {
 229                                         return 2
 230                                 }
 231                                 return 2
 232                         case "TRI":
 233                                 if sname {
 234                                         return 2
 235                                 }
 236                                 return 2
 237                         }
 238                 case "SY":
 239                         switch c3 {
 240                         default:
 241                                 panic("lapack: bad function name")
 242                         case "TRF":
 243                                 if sname {
 244                                         return 8
 245                                 }
 246                                 return 8
 247                         case "TRD":
 248                                 if sname {
 249                                         return 2
 250                                 }
 251                                 panic("lapack: bad function name")
 252                         }
 253                 case "HE":
 254                         if c3 == "TRD" {
 255                                 return 2
 256                         }
 257                         panic("lapack: bad function name")
 258                 case "OR":
 259                         if !sname {
 260                                 panic("lapack: bad function name")
 261                         }
 262                         switch c3[0] {
 263                         default:
 264                                 panic("lapack: bad function name")
 265                         case 'G':
 266                                 switch c4 {
 267                                 default:
 268                                         panic("lapack: bad function name")
 269                                 case "QR", "RQ", "LQ", "QL", "HR", "TR", "BR":
 270                                         return 2
 271                                 }
 272                         case 'M':
 273                                 switch c4 {
 274                                 default:
 275                                         panic("lapack: bad function name")
 276                                 case "QR", "RQ", "LQ", "QL", "HR", "TR", "BR":
 277                                         return 2
 278                                 }
 279                         }
 280                 case "UN":
 281                         switch c3[0] {
 282                         default:
 283                                 panic("lapack: bad function name")
 284                         case 'G':
 285                                 switch c4 {
 286                                 default:
 287                                         panic("lapack: bad function name")
 288                                 case "QR", "RQ", "LQ", "QL", "HR", "TR", "BR":
 289                                         return 2
 290                                 }
 291                         case 'M':
 292                                 switch c4 {
 293                                 default:
 294                                         panic("lapack: bad function name")
 295                                 case "QR", "RQ", "LQ", "QL", "HR", "TR", "BR":
 296                                         return 2
 297                                 }
 298                         }
 299                 }
 300         case 3:
 301                 switch c2 {
 302                 default:
 303                         panic("lapack: bad function name")
 304                 case "GE":
 305                         switch c3 {
 306                         default:
 307                                 panic("lapack: bad function name")
 308                         case "QRF", "RQF", "LQF", "QLF":
 309                                 if sname {
 310                                         return 128
 311                                 }
 312                                 return 128
 313                         case "HRD":
 314                                 if sname {
 315                                         return 128
 316                                 }
 317                                 return 128
 318                         case "BRD":
 319                                 if sname {
 320                                         return 128
 321                                 }
 322                                 return 128
 323                         }
 324                 case "SY":
 325                         if sname && c3 == "TRD" {
 326                                 return 32
 327                         }
 328                         panic("lapack: bad function name")
 329                 case "HE":
 330                         if c3 == "TRD" {
 331                                 return 32
 332                         }
 333                         panic("lapack: bad function name")
 334                 case "OR":
 335                         switch c3[0] {
 336                         default:
 337                                 panic("lapack: bad function name")
 338                         case 'G':
 339                                 switch c4 {
 340                                 default:
 341                                         panic("lapack: bad function name")
 342                                 case "QR", "RQ", "LQ", "QL", "HR", "TR", "BR":
 343                                         return 128
 344                                 }
 345                         }
 346                 case "UN":
 347                         switch c3[0] {
 348                         default:
 349                                 panic("lapack: bad function name")
 350                         case 'G':
 351                                 switch c4 {
 352                                 default:
 353                                         panic("lapack: bad function name")
 354                                 case "QR", "RQ", "LQ", "QL", "HR", "TR", "BR":
 355                                         return 128
 356                                 }
 357                         }
 358                 }
 359         case 4:
 360                 // Used by xHSEQR
 361                 return 6
 362         case 5:
 363                 // Not used
 364                 return 2
 365         case 6:
 366                 // Used by xGELSS and xGESVD
 367                 return int(float64(min(n1, n2)) * 1.6)
 368         case 7:
 369                 // Not used
 370                 return 1
 371         case 8:
 372                 // Used by xHSEQR
 373                 return 50
 374         case 9:
 375                 // used by xGELSD and xGESDD
 376                 return 25
 377         case 10:
 378                 // Go guarantees ieee
 379                 return 1
 380         case 11:
 381                 // Go guarantees ieee
 382                 return 1
 383         case 12, 13, 14, 15, 16:
 384                 // Dhseqr and related functions for eigenvalue problems.
 385                 return impl.Iparmq(ispec, s, opts, n1, n2, n3, n4)
 386         }
 387 }