Amesos Package Browser (Single Doxygen Collection) Development
amesos_t_cholmod_change_factor.c
Go to the documentation of this file.
00001 /* ========================================================================== */
00002 /* === Core/t_cholmod_change_factor ========================================= */
00003 /* ========================================================================== */
00004 
00005 /* -----------------------------------------------------------------------------
00006  * CHOLMOD/Core Module.  Copyright (C) 2005-2006,
00007  * Univ. of Florida.  Author: Timothy A. Davis
00008  * The CHOLMOD/Core Module is licensed under Version 2.1 of the GNU
00009  * Lesser General Public License.  See lesser.txt for a text of the license.
00010  * CHOLMOD is also available under other licenses; contact authors for details.
00011  * http://www.cise.ufl.edu/research/sparse
00012  * -------------------------------------------------------------------------- */
00013 
00014 /* Template routine for cholmod_change_factor.  All xtypes supported. */
00015 
00016 #include "amesos_cholmod_template.h"
00017 
00018 /* ========================================================================== */
00019 /* === t_change_simplicial_numeric ========================================== */
00020 /* ========================================================================== */
00021 
00022 static void TEMPLATE (change_simplicial_numeric)
00023 (
00024     cholmod_factor *L,
00025     Int to_ll,
00026     Int to_packed,
00027     Int *newLi,
00028     double *newLx,
00029     double *newLz,
00030     Int lnz,
00031     Int grow,
00032     double grow1,
00033     Int grow2,
00034     Int make_ll,
00035     Int make_monotonic,
00036     Int make_ldl,
00037     cholmod_common *Common
00038 )
00039 {
00040     double xlen, dj [1], ljj [1], lj2 [1] ;
00041     double *Lx, *Lz ;
00042     Int *Lp, *Li, *Lnz ;
00043     Int n, j, len, pnew, pold, k, p, pend ;
00044 
00045     n = L->n ;
00046     Lp = L->p ;
00047     Li = L->i ;
00048     Lx = L->x ;
00049     Lz = L->z ;
00050     Lnz = L->nz ;
00051 
00052     if (make_ll)
00053     {
00054   L->minor = n ;
00055     }
00056 
00057     if (make_monotonic)
00058     {
00059 
00060   /* ------------------------------------------------------------------ */
00061   /* reorder the columns to make them monotonic */
00062   /* ------------------------------------------------------------------ */
00063 
00064   pnew = 0 ;
00065   for (j = 0 ; j < n ; j++)
00066   {
00067       /* copy and pack column j */
00068       len = Lnz [j] ;
00069       PRINT2 (("j: "ID" Lnz[j] "ID" len "ID" p "ID"\n",
00070       j, Lnz [j], len, pnew)) ;
00071       pold = Lp [j] ;
00072       ASSERT (Li [pold] == j) ;
00073 
00074       if (make_ll)
00075       {
00076 
00077     /* ---------------------------------------------------------- */
00078     /* copy and convert LDL' to LL' */
00079     /* ---------------------------------------------------------- */
00080 
00081     /* dj = Lx [pold] ; */
00082     ASSIGN_REAL (dj,0, Lx,pold) ;
00083 
00084     if (IS_LE_ZERO (dj [0]))
00085     {
00086         /* Conversion has failed; matrix is not positive definite.
00087          * Do not modify the column so that the LDL' factorization
00088          * can be restored if desired, by converting back to LDL'.
00089          * Continue the conversion, but flag the error. */
00090         if (L->minor == (size_t) n)
00091         {
00092       ERROR (CHOLMOD_NOT_POSDEF, "L not positive definite") ;
00093       L->minor = j ;
00094         }
00095         for (k = 0 ; k < len ; k++)
00096         {
00097       newLi [pnew + k] = Li [pold + k] ;
00098       /* newLx [pnew + k] = Lx [pold + k] ; */
00099       ASSIGN (newLx, newLz, pnew+k, Lx, Lz, pold+k) ;
00100         }
00101     }
00102     else
00103     {
00104         ljj [0] = sqrt (dj [0]) ;
00105         newLi [pnew] = j ;
00106         /* newLx [pnew] = ljj ; */
00107         ASSIGN_REAL (newLx, pnew, ljj, 0) ;
00108         CLEAR_IMAG (newLx, newLz, pnew) ;
00109 
00110         for (k = 1 ; k < len ; k++)
00111         {
00112       newLi [pnew + k] = Li [pold + k] ;
00113       /* newLx [pnew + k] = Lx [pold + k] * ljj ; */
00114       MULT_REAL (newLx, newLz, pnew+k, Lx, Lz, pold+k, ljj,0);
00115         }
00116     }
00117 
00118       }
00119       else if (make_ldl)
00120       {
00121 
00122     /* ---------------------------------------------------------- */
00123     /* copy and convert LL' to LDL' */
00124     /* ---------------------------------------------------------- */
00125 
00126     /* ljj = Lx [pold] ; */
00127     ASSIGN_REAL (ljj, 0, Lx, pold) ;
00128 
00129     if (ljj [0] <= 0)
00130     {
00131         /* matrix is not positive-definite; copy column as-is */
00132         for (k = 0 ; k < len ; k++)
00133         {
00134       newLi [pnew + k] = Li [pold + k] ;
00135       /* newLx [pnew + k] = Lx [pold + k] ; */
00136       ASSIGN (newLx, newLz, pnew+k, Lx, Lz, pold+k) ;
00137         }
00138     }
00139     else
00140     {
00141         newLi [pnew] = j ;
00142         /* newLx [pnew] = ljj*ljj ; */
00143         lj2 [0] = ljj [0] * ljj [0] ;
00144         ASSIGN_REAL (newLx, pnew, lj2, 0) ;
00145         CLEAR_IMAG (newLx, newLz, pnew) ;
00146 
00147         for (k = 1 ; k < len ; k++)
00148         {
00149       newLi [pnew + k] = Li [pold + k] ;
00150       /* newLx [pnew + k] = Lx [pold + k] / ljj ; */
00151       DIV_REAL (newLx, newLz, pnew+k, Lx, Lz, pold+k, ljj,0) ;
00152         }
00153     }
00154 
00155       }
00156       else
00157       {
00158 
00159     /* ---------------------------------------------------------- */
00160     /* copy and leave LL' or LDL' as-is */
00161     /* ---------------------------------------------------------- */
00162 
00163     for (k = 0 ; k < len ; k++)
00164     {
00165         newLi [pnew + k] = Li [pold + k] ;
00166         /* newLx [pnew + k] = Lx [pold + k] ; */
00167         ASSIGN (newLx, newLz, pnew+k, Lx, Lz, pold+k) ;
00168     }
00169       }
00170 
00171       Lp [j] = pnew ;
00172 
00173       /* compute len in double to avoid integer overflow */
00174       if (grow)
00175       {
00176     xlen = (double) len ;
00177     xlen = grow1 * xlen + grow2 ;
00178     xlen = MIN (xlen, n-j) ;
00179     len = (Int) xlen ;
00180       }
00181       ASSERT (len >= Lnz [j] && len <= n-j) ;
00182       pnew += len ;
00183       ASSERT (pnew > 0) ;     /* integer overflow case already covered */
00184   }
00185   Lp [n] = pnew ;
00186   PRINT1 (("final pnew = "ID", lnz "ID" lnzmax %g\n",
00187         pnew, lnz, (double) L->nzmax)) ;
00188   ASSERT (pnew <= lnz) ;
00189 
00190   /* free the old L->i and L->x and replace with the new ones */
00191   CHOLMOD(free) (L->nzmax, sizeof (Int), L->i, Common) ;
00192 
00193 #ifdef REAL
00194   CHOLMOD(free) (L->nzmax, sizeof (double), L->x, Common) ;
00195 #elif defined (COMPLEX)
00196   CHOLMOD(free) (L->nzmax, 2*sizeof (double), L->x, Common) ;
00197 #else
00198   CHOLMOD(free) (L->nzmax, sizeof (double), L->x, Common) ;
00199   CHOLMOD(free) (L->nzmax, sizeof (double), L->z, Common) ;
00200 #endif
00201 
00202   L->i = newLi ;
00203   L->x = newLx ;
00204   L->z = newLz ;
00205   L->nzmax = lnz ;
00206 
00207   /* reconstruct the link list */
00208   natural_list (L) ;
00209 
00210     }
00211     else if (to_packed)
00212     {
00213 
00214   /* ------------------------------------------------------------------ */
00215   /* already monotonic, just pack the columns of L */
00216   /* ------------------------------------------------------------------ */
00217 
00218   pnew = 0 ;
00219 
00220   if (make_ll)
00221   {
00222 
00223       /* -------------------------------------------------------------- */
00224       /* pack and convert LDL' to LL' */
00225       /* -------------------------------------------------------------- */
00226 
00227       for (j = 0 ; j < n ; j++)
00228       {
00229     /* pack column j */
00230     pold = Lp [j] ;
00231     len = Lnz [j] ;
00232     ASSERT (len > 0) ;
00233     ASSERT (Li [pold] == j) ;
00234     PRINT2 (("col "ID" pnew "ID" pold "ID"\n", j, pnew, pold)) ;
00235 
00236     /* dj = Lx [pold] ; */
00237     ASSIGN_REAL (dj,0, Lx,pold) ;
00238 
00239     if (IS_LE_ZERO (dj [0]))
00240     {
00241         /* Conversion has failed; matrix is not positive definite.
00242          * Do not modify the column so that the LDL' factorization
00243          * can be restored if desired, by converting back to LDL'.
00244          * Continue the conversion, but flag the error. */
00245         if (L->minor == (size_t) n)
00246         {
00247       ERROR (CHOLMOD_NOT_POSDEF, "L not positive definite") ;
00248       L->minor = j ;
00249         }
00250         for (k = 0 ; k < len ; k++)
00251         {
00252       Li [pnew + k] = Li [pold + k] ;
00253       /* Lx [pnew + k] = Lx [pold + k] ; */
00254       ASSIGN (Lx, Lz, pnew+k, Lx, Lz, pold+k) ;
00255         }
00256     }
00257     else
00258     {
00259         ljj [0] = sqrt (dj [0]) ;
00260         Li [pnew] = j ;
00261 
00262         /* Lx [pnew] = ljj ; */
00263         ASSIGN_REAL (Lx, pnew, ljj, 0) ;
00264         CLEAR_IMAG (Lx, Lz, pnew) ;
00265 
00266         for (k = 1 ; k < len ; k++)
00267         {
00268       Li [pnew + k] = Li [pold + k] ;
00269       /* Lx [pnew + k] = Lx [pold + k] * ljj ; */
00270       MULT_REAL (Lx, Lz, pnew+k, Lx, Lz, pold+k, ljj,0) ;
00271         }
00272     }
00273     Lp [j] = pnew ;
00274     pnew += len ;
00275       }
00276 
00277   }
00278   else if (make_ldl)
00279   {
00280 
00281       /* -------------------------------------------------------------- */
00282       /* pack and convert LL' to LDL' */
00283       /* -------------------------------------------------------------- */
00284 
00285       for (j = 0 ; j < n ; j++)
00286       {
00287     /* pack column j */
00288     pold = Lp [j] ;
00289     len = Lnz [j] ;
00290 
00291     /* ljj = Lx [pold] ; */
00292     ASSIGN_REAL (ljj, 0, Lx, pold) ;
00293 
00294     ASSERT (len > 0) ;
00295     PRINT2 (("col "ID" pnew "ID" pold "ID"\n", j, pnew, pold)) ;
00296     if (ljj [0] <= 0)
00297     {
00298         /* matrix is not positive-definite; pack column as-is */
00299         for (k = 0 ; k < len ; k++)
00300         {
00301       Li [pnew + k] = Li [pold + k] ;
00302       /* Lx [pnew + k] = Lx [pold + k] ; */
00303       ASSIGN (Lx, Lz, pnew+k, Lx, Lz, pold+k) ;
00304         }
00305     }
00306     else
00307     {
00308         Li [pnew] = Li [pold] ;
00309 
00310         /* Lx [pnew] = ljj*ljj ; */
00311         lj2 [0] = ljj [0] * ljj [0] ;
00312         ASSIGN_REAL (Lx, pnew, lj2, 0) ;
00313         CLEAR_IMAG (Lx, Lz, pnew) ;
00314 
00315         for (k = 1 ; k < len ; k++)
00316         {
00317       Li [pnew + k] = Li [pold + k] ;
00318       /* Lx [pnew + k] = Lx [pold + k] / ljj ; */
00319       DIV_REAL (Lx, Lz, pnew+k, Lx, Lz, pold+k, ljj,0) ;
00320         }
00321     }
00322     Lp [j] = pnew ;
00323     pnew += len ;
00324       }
00325 
00326   }
00327   else
00328   {
00329 
00330       /* ---------------------------------------------------------- */
00331       /* pack and leave LL' or LDL' as-is */
00332       /* ---------------------------------------------------------- */
00333 
00334       for (j = 0 ; j < n ; j++)
00335       {
00336     /* pack column j */
00337     pold = Lp [j] ;
00338     len = Lnz [j] ;
00339     ASSERT (len > 0) ;
00340     PRINT2 (("col "ID" pnew "ID" pold "ID"\n", j, pnew, pold)) ;
00341     if (pnew < pold)
00342     {
00343         PRINT2 (("    pack this column\n")) ;
00344         for (k = 0 ; k < len ; k++)
00345         {
00346       Li [pnew + k] = Li [pold + k] ;
00347       /* Lx [pnew + k] = Lx [pold + k] ; */
00348       ASSIGN (Lx, Lz, pnew+k, Lx, Lz, pold+k) ;
00349         }
00350         Lp [j] = pnew ;
00351     }
00352     pnew += len ;
00353       }
00354   }
00355 
00356   Lp [n] = pnew ;
00357   PRINT2 (("Lp [n] = "ID"\n", pnew)) ;
00358 
00359     }
00360     else if (make_ll)
00361     {
00362 
00363   /* ------------------------------------------------------------------ */
00364   /* convert LDL' to LL', but do so in-place */
00365   /* ------------------------------------------------------------------ */
00366 
00367   for (j = 0 ; j < n ; j++)
00368   {
00369       p = Lp [j] ;
00370       pend = p + Lnz [j] ;
00371 
00372       /* dj = Lx [p] ; */
00373       ASSIGN_REAL (dj,0, Lx,p) ;
00374 
00375       if (IS_LE_ZERO (dj [0]))
00376       {
00377     /* Conversion has failed; matrix is not positive definite.
00378      * Do not modify the column so that the LDL' factorization
00379      * can be restored if desired, by converting back to LDL'.
00380      * Continue the conversion, but flag the error. */
00381     if (L->minor == (size_t) n)
00382     {
00383         ERROR (CHOLMOD_NOT_POSDEF, "L not positive definite") ;
00384         L->minor = j ;
00385     }
00386       }
00387       else
00388       {
00389     ljj [0] = sqrt (dj [0]) ;
00390     /* Lx [p] = ljj ; */
00391     ASSIGN_REAL (Lx,p, ljj,0) ;
00392     CLEAR_IMAG (Lx, Lz, p) ;
00393 
00394     for (p++ ; p < pend ; p++)
00395     {
00396         /* Lx [p] *= ljj ; */
00397         MULT_REAL (Lx,Lz,p, Lx,Lz,p, ljj,0) ;
00398     }
00399       }
00400   }
00401 
00402     }
00403     else if (make_ldl)
00404     {
00405 
00406   /* ------------------------------------------------------------------ */
00407   /* convert LL' to LDL', but do so in-place */
00408   /* ------------------------------------------------------------------ */
00409 
00410   for (j = 0 ; j < n ; j++)
00411   {
00412       p = Lp [j] ;
00413       pend = p + Lnz [j] ;
00414 
00415       /* ljj = Lx [p] ; */
00416       ASSIGN_REAL (ljj, 0, Lx, p) ;
00417 
00418       if (ljj [0] > 0)
00419       {
00420     /* Lx [p] = ljj*ljj ; */
00421     lj2 [0] = ljj [0] * ljj [0] ;
00422     ASSIGN_REAL (Lx, p, lj2, 0) ;
00423     CLEAR_IMAG (Lx, Lz, p) ;
00424 
00425     for (p++ ; p < pend ; p++)
00426     {
00427         /* Lx [p] /= ljj ; */
00428         DIV_REAL (Lx,Lz,p, Lx,Lz,p, ljj,0) ;
00429     }
00430       }
00431   }
00432     }
00433 
00434     L->is_ll = to_ll ;
00435 
00436     DEBUG (CHOLMOD(dump_factor) (L, "done change simplicial numeric", Common)) ;
00437 }
00438 
00439 
00440 /* ========================================================================== */
00441 /* === t_ll_super_to_simplicial_numeric ===================================== */
00442 /* ========================================================================== */
00443 
00444 /* A supernodal L can only be real or complex, not zomplex */
00445 
00446 #ifndef ZOMPLEX
00447 
00448 static void TEMPLATE (ll_super_to_simplicial_numeric)
00449 (
00450     cholmod_factor *L,
00451     Int to_packed,
00452     Int to_ll,
00453     cholmod_common *Common
00454 )
00455 {
00456     double ljj [1], lj2 [1] ;
00457     double *Lx ;
00458     Int *Ls, *Lpi, *Lpx, *Super, *Lp, *Li, *Lnz ;
00459     Int n, lnz, s, nsuper, p, psi, psx, psend, nsrow, nscol, ii, jj, j, k1, k2,
00460   q ;
00461 
00462     L->is_ll = to_ll ;
00463 
00464     Lp = L->p ;
00465     Li = L->i ;
00466     Lx = L->x ;
00467     Lnz = L->nz ;
00468     lnz = L->nzmax ;
00469 
00470     n = L->n ;
00471     nsuper = L->nsuper ;
00472     Lpi = L->pi ;
00473     Lpx = L->px ;
00474     Ls = L->s ;
00475     Super = L->super ;
00476 
00477     p = 0 ;
00478 
00479     for (s = 0 ; s < nsuper ; s++)
00480     {
00481   k1 = Super [s] ;
00482   k2 = Super [s+1] ;
00483   psi = Lpi [s] ;
00484   psend = Lpi [s+1] ;
00485   psx = Lpx [s] ;
00486   nsrow = psend - psi ;
00487   nscol = k2 - k1 ;
00488 
00489   for (jj = 0 ; jj < nscol ; jj++)
00490   {
00491       /* column j of L starts here */
00492       j = jj + k1 ;
00493 
00494       if (to_ll)
00495       {
00496     if (to_packed)
00497     {
00498 
00499         /* ------------------------------------------------------ */
00500         /* convert to LL' packed */
00501         /* ------------------------------------------------------ */
00502 
00503         Lp [j] = p ;
00504         PRINT2 (("Col j "ID" p "ID"\n", j, p)) ;
00505         for (ii = jj ; ii < nsrow ; ii++)
00506         {
00507       /* get L(i,j) from supernode and store in column j */
00508       ASSERT (p < (Int) (L->xsize) && p <= psx+ii+jj*nsrow) ;
00509       Li [p] = Ls [psi + ii] ;
00510       /* Lx [p] = Lx [psx + ii + jj*nsrow] ; */
00511       q = psx + ii + jj*nsrow ;
00512       ASSIGN (Lx,-,p, Lx,-,q) ;
00513       PRINT2 (("  i "ID" ", Li [p])) ;
00514       XPRINT2 (Lx,-,q) ;
00515       PRINT2 (("\n")) ;
00516       p++ ;
00517         }
00518         Lnz [j] = p - Lp [j] ;
00519 
00520     }
00521     else
00522     {
00523 
00524         /* ------------------------------------------------------ */
00525         /* convert to LL' unpacked */
00526         /* ------------------------------------------------------ */
00527 
00528         p = psx + jj + jj*nsrow ;
00529         Lp [j] = p ;
00530         Li [p] = j ;
00531         Lnz [j] = nsrow - jj ;
00532         p++ ;
00533         for (ii = jj + 1 ; ii < nsrow ; ii++)
00534         {
00535       /* get L(i,j) from supernode and store in column j */
00536       Li [psx + ii + jj*nsrow] = Ls [psi + ii] ;
00537         }
00538 
00539     }
00540       }
00541       else
00542       {
00543     if (to_packed)
00544     {
00545 
00546         /* ------------------------------------------------------ */
00547         /* convert to LDL' packed */
00548         /* ------------------------------------------------------ */
00549 
00550         Lp [j] = p ;
00551         PRINT2 (("Col j "ID" p "ID"\n", Lp [j], p)) ;
00552         /* ljj = Lx [psx + jj + jj*nsrow] ; */
00553         ASSIGN_REAL (ljj, 0, Lx, psx + jj + jj*nsrow) ;
00554 
00555         if (ljj [0] <= 0)
00556         {
00557       /* the matrix is not positive definite; do not divide */
00558       /* Lx [p] = ljj ; */
00559       ASSIGN_REAL (Lx, p, ljj, 0) ;
00560       CLEAR_IMAG (Lx, Lz, p) ;
00561       ljj [0] = 1 ;
00562         }
00563         else
00564         {
00565       lj2 [0] = ljj [0] * ljj [0] ;
00566       /* Lx [p] = ljj*ljj ; */
00567       ASSIGN_REAL (Lx, p, lj2, 0) ;
00568       CLEAR_IMAG (Lx, Lz, p) ;
00569         }
00570         Li [p] = j ;
00571         p++ ;
00572         for (ii = jj + 1 ; ii < nsrow ; ii++)
00573         {
00574       /* get L(i,j) from supernode and store in column j */
00575       ASSERT (p < (Int) (L->xsize) && p <= psx+ii+jj*nsrow) ;
00576       Li [p] = Ls [psi + ii] ;
00577 
00578       /* Lx [p] = Lx [psx + ii + jj*nsrow] / ljj ; */
00579       q = psx + ii + jj*nsrow ;
00580       DIV_REAL (Lx, Lz, p, Lx, Lz, q, ljj,0) ;
00581 
00582       PRINT2 (("  i "ID" %g\n", Li [p], Lx [p])) ;
00583       p++ ;
00584         }
00585         Lnz [j] = p - Lp [j] ;
00586 
00587     }
00588     else
00589     {
00590 
00591         /* ------------------------------------------------------ */
00592         /* convert to LDL' unpacked */
00593         /* ------------------------------------------------------ */
00594 
00595         p = psx + jj + jj*nsrow ;
00596         Lp [j] = p ;
00597 
00598         /* ljj = Lx [p] ; */
00599         ASSIGN_REAL (ljj,0, Lx,p) ;
00600 
00601         if (ljj [0] <= 0)
00602         {
00603       /* the matrix is not positive definite; do not divide */
00604       /* Lx [p] = ljj ; */
00605       ASSIGN_REAL (Lx, p, ljj, 0) ;
00606       CLEAR_IMAG (Lx, Lz, p) ;
00607       ljj [0] = 1 ;
00608         }
00609         else
00610         {
00611       lj2 [0] = ljj [0] * ljj [0] ;
00612       /* Lx [p] = ljj*ljj ; */
00613       ASSIGN_REAL (Lx, p, lj2, 0) ;
00614       CLEAR_IMAG (Lx, Lz, p) ;
00615         }
00616         Li [p] = j ;
00617         Lnz [j] = nsrow - jj ;
00618         p++ ;
00619         for (ii = jj + 1 ; ii < nsrow ; ii++)
00620         {
00621       /* get L(i,j) from supernode and store in column j */
00622       Li [psx + ii + jj*nsrow] = Ls [psi + ii] ;
00623 
00624       /* Lx [psx + ii + jj*nsrow] /= ljj ; */
00625       q = psx + ii + jj*nsrow ;
00626       DIV_REAL (Lx, Lz, q, Lx, Lz, q, ljj,0) ;
00627         }
00628     }
00629       }
00630   }
00631     }
00632 
00633     if (to_packed)
00634     {
00635   Lp [n] = p ;
00636   PRINT1 (("Final Lp "ID" n "ID" lnz "ID"\n", p, n, lnz)) ;
00637   ASSERT (Lp [n] == lnz) ;
00638   ASSERT (lnz <= (Int) (L->xsize)) ;
00639   /* reduce size of L->x to match L->i.  This cannot fail. */
00640   L->x = CHOLMOD(realloc) (lnz, 
00641 #ifdef COMPLEX
00642     2 *
00643 #endif
00644     sizeof (double), L->x, &(L->xsize), Common) ;
00645   ASSERT (lnz == (Int) (L->xsize)) ;
00646   Common->status = CHOLMOD_OK ;
00647     }
00648     else
00649     {
00650   Lp [n] = Lpx [nsuper] ;
00651   ASSERT (MAX (1,Lp [n]) == (Int) (L->xsize)) ;
00652   ASSERT (MAX (1,Lp [n]) == (Int) (L->nzmax)) ;
00653     }
00654 }
00655 
00656 #endif
00657 
00658 #undef PATTERN
00659 #undef REAL
00660 #undef COMPLEX
00661 #undef ZOMPLEX
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines