Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
07/22/10 00:44:01 (14 years ago)
Author:
swagner
Message:

Sorted usings and removed unused usings in entire solution (#1094)

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.ExtLibs/HeuristicLab.ALGLIB/2.5.0/ALGLIB-2.5.0/sblas.cs

    r3839 r4068  
    2525*************************************************************************/
    2626
    27 using System;
    2827
    29 namespace alglib
    30 {
    31     public class sblas
    32     {
    33         public static void symmetricmatrixvectormultiply(ref double[,] a,
    34             bool isupper,
    35             int i1,
    36             int i2,
    37             ref double[] x,
    38             double alpha,
    39             ref double[] y)
    40         {
    41             int i = 0;
    42             int ba1 = 0;
    43             int ba2 = 0;
    44             int by1 = 0;
    45             int by2 = 0;
    46             int bx1 = 0;
    47             int bx2 = 0;
    48             int n = 0;
    49             double v = 0;
    50             int i_ = 0;
    51             int i1_ = 0;
     28namespace alglib {
     29  public class sblas {
     30    public static void symmetricmatrixvectormultiply(ref double[,] a,
     31        bool isupper,
     32        int i1,
     33        int i2,
     34        ref double[] x,
     35        double alpha,
     36        ref double[] y) {
     37      int i = 0;
     38      int ba1 = 0;
     39      int ba2 = 0;
     40      int by1 = 0;
     41      int by2 = 0;
     42      int bx1 = 0;
     43      int bx2 = 0;
     44      int n = 0;
     45      double v = 0;
     46      int i_ = 0;
     47      int i1_ = 0;
    5248
    53             n = i2-i1+1;
    54             if( n<=0 )
    55             {
    56                 return;
    57             }
    58            
    59             //
    60             // Let A = L + D + U, where
    61             //  L is strictly lower triangular (main diagonal is zero)
    62             //  D is diagonal
    63             //  U is strictly upper triangular (main diagonal is zero)
    64             //
    65             // A*x = L*x + D*x + U*x
    66             //
    67             // Calculate D*x first
    68             //
    69             for(i=i1; i<=i2; i++)
    70             {
    71                 y[i-i1+1] = a[i,i]*x[i-i1+1];
    72             }
    73            
    74             //
    75             // Add L*x + U*x
    76             //
    77             if( isupper )
    78             {
    79                 for(i=i1; i<=i2-1; i++)
    80                 {
    81                    
    82                     //
    83                     // Add L*x to the result
    84                     //
    85                     v = x[i-i1+1];
    86                     by1 = i-i1+2;
    87                     by2 = n;
    88                     ba1 = i+1;
    89                     ba2 = i2;
    90                     i1_ = (ba1) - (by1);
    91                     for(i_=by1; i_<=by2;i_++)
    92                     {
    93                         y[i_] = y[i_] + v*a[i,i_+i1_];
    94                     }
    95                    
    96                     //
    97                     // Add U*x to the result
    98                     //
    99                     bx1 = i-i1+2;
    100                     bx2 = n;
    101                     ba1 = i+1;
    102                     ba2 = i2;
    103                     i1_ = (ba1)-(bx1);
    104                     v = 0.0;
    105                     for(i_=bx1; i_<=bx2;i_++)
    106                     {
    107                         v += x[i_]*a[i,i_+i1_];
    108                     }
    109                     y[i-i1+1] = y[i-i1+1]+v;
    110                 }
    111             }
    112             else
    113             {
    114                 for(i=i1+1; i<=i2; i++)
    115                 {
    116                    
    117                     //
    118                     // Add L*x to the result
    119                     //
    120                     bx1 = 1;
    121                     bx2 = i-i1;
    122                     ba1 = i1;
    123                     ba2 = i-1;
    124                     i1_ = (ba1)-(bx1);
    125                     v = 0.0;
    126                     for(i_=bx1; i_<=bx2;i_++)
    127                     {
    128                         v += x[i_]*a[i,i_+i1_];
    129                     }
    130                     y[i-i1+1] = y[i-i1+1]+v;
    131                    
    132                     //
    133                     // Add U*x to the result
    134                     //
    135                     v = x[i-i1+1];
    136                     by1 = 1;
    137                     by2 = i-i1;
    138                     ba1 = i1;
    139                     ba2 = i-1;
    140                     i1_ = (ba1) - (by1);
    141                     for(i_=by1; i_<=by2;i_++)
    142                     {
    143                         y[i_] = y[i_] + v*a[i,i_+i1_];
    144                     }
    145                 }
    146             }
    147             for(i_=1; i_<=n;i_++)
    148             {
    149                 y[i_] = alpha*y[i_];
    150             }
     49      n = i2 - i1 + 1;
     50      if (n <= 0) {
     51        return;
     52      }
     53
     54      //
     55      // Let A = L + D + U, where
     56      //  L is strictly lower triangular (main diagonal is zero)
     57      //  D is diagonal
     58      //  U is strictly upper triangular (main diagonal is zero)
     59      //
     60      // A*x = L*x + D*x + U*x
     61      //
     62      // Calculate D*x first
     63      //
     64      for (i = i1; i <= i2; i++) {
     65        y[i - i1 + 1] = a[i, i] * x[i - i1 + 1];
     66      }
     67
     68      //
     69      // Add L*x + U*x
     70      //
     71      if (isupper) {
     72        for (i = i1; i <= i2 - 1; i++) {
     73
     74          //
     75          // Add L*x to the result
     76          //
     77          v = x[i - i1 + 1];
     78          by1 = i - i1 + 2;
     79          by2 = n;
     80          ba1 = i + 1;
     81          ba2 = i2;
     82          i1_ = (ba1) - (by1);
     83          for (i_ = by1; i_ <= by2; i_++) {
     84            y[i_] = y[i_] + v * a[i, i_ + i1_];
     85          }
     86
     87          //
     88          // Add U*x to the result
     89          //
     90          bx1 = i - i1 + 2;
     91          bx2 = n;
     92          ba1 = i + 1;
     93          ba2 = i2;
     94          i1_ = (ba1) - (bx1);
     95          v = 0.0;
     96          for (i_ = bx1; i_ <= bx2; i_++) {
     97            v += x[i_] * a[i, i_ + i1_];
     98          }
     99          y[i - i1 + 1] = y[i - i1 + 1] + v;
    151100        }
     101      } else {
     102        for (i = i1 + 1; i <= i2; i++) {
     103
     104          //
     105          // Add L*x to the result
     106          //
     107          bx1 = 1;
     108          bx2 = i - i1;
     109          ba1 = i1;
     110          ba2 = i - 1;
     111          i1_ = (ba1) - (bx1);
     112          v = 0.0;
     113          for (i_ = bx1; i_ <= bx2; i_++) {
     114            v += x[i_] * a[i, i_ + i1_];
     115          }
     116          y[i - i1 + 1] = y[i - i1 + 1] + v;
     117
     118          //
     119          // Add U*x to the result
     120          //
     121          v = x[i - i1 + 1];
     122          by1 = 1;
     123          by2 = i - i1;
     124          ba1 = i1;
     125          ba2 = i - 1;
     126          i1_ = (ba1) - (by1);
     127          for (i_ = by1; i_ <= by2; i_++) {
     128            y[i_] = y[i_] + v * a[i, i_ + i1_];
     129          }
     130        }
     131      }
     132      for (i_ = 1; i_ <= n; i_++) {
     133        y[i_] = alpha * y[i_];
     134      }
     135    }
    152136
    153137
    154         public static void symmetricrank2update(ref double[,] a,
    155             bool isupper,
    156             int i1,
    157             int i2,
    158             ref double[] x,
    159             ref double[] y,
    160             ref double[] t,
    161             double alpha)
    162         {
    163             int i = 0;
    164             int tp1 = 0;
    165             int tp2 = 0;
    166             double v = 0;
    167             int i_ = 0;
    168             int i1_ = 0;
     138    public static void symmetricrank2update(ref double[,] a,
     139        bool isupper,
     140        int i1,
     141        int i2,
     142        ref double[] x,
     143        ref double[] y,
     144        ref double[] t,
     145        double alpha) {
     146      int i = 0;
     147      int tp1 = 0;
     148      int tp2 = 0;
     149      double v = 0;
     150      int i_ = 0;
     151      int i1_ = 0;
    169152
    170             if( isupper )
    171             {
    172                 for(i=i1; i<=i2; i++)
    173                 {
    174                     tp1 = i+1-i1;
    175                     tp2 = i2-i1+1;
    176                     v = x[i+1-i1];
    177                     for(i_=tp1; i_<=tp2;i_++)
    178                     {
    179                         t[i_] = v*y[i_];
    180                     }
    181                     v = y[i+1-i1];
    182                     for(i_=tp1; i_<=tp2;i_++)
    183                     {
    184                         t[i_] = t[i_] + v*x[i_];
    185                     }
    186                     for(i_=tp1; i_<=tp2;i_++)
    187                     {
    188                         t[i_] = alpha*t[i_];
    189                     }
    190                     i1_ = (tp1) - (i);
    191                     for(i_=i; i_<=i2;i_++)
    192                     {
    193                         a[i,i_] = a[i,i_] + t[i_+i1_];
    194                     }
    195                 }
    196             }
    197             else
    198             {
    199                 for(i=i1; i<=i2; i++)
    200                 {
    201                     tp1 = 1;
    202                     tp2 = i+1-i1;
    203                     v = x[i+1-i1];
    204                     for(i_=tp1; i_<=tp2;i_++)
    205                     {
    206                         t[i_] = v*y[i_];
    207                     }
    208                     v = y[i+1-i1];
    209                     for(i_=tp1; i_<=tp2;i_++)
    210                     {
    211                         t[i_] = t[i_] + v*x[i_];
    212                     }
    213                     for(i_=tp1; i_<=tp2;i_++)
    214                     {
    215                         t[i_] = alpha*t[i_];
    216                     }
    217                     i1_ = (tp1) - (i1);
    218                     for(i_=i1; i_<=i;i_++)
    219                     {
    220                         a[i,i_] = a[i,i_] + t[i_+i1_];
    221                     }
    222                 }
    223             }
     153      if (isupper) {
     154        for (i = i1; i <= i2; i++) {
     155          tp1 = i + 1 - i1;
     156          tp2 = i2 - i1 + 1;
     157          v = x[i + 1 - i1];
     158          for (i_ = tp1; i_ <= tp2; i_++) {
     159            t[i_] = v * y[i_];
     160          }
     161          v = y[i + 1 - i1];
     162          for (i_ = tp1; i_ <= tp2; i_++) {
     163            t[i_] = t[i_] + v * x[i_];
     164          }
     165          for (i_ = tp1; i_ <= tp2; i_++) {
     166            t[i_] = alpha * t[i_];
     167          }
     168          i1_ = (tp1) - (i);
     169          for (i_ = i; i_ <= i2; i_++) {
     170            a[i, i_] = a[i, i_] + t[i_ + i1_];
     171          }
    224172        }
     173      } else {
     174        for (i = i1; i <= i2; i++) {
     175          tp1 = 1;
     176          tp2 = i + 1 - i1;
     177          v = x[i + 1 - i1];
     178          for (i_ = tp1; i_ <= tp2; i_++) {
     179            t[i_] = v * y[i_];
     180          }
     181          v = y[i + 1 - i1];
     182          for (i_ = tp1; i_ <= tp2; i_++) {
     183            t[i_] = t[i_] + v * x[i_];
     184          }
     185          for (i_ = tp1; i_ <= tp2; i_++) {
     186            t[i_] = alpha * t[i_];
     187          }
     188          i1_ = (tp1) - (i1);
     189          for (i_ = i1; i_ <= i; i_++) {
     190            a[i, i_] = a[i, i_] + t[i_ + i1_];
     191          }
     192        }
     193      }
    225194    }
     195  }
    226196}
Note: See TracChangeset for help on using the changeset viewer.