Public Member Functions | Private Member Functions | Private Attributes
sparse_number_mat Class Reference

Public Member Functions

 sparse_number_mat (ideal, const ring)
 
 ~sparse_number_mat ()
 
int smIsSing ()
 
void smTriangular ()
 
void smSolv ()
 
ideal smRes2Ideal ()
 

Private Member Functions

void smColToRow ()
 
void smRowToCol ()
 
void smSelectPR ()
 
void smRealPivot ()
 
void smZeroToredElim ()
 
void smGElim ()
 
void smAllDel ()
 

Private Attributes

int nrows
 
int ncols
 
int act
 
int crd
 
int tored
 
int sing
 
int rpiv
 
int * perm
 
number * sol
 
int * wrw
 
int * wcl
 
smnumberm_act
 
smnumberm_res
 
smnumberm_row
 
smnumber red
 
smnumber piv
 
smnumber dumm
 
ring _R
 

Detailed Description

Definition at line 2331 of file sparsmat.cc.

Constructor & Destructor Documentation

sparse_number_mat::sparse_number_mat ( ideal  smat,
const ring  R 
)

Definition at line 2407 of file sparsmat.cc.

2408 {
2409  int i;
2410  poly* pmat;
2411  _R=R;
2412 
2413  crd = sing = 0;
2414  act = ncols = smat->ncols;
2415  tored = nrows = smat->rank;
2416  i = tored+1;
2417  perm = (int *)omAlloc(sizeof(int)*i);
2418  m_row = (smnumber *)omAlloc0(sizeof(smnumber)*i);
2419  wrw = (int *)omAlloc(sizeof(int)*i);
2420  i = ncols+1;
2421  wcl = (int *)omAlloc(sizeof(int)*i);
2422  m_act = (smnumber *)omAlloc(sizeof(smnumber)*i);
2423  m_res = (smnumber *)omAlloc0(sizeof(smnumber)*i);
2425  pmat = smat->m;
2426  for(i=ncols; i; i--)
2427  {
2428  m_act[i] = sm_Poly2Smnumber(pmat[i-1],_R);
2429  }
2430  omFreeSize((ADDRESS)pmat,smat->ncols*sizeof(poly));
2432 }
#define omAllocBin(bin)
Definition: omAllocDecl.h:205
smnumber * m_res
Definition: sparsmat.cc:2343
omBin sip_sideal_bin
Definition: simpleideals.cc:30
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void * ADDRESS
Definition: auxiliary.h:161
#define omAlloc(size)
Definition: omAllocDecl.h:210
smnumber * m_act
Definition: sparsmat.cc:2342
sm_nrec * smnumber
Definition: sparsmat.cc:2313
const ring R
Definition: DebugPrint.cc:36
int i
Definition: cfEzgcd.cc:123
smnumber * m_row
Definition: sparsmat.cc:2344
static smnumber sm_Poly2Smnumber(poly, const ring)
Definition: sparsmat.cc:2901
static omBin smnrec_bin
Definition: sparsmat.cc:2320
polyrec * poly
Definition: hilb.h:10
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
#define omAlloc0(size)
Definition: omAllocDecl.h:211
sparse_number_mat::~sparse_number_mat ( )

Definition at line 2437 of file sparsmat.cc.

2438 {
2439  int i;
2441  i = ncols+1;
2442  omFreeSize((ADDRESS)m_res, sizeof(smnumber)*i);
2443  omFreeSize((ADDRESS)m_act, sizeof(smnumber)*i);
2444  omFreeSize((ADDRESS)wcl, sizeof(int)*i);
2445  i = nrows+1;
2446  omFreeSize((ADDRESS)wrw, sizeof(int)*i);
2447  omFreeSize((ADDRESS)m_row, sizeof(smnumber)*i);
2448  omFreeSize((ADDRESS)perm, sizeof(int)*i);
2449 }
smnumber * m_res
Definition: sparsmat.cc:2343
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void * ADDRESS
Definition: auxiliary.h:161
smnumber * m_act
Definition: sparsmat.cc:2342
sm_nrec * smnumber
Definition: sparsmat.cc:2313
int i
Definition: cfEzgcd.cc:123
smnumber * m_row
Definition: sparsmat.cc:2344
static omBin smnrec_bin
Definition: sparsmat.cc:2320
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259

Member Function Documentation

void sparse_number_mat::smAllDel ( )
private

Definition at line 2851 of file sparsmat.cc.

2852 {
2853  smnumber a;
2854  int i;
2855 
2856  for (i=act; i; i--)
2857  {
2858  a = m_act[i];
2859  while (a != NULL)
2860  sm_NumberDelete(&a,_R);
2861  }
2862  for (i=crd; i; i--)
2863  {
2864  a = m_res[i];
2865  while (a != NULL)
2866  sm_NumberDelete(&a,_R);
2867  }
2868  if (act)
2869  {
2870  for (i=nrows; i; i--)
2871  {
2872  a = m_row[i];
2873  while (a != NULL)
2874  sm_NumberDelete(&a,_R);
2875  }
2876  }
2877 }
smnumber * m_res
Definition: sparsmat.cc:2343
const poly a
Definition: syzextra.cc:212
static void sm_NumberDelete(smnumber *, const ring R)
Definition: sparsmat.cc:2881
smnumber * m_act
Definition: sparsmat.cc:2342
sm_nrec * smnumber
Definition: sparsmat.cc:2313
int i
Definition: cfEzgcd.cc:123
smnumber * m_row
Definition: sparsmat.cc:2344
#define NULL
Definition: omList.c:10
void sparse_number_mat::smColToRow ( )
private

Definition at line 2776 of file sparsmat.cc.

2777 {
2778  smnumber c = m_act[act];
2779  smnumber h;
2780 
2781  while (c != NULL)
2782  {
2783  h = c;
2784  c = c->n;
2785  h->n = m_row[h->pos];
2786  m_row[h->pos] = h;
2787  h->pos = crd;
2788  }
2789 }
smnumber * m_act
Definition: sparsmat.cc:2342
sm_nrec * smnumber
Definition: sparsmat.cc:2313
smnumber * m_row
Definition: sparsmat.cc:2344
#define NULL
Definition: omList.c:10
static Poly * h
Definition: janet.cc:978
void sparse_number_mat::smGElim ( )
private

Definition at line 2632 of file sparsmat.cc.

2633 {
2634  number p = n_Invers(piv->m,_R->cf); // pivotelement
2635  smnumber c = m_act[act]; // pivotcolumn
2636  smnumber r = red; // row to reduce
2637  smnumber res, a, b;
2638  number w, ha, hb;
2639 
2640  if ((c == NULL) || (r == NULL))
2641  {
2642  while (r!=NULL) sm_NumberDelete(&r,_R);
2643  return;
2644  }
2645  do
2646  {
2647  a = m_act[r->pos];
2648  res = dumm;
2649  res->n = NULL;
2650  b = c;
2651  w = n_Mult(r->m, p,_R->cf);
2652  n_Delete(&r->m,_R->cf);
2653  r->m = w;
2654  loop // combine the chains a and b: a + w*b
2655  {
2656  if (a == NULL)
2657  {
2658  do
2659  {
2660  res = res->n = smNumberCopy(b);
2661  res->m = n_Mult(b->m, w,_R->cf);
2662  b = b->n;
2663  } while (b != NULL);
2664  break;
2665  }
2666  if (a->pos < b->pos)
2667  {
2668  res = res->n = a;
2669  a = a->n;
2670  }
2671  else if (a->pos > b->pos)
2672  {
2673  res = res->n = smNumberCopy(b);
2674  res->m = n_Mult(b->m, w,_R->cf);
2675  b = b->n;
2676  }
2677  else
2678  {
2679  hb = n_Mult(b->m, w,_R->cf);
2680  ha = n_Add(a->m, hb,_R->cf);
2681  n_Delete(&hb,_R->cf);
2682  n_Delete(&a->m,_R->cf);
2683  if (n_IsZero(ha,_R->cf))
2684  {
2685  sm_NumberDelete(&a,_R);
2686  }
2687  else
2688  {
2689  a->m = ha;
2690  res = res->n = a;
2691  a = a->n;
2692  }
2693  b = b->n;
2694  }
2695  if (b == NULL)
2696  {
2697  res->n = a;
2698  break;
2699  }
2700  }
2701  m_act[r->pos] = dumm->n;
2702  sm_NumberDelete(&r,_R);
2703  } while (r != NULL);
2704  n_Delete(&p,_R->cf);
2705 }
const poly a
Definition: syzextra.cc:212
loop
Definition: myNF.cc:98
return P p
Definition: myNF.cc:203
static void sm_NumberDelete(smnumber *, const ring R)
Definition: sparsmat.cc:2881
smnumber * m_act
Definition: sparsmat.cc:2342
poly res
Definition: myNF.cc:322
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:637
sm_nrec * smnumber
Definition: sparsmat.cc:2313
const ring r
Definition: syzextra.cc:208
static smnumber smNumberCopy(smnumber)
Definition: sparsmat.cc:2890
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of &#39;a&#39; and &#39;b&#39;, i.e., a+b
Definition: coeffs.h:657
static FORCE_INLINE number n_Invers(number a, const coeffs r)
return the multiplicative inverse of &#39;a&#39;; raise an error if &#39;a&#39; is not invertible ...
Definition: coeffs.h:565
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
#define NULL
Definition: omList.c:10
const CanonicalForm & w
Definition: facAbsFact.cc:55
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
const poly b
Definition: syzextra.cc:213
int sparse_number_mat::smIsSing ( )
inline

Definition at line 2359 of file sparsmat.cc.

2359 { return sing; }
void sparse_number_mat::smRealPivot ( )
private

Definition at line 2581 of file sparsmat.cc.

2582 {
2583  smnumber a;
2584  number x, xo;
2585  int i, copt, ropt;
2586 
2587  xo=n_Init(0,_R->cf);
2588  for (i=act; i; i--)
2589  {
2590  a = m_act[i];
2591  while ((a!=NULL) && (a->pos<=tored))
2592  {
2593  x = a->m;
2594  if (n_GreaterZero(x,_R->cf))
2595  {
2596  if (n_Greater(x,xo,_R->cf))
2597  {
2598  n_Delete(&xo,_R->cf);
2599  xo = n_Copy(x,_R->cf);
2600  copt = i;
2601  ropt = a->pos;
2602  }
2603  }
2604  else
2605  {
2606  xo = n_InpNeg(xo,_R->cf);
2607  if (n_Greater(xo,x,_R->cf))
2608  {
2609  n_Delete(&xo,_R->cf);
2610  xo = n_Copy(x,_R->cf);
2611  copt = i;
2612  ropt = a->pos;
2613  }
2614  xo = n_InpNeg(xo,_R->cf);
2615  }
2616  a = a->n;
2617  }
2618  }
2619  rpiv = ropt;
2620  if (copt != act)
2621  {
2622  a = m_act[act];
2623  m_act[act] = m_act[copt];
2624  m_act[copt] = a;
2625  }
2626  n_Delete(&xo,_R->cf);
2627 }
static FORCE_INLINE BOOLEAN n_Greater(number a, number b, const coeffs r)
ordered fields: TRUE iff &#39;a&#39; is larger than &#39;b&#39;; in Z/pZ: TRUE iff la > lb, where la and lb are the l...
Definition: coeffs.h:512
const poly a
Definition: syzextra.cc:212
static FORCE_INLINE number n_Init(long i, const coeffs r)
a number representing i in the given coeff field/ring r
Definition: coeffs.h:539
smnumber * m_act
Definition: sparsmat.cc:2342
sm_nrec * smnumber
Definition: sparsmat.cc:2313
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition: coeffs.h:558
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Copy(number n, const coeffs r)
return a copy of &#39;n&#39;
Definition: coeffs.h:452
Variable x
Definition: cfModGcd.cc:4023
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
static FORCE_INLINE BOOLEAN n_GreaterZero(number n, const coeffs r)
ordered fields: TRUE iff &#39;n&#39; is positive; in Z/pZ: TRUE iff 0 < m <= roundedBelow(p/2), where m is the long representing n in C: TRUE iff (Im(n) != 0 and Im(n) >= 0) or (Im(n) == 0 and Re(n) >= 0) in K(a)/<p(a)>: TRUE iff (n != 0 and (LC(n) > 0 or deg(n) > 0)) in K(t_1, ..., t_n): TRUE iff (LC(numerator(n) is a constant and > 0) or (LC(numerator(n) is not a constant) in Z/2^kZ: TRUE iff 0 < n <= 2^(k-1) in Z/mZ: TRUE iff the internal mpz is greater than zero in Z: TRUE iff n > 0
Definition: coeffs.h:495
ideal sparse_number_mat::smRes2Ideal ( )

Definition at line 2562 of file sparsmat.cc.

2563 {
2564  int i, j;
2565  ideal res = idInit(crd, 1);
2566 
2567  for (i=crd; i; i--)
2568  {
2569  j = perm[i]-1;
2570  res->m[j] = sm_Smnumber2Poly(sol[i],_R);
2571  }
2572  omFreeSize((ADDRESS)sol, sizeof(number)*(crd+1));
2573  return res;
2574 }
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260
void * ADDRESS
Definition: auxiliary.h:161
poly res
Definition: myNF.cc:322
static poly sm_Smnumber2Poly(number, const ring)
Definition: sparsmat.cc:2932
int j
Definition: myNF.cc:70
int i
Definition: cfEzgcd.cc:123
ideal idInit(int idsize, int rank)
initialise an ideal / module
Definition: simpleideals.cc:38
void sparse_number_mat::smRowToCol ( )
private

Definition at line 2796 of file sparsmat.cc.

2797 {
2798  smnumber r = m_row[rpiv];
2799  smnumber a, ap, h;
2800 
2801  m_row[rpiv] = NULL;
2802  perm[crd] = rpiv;
2803  piv->pos = crd;
2804  m_res[crd] = piv;
2805  while (r != NULL)
2806  {
2807  ap = m_res[r->pos];
2808  loop
2809  {
2810  a = ap->n;
2811  if (a == NULL)
2812  {
2813  ap->n = h = r;
2814  r = r->n;
2815  h->n = a;
2816  h->pos = crd;
2817  break;
2818  }
2819  ap = a;
2820  }
2821  }
2822 }
smnumber * m_res
Definition: sparsmat.cc:2343
const poly a
Definition: syzextra.cc:212
loop
Definition: myNF.cc:98
sm_nrec * smnumber
Definition: sparsmat.cc:2313
const ring r
Definition: syzextra.cc:208
smnumber * m_row
Definition: sparsmat.cc:2344
#define NULL
Definition: omList.c:10
static Poly * h
Definition: janet.cc:978
void sparse_number_mat::smSelectPR ( )
private

Definition at line 2712 of file sparsmat.cc.

2713 {
2714  smnumber b = dumm;
2715  smnumber a, ap;
2716  int i;
2717 
2718  if (TEST_OPT_PROT)
2719  {
2720  if ((crd+1)%10)
2721  PrintS(".");
2722  else
2723  PrintS(".\n");
2724  }
2725  a = m_act[act];
2726  if (a->pos < rpiv)
2727  {
2728  do
2729  {
2730  ap = a;
2731  a = a->n;
2732  } while (a->pos < rpiv);
2733  ap->n = a->n;
2734  }
2735  else
2736  m_act[act] = a->n;
2737  piv = a;
2738  a->n = NULL;
2739  for (i=1; i<act; i++)
2740  {
2741  a = m_act[i];
2742  if (a->pos < rpiv)
2743  {
2744  loop
2745  {
2746  ap = a;
2747  a = a->n;
2748  if ((a == NULL) || (a->pos > rpiv))
2749  break;
2750  if (a->pos == rpiv)
2751  {
2752  ap->n = a->n;
2753  a->m = n_InpNeg(a->m,_R);
2754  b = b->n = a;
2755  b->pos = i;
2756  break;
2757  }
2758  }
2759  }
2760  else if (a->pos == rpiv)
2761  {
2762  m_act[i] = a->n;
2763  a->m = n_InpNeg(a->m,_R);
2764  b = b->n = a;
2765  b->pos = i;
2766  }
2767  }
2768  b->n = NULL;
2769  red = dumm->n;
2770 }
const poly a
Definition: syzextra.cc:212
#define TEST_OPT_PROT
Definition: options.h:98
loop
Definition: myNF.cc:98
smnumber * m_act
Definition: sparsmat.cc:2342
sm_nrec * smnumber
Definition: sparsmat.cc:2313
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition: coeffs.h:558
int i
Definition: cfEzgcd.cc:123
void PrintS(const char *s)
Definition: reporter.cc:294
#define NULL
Definition: omList.c:10
const poly b
Definition: syzextra.cc:213
void sparse_number_mat::smSolv ( )

Definition at line 2485 of file sparsmat.cc.

2486 {
2487  int i, j;
2488  number x, y, z;
2489  smnumber s, d, r = m_row[nrows];
2490 
2491  m_row[nrows] = NULL;
2492  sol = (number *)omAlloc0(sizeof(number)*(crd+1));
2493  while (r != NULL) // expand the rigth hand side
2494  {
2495  sol[r->pos] = r->m;
2496  s = r;
2497  r = r->n;
2499  }
2500  i = crd; // solve triangular system
2501  if (sol[i] != NULL)
2502  {
2503  x = sol[i];
2504  sol[i] = n_Div(x, m_res[i]->m,_R->cf);
2505  n_Delete(&x,_R->cf);
2506  }
2507  i--;
2508  while (i > 0)
2509  {
2510  x = NULL;
2511  d = m_res[i];
2512  s = d->n;
2513  while (s != NULL)
2514  {
2515  j = s->pos;
2516  if (sol[j] != NULL)
2517  {
2518  z = n_Mult(sol[j], s->m,_R->cf);
2519  if (x != NULL)
2520  {
2521  y = x;
2522  x = n_Sub(y, z,_R->cf);
2523  n_Delete(&y,_R->cf);
2524  n_Delete(&z,_R->cf);
2525  }
2526  else
2527  x = n_InpNeg(z,_R->cf);
2528  }
2529  s = s->n;
2530  }
2531  if (sol[i] != NULL)
2532  {
2533  if (x != NULL)
2534  {
2535  y = n_Add(x, sol[i],_R->cf);
2536  n_Delete(&x,_R->cf);
2537  if (n_IsZero(y,_R->cf))
2538  {
2539  n_Delete(&sol[i],_R->cf);
2540  sol[i] = NULL;
2541  }
2542  else
2543  sol[i] = y;
2544  }
2545  }
2546  else
2547  sol[i] = x;
2548  if (sol[i] != NULL)
2549  {
2550  x = sol[i];
2551  sol[i] = n_Div(x, d->m,_R->cf);
2552  n_Delete(&x,_R->cf);
2553  }
2554  i--;
2555  }
2556  this->smAllDel();
2557 }
static FORCE_INLINE number n_Sub(number a, number b, const coeffs r)
return the difference of &#39;a&#39; and &#39;b&#39;, i.e., a-b
Definition: coeffs.h:670
const CanonicalForm int s
Definition: facAbsFact.cc:55
smnumber * m_res
Definition: sparsmat.cc:2343
const CanonicalForm int const CFList const Variable & y
Definition: facAbsFact.cc:57
void * ADDRESS
Definition: auxiliary.h:161
static FORCE_INLINE number n_Mult(number a, number b, const coeffs r)
return the product of &#39;a&#39; and &#39;b&#39;, i.e., a*b
Definition: coeffs.h:637
sm_nrec * smnumber
Definition: sparsmat.cc:2313
const ring r
Definition: syzextra.cc:208
int j
Definition: myNF.cc:70
static FORCE_INLINE number n_Add(number a, number b, const coeffs r)
return the sum of &#39;a&#39; and &#39;b&#39;, i.e., a+b
Definition: coeffs.h:657
int m
Definition: cfEzgcd.cc:119
static FORCE_INLINE number n_InpNeg(number n, const coeffs r)
in-place negation of n MUST BE USED: n = n_InpNeg(n) (no copy is returned)
Definition: coeffs.h:558
int i
Definition: cfEzgcd.cc:123
static FORCE_INLINE BOOLEAN n_IsZero(number n, const coeffs r)
TRUE iff &#39;n&#39; represents the zero element.
Definition: coeffs.h:465
smnumber * m_row
Definition: sparsmat.cc:2344
#define NULL
Definition: omList.c:10
static FORCE_INLINE number n_Div(number a, number b, const coeffs r)
return the quotient of &#39;a&#39; and &#39;b&#39;, i.e., a/b; raises an error if &#39;b&#39; is not invertible in r exceptio...
Definition: coeffs.h:616
Variable x
Definition: cfModGcd.cc:4023
static omBin smnrec_bin
Definition: sparsmat.cc:2320
static FORCE_INLINE void n_Delete(number *p, const coeffs r)
delete &#39;p&#39;
Definition: coeffs.h:456
#define omFreeBin(addr, bin)
Definition: omAllocDecl.h:259
#define omAlloc0(size)
Definition: omAllocDecl.h:211
void sparse_number_mat::smTriangular ( )

Definition at line 2454 of file sparsmat.cc.

2455 {
2456  tored--;
2457  this->smZeroToredElim();
2458  if (sing != 0) return;
2459  while (act > 1)
2460  {
2461  this->smRealPivot();
2462  this->smSelectPR();
2463  this->smGElim();
2464  crd++;
2465  this->smColToRow();
2466  act--;
2467  this->smRowToCol();
2468  this->smZeroToredElim();
2469  if (sing != 0) return;
2470  }
2471  if (TEST_OPT_PROT) PrintS(".\n");
2472  piv = m_act[1];
2473  rpiv = piv->pos;
2474  m_act[1] = piv->n;
2475  piv->n = NULL;
2476  crd++;
2477  this->smColToRow();
2478  act--;
2479  this->smRowToCol();
2480 }
#define TEST_OPT_PROT
Definition: options.h:98
smnumber * m_act
Definition: sparsmat.cc:2342
void smZeroToredElim()
Definition: sparsmat.cc:2829
void PrintS(const char *s)
Definition: reporter.cc:294
#define NULL
Definition: omList.c:10
void sparse_number_mat::smZeroToredElim ( )
private

Definition at line 2829 of file sparsmat.cc.

2830 {
2831  smnumber a;
2832  int i = act;
2833 
2834  loop
2835  {
2836  if (i == 0) return;
2837  a = m_act[i];
2838  if ((a==NULL) || (a->pos>tored))
2839  {
2840  sing = 1;
2841  this->smAllDel();
2842  return;
2843  }
2844  i--;
2845  }
2846 }
const poly a
Definition: syzextra.cc:212
loop
Definition: myNF.cc:98
smnumber * m_act
Definition: sparsmat.cc:2342
sm_nrec * smnumber
Definition: sparsmat.cc:2313
int i
Definition: cfEzgcd.cc:123
#define NULL
Definition: omList.c:10

Field Documentation

ring sparse_number_mat::_R
private

Definition at line 2348 of file sparsmat.cc.

int sparse_number_mat::act
private

Definition at line 2334 of file sparsmat.cc.

int sparse_number_mat::crd
private

Definition at line 2335 of file sparsmat.cc.

smnumber sparse_number_mat::dumm
private

Definition at line 2347 of file sparsmat.cc.

smnumber* sparse_number_mat::m_act
private

Definition at line 2342 of file sparsmat.cc.

smnumber* sparse_number_mat::m_res
private

Definition at line 2343 of file sparsmat.cc.

smnumber* sparse_number_mat::m_row
private

Definition at line 2344 of file sparsmat.cc.

int sparse_number_mat::ncols
private

Definition at line 2333 of file sparsmat.cc.

int sparse_number_mat::nrows
private

Definition at line 2333 of file sparsmat.cc.

int* sparse_number_mat::perm
private

Definition at line 2339 of file sparsmat.cc.

smnumber sparse_number_mat::piv
private

Definition at line 2346 of file sparsmat.cc.

smnumber sparse_number_mat::red
private

Definition at line 2345 of file sparsmat.cc.

int sparse_number_mat::rpiv
private

Definition at line 2338 of file sparsmat.cc.

int sparse_number_mat::sing
private

Definition at line 2337 of file sparsmat.cc.

number* sparse_number_mat::sol
private

Definition at line 2340 of file sparsmat.cc.

int sparse_number_mat::tored
private

Definition at line 2336 of file sparsmat.cc.

int * sparse_number_mat::wcl
private

Definition at line 2341 of file sparsmat.cc.

int* sparse_number_mat::wrw
private

Definition at line 2341 of file sparsmat.cc.


The documentation for this class was generated from the following file: