src/main/java/edu/ufl/cise/klu/tdouble/Dklu_free_numeric.java

   1 /**
   2  * KLU: a sparse LU factorization algorithm.
   3  * Copyright (C) 2004-2009, Timothy A. Davis.
   4  * Copyright (C) 2011, Richard W. Lincoln.
   5  * http://www.cise.ufl.edu/research/sparse/klu
   6  *
   7  * -------------------------------------------------------------------------
   8  *
   9  * KLU is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public
  11  * License as published by the Free Software Foundation; either
  12  * version 2.1 of the License, or (at your option) any later version.
  13  *
  14  * KLU is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public
  20  * License along with this Module; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  22  *
  23  */
  24
  25 package edu.ufl.cise.klu.tdouble;
  26
  27 import edu.ufl.cise.klu.common.KLU_common;
  28 import edu.ufl.cise.klu.common.KLU_numeric;
  29
  30 /**
  31  * Free the KLU Numeric object.
  32  */
  33 public class Dklu_free_numeric extends Dklu_internal
  34 {
  35
  36 //      public static int klu_free_numeric(KLU_numeric NumericHandle,
  37 //                      KLU_common  Common)
  38 //      {
  39 //              KLU_numeric Numeric ;
  40 //              double[][] LUbx ;
  41 //              int LUsize ;
  42 //              int block, n, nzoff, nblocks ;
  43 //
  44 //              if (Common == null)
  45 //              {
  46 //                      return (FALSE) ;
  47 //              }
  48 //              if (NumericHandle == null || NumericHandle == null)
  49 //              {
  50 //                      return (TRUE) ;
  51 //              }
  52 //
  53 //              Numeric = NumericHandle ;
  54 //
  55 //              n = Numeric.n ;
  56 //              nzoff = Numeric.nzoff ;
  57 //              nblocks = Numeric.nblocks ;
  58 //              LUsize = Numeric.LUsize ;
  59 //
  60 //              LUbx = (double[][]) Numeric.LUbx ;
  61 //              if (LUbx != null)
  62 //              {
  63 //                      for (block = 0 ; block < nblocks ; block++)
  64 //                      {
  65 //                              KLU_free (LUbx [block], LUsize ? LUsize [block] : 0,
  66 //                                      sizeof (double), Common) ;
  67 //                      }
  68 //              }
  69 //
  70 //              KLU_free (Numeric.Pnum, n, sizeof (Integer), Common) ;
  71 //              KLU_free (Numeric.Offp, n+1, sizeof (Integer), Common) ;
  72 //              KLU_free (Numeric.Offi, nzoff+1, sizeof (Integer), Common) ;
  73 //              KLU_free (Numeric.Offx, nzoff+1, sizeof (double), Common) ;
  74 //
  75 //              KLU_free (Numeric.Lip,  n, sizeof (Integer), Common) ;
  76 //              KLU_free (Numeric.Llen, n, sizeof (Integer), Common) ;
  77 //              KLU_free (Numeric.Uip,  n, sizeof (Integer), Common) ;
  78 //              KLU_free (Numeric.Ulen, n, sizeof (Integer), Common) ;
  79 //
  80 //              KLU_free (Numeric.LUsize, nblocks, sizeof (int), Common) ;
  81 //
  82 //              KLU_free (Numeric.LUbx, nblocks, sizeof (double[]), Common) ;
  83 //
  84 //              KLU_free (Numeric.Udiag, n, sizeof (double), Common) ;
  85 //
  86 //              KLU_free (Numeric.Rs,   n, sizeof (Double), Common) ;
  87 //              KLU_free (Numeric.Pinv, n, sizeof (Int), Common) ;
  88 //
  89 //              KLU_free (Numeric.Work, Numeric.worksize, 1, Common) ;
  90 //
  91 //              KLU_free (Numeric, 1, sizeof (KLU_numeric), Common) ;
  92 //
  93 //              NumericHandle = null ;
  94 //              return (TRUE) ;
  95 //      }
  96
  97 }