## Revision 692 branches/merge-trunk-davef/src/sparse/hs_sparse.cpp

hs_sparse.cpp (revision 692)
245 245
```  return tmp;
```
246 246
```}
```
247 247

248
```dvar_matrix make_sdvar_matrix(dvar_compressed_triplet& M,int n,int m)
```
249
```{
```
250
```  dvar_matrix tmp(1,n,1,m);
```
251
```  int nz = M.indexmax()- M.indexmin() + 1;
```
252
```  for (int i=1;i<=nz;i++)
```
253
```  {
```
254
```    tmp(M(1,i),M(2,i))=M(i);
```
255
```    if (M(1,i) != M(2,i))
```
256
```    {
```
257
```      tmp(M(2,i),M(1,i))=M(i);
```
258
```    }
```
259
```  }
```
260
```  return tmp;
```
261
```}
```
248 262

249 263
```hs_smatrix::hs_smatrix(int _n, XCONST dcompressed_triplet &_M)
```
250 264
```{
```
......
281 295
```    for (k = 0 ; k < nz ; k++)
```
282 296
```      lower_tri += Ti[k]>Tj[k];
```
283 297
```    if(lower_tri)
```
298
```    {
```
284 299
```      cout << "hs_smatrix::hs_smatrix: M must be upper triangular" << endl;
```
300
```      ad_exit(1);
```
301
```    }
```
285 302

286 303
```    // Matrix in compressed format
```
287 304
```    p.allocate(0,n);
```
......
2565 2582
```{
```
2566 2583
```  allocate(mmin,mmax,_n,_m);
```
2567 2584
```}
```
2585
```dcompressed_triplet::dcompressed_triplet(void)
```
2586
```{
```
2587
```  n=0;
```
2588
```  m=-1;
```
2589
```}
```
2568 2590

2569

2570 2591
```void dvar_compressed_triplet::allocate(int mmin,int mmax,int _n,int _m)
```
2571 2592
```{
```
2572 2593
```  n=_n;
```
......
2809 2830
```    return x;
```
2810 2831
```  }
```
2811 2832
```
```
2833
```  dvector solve(const dcompressed_triplet & _st,const dvector& _grad)
```
2834
```  {
```
2835
```    ADUNCONST(dcompressed_triplet,st)
```
2836
```    ADUNCONST(dvector,grad)
```
2837
```    int n=st.get_n();
```
2838
```    //int n=Hess.indexmax();
```
2839
```    // fill up compressed triplet with nonzero entries of the Hessian
```
2840
```    hs_symbolic S(st,1);         // Fill reducing row-col permutation
```
2841
```
```
2842
```    hs_smatrix HS(n,st);  // Convert triplet to working format
```
2843
```
```
2844
```    hs_smatrix L(S);              // Allocates cholesky factor
```
2845
```
```
2846
```    ivector nxcount;
```
2847
```    chol(HS,S,L);                  // Does numeric factorization
```
2848
```
```
2849
```    dvector x(0,n-1);
```
2850
```    grad.shift(0);
```
2851
```    x = cs_ipvec(S.pinv, grad);
```
2852
```    grad.shift(1);
```
2853
```    x = cs_lsolve(L,x);
```
2854
```    x = cs_ltsolve(L,x);
```
2855
```    x = cs_pvec(S.pinv,x);
```
2856
```    x.shift(1);
```
2857
```    return x;
```
2858
```  }
```
2859
```
```
2812 2860
```  dvector solve(const dcompressed_triplet & _st,const dvector& _grad,const hs_symbolic& S,int& ierr)
```
2813 2861
```  {
```
2814 2862
```    ADUNCONST(dcompressed_triplet,st)
```
......
2857 2905
```{
```
2858 2906
```  int n=VM.get_n();
```
2859 2907
```  dvar_hs_smatrix H(n,VM);
```
2860
```  hs_symbolic S(VM,1);         // Fill reducing row-col permutation
```
2908
```  cout << "Needs fixing ??? " << endl;
```
2909
```  //sleep(1);
```
2910
```  // what is difference between 0 and 1
```
2911
```  hs_symbolic S(VM,0);         // Fill reducing row-col permutation
```
2912
```  //hs_symbolic S(VM,1);         // Fill reducing row-col permutation
```
2861 2913
```  dvar_hs_smatrix L(S);              // Allocates cholesky factor
```
2862 2914
```  int ierr=chol(H,S,L);                  // Does numeric factorization
```
2863 2915
```  if (ierr==0)
```
......
3048 3100

3049 3101
```static void dfcholeski_sparse(void);
```
3050 3102

... This diff was truncated because it exceeds the maximum size that can be displayed.

Also available in: Unified diff