sparsmat.cc File Reference

#include "misc/auxiliary.h"
#include "misc/mylimits.h"
#include "misc/options.h"
#include "reporter/reporter.h"
#include "misc/intvec.h"
#include "coeffs/numbers.h"
#include "monomials/ring.h"
#include "monomials/p_polys.h"
#include "simpleideals.h"
#include "sparsmat.h"
#include "prCopy.h"
#include "templates/p_Procs.h"
#include "kbuckets.h"
#include "operations/p_Mult_q.h"

Go to the source code of this file.

Data Structures
struct	sm_prec
class	sparse_mat
struct	sm_nrec
class	sparse_number_mat

Macros
#define	SM_MIN_LENGTH_BUCKET   MIN_LENGTH_BUCKET - 5

Typedefs
typedef sm_prec *	smpoly
typedef sm_nrec *	smnumber

Functions
static void	sm_ExactPolyDiv (poly, poly, const ring)
static BOOLEAN	sm_IsNegQuot (poly, const poly, const poly, const ring)
static void	sm_ExpMultDiv (poly, const poly, const poly, const ring)
static void	sm_PolyDivN (poly, const number, const ring)
static BOOLEAN	smSmaller (poly, poly)
static void	sm_CombineChain (poly *, poly, const ring)
static void	sm_FindRef (poly *, poly *, poly, const ring)
static void	sm_ElemDelete (smpoly *, const ring)
static smpoly	smElemCopy (smpoly)
static float	sm_PolyWeight (smpoly, const ring)
static smpoly	sm_Poly2Smpoly (poly, const ring)
static poly	sm_Smpoly2Poly (smpoly, const ring)
static BOOLEAN	sm_HaveDenom (poly, const ring)
static number	sm_Cleardenom (ideal, const ring)
static poly	pp_Mult_Coeff_mm_DivSelect_MultDiv (poly p, int &lp, poly m, poly a, poly b, const ring currRing)
static poly	sm_SelectCopy_ExpMultDiv (poly p, poly m, poly a, poly b, const ring currRing)
static void	smMinSelect (long *, int, int)
long	sm_ExpBound (ideal m, int di, int ra, int t, const ring currRing)
ring	sm_RingChange (const ring origR, long bound)
void	sm_KillModifiedRing (ring r)
poly	sm_CallDet (ideal I, const ring R)
void	sm_CallBareiss (ideal I, int x, int y, ideal &M, intvec **iv, const ring R)
poly	sm_MultDiv (poly a, poly b, const poly c, const ring R)
void	sm_SpecialPolyDiv (poly a, poly b, const ring R)
static void	sm_NumberDelete (smnumber *, const ring R)
static smnumber	smNumberCopy (smnumber)
static smnumber	sm_Poly2Smnumber (poly, const ring)
static poly	sm_Smnumber2Poly (number, const ring)
static BOOLEAN	smCheckSolv (ideal)
ideal	sm_CallSolv (ideal I, const ring R)

Variables
VAR omBin	smprec_bin = omGetSpecBin(sizeof(smprec))
STATIC_VAR omBin	smnrec_bin = omGetSpecBin(sizeof(smnrec))

---

Data Structure Documentation

smprec

struct smprec

Definition at line 47 of file sparsmat.cc.

Data Fields
int	e
float	f
poly	m
smpoly	n
int	pos

smnrec

struct smnrec

Definition at line 2258 of file sparsmat.cc.

Data Fields
number	m
smnumber	n
int	pos

Macro Definition Documentation

SM_MIN_LENGTH_BUCKET

#define SM_MIN_LENGTH_BUCKET   MIN_LENGTH_BUCKET - 5

Definition at line 40 of file sparsmat.cc.

Typedef Documentation

smnumber

typedef sm_nrec* smnumber

Definition at line 2257 of file sparsmat.cc.

smpoly

typedef sm_prec* smpoly

Definition at line 46 of file sparsmat.cc.

Function Documentation

pp_Mult_Coeff_mm_DivSelect_MultDiv()

static poly pp_Mult_Coeff_mm_DivSelect_MultDiv ( poly  p, int &  lp, poly  m, poly  a, poly  b, const ring  currRing  )

static

Definition at line 76 of file sparsmat.cc.

{
  if (rOrd_is_Comp_dp(currRing) && currRing->ExpL_Size > 2)
  {
    // pp_Mult_Coeff_mm_DivSelectMult only works for (c/C,dp) and
    // ExpL_Size > 2
    // should be generalized, at least to dp with ExpL_Size == 2
    // (is the case for 1 variable)
    int shorter;
    p = currRing->p_Procs->pp_Mult_Coeff_mm_DivSelectMult(p, m, a, b,
                                                          shorter, currRing);
    lp -= shorter;
  }
  else
  {
    p = pp_Mult_Coeff_mm_DivSelect(p, lp, m, currRing);
    sm_ExpMultDiv(p, a, b, currRing);
  }
  return p;
}

sm_CallBareiss()

void sm_CallBareiss	(	ideal	I,
		int	x,
		int	y,
		ideal &	M,
		intvec **	iv,
		const ring	R
	)

Definition at line 347 of file sparsmat.cc.

{
  int r=id_RankFreeModule(I,R),t=r;
  int c=IDELEMS(I),s=c;
  long bound;
  ring tmpR;
  sparse_mat *bareiss;
 
  if ((x>0) && (x<t))
    t-=x;
  if ((y>1) && (y<s))
    s-=y;
  if (t>s) t=s;
  bound=sm_ExpBound(I,c,r,t,R);
  tmpR=sm_RingChange(R,bound);
  ideal II = idrCopyR(I, R, tmpR);
  bareiss = new sparse_mat(II,tmpR);
  if (bareiss->smGetAct() == NULL)
  {
    delete bareiss;
    *iv=new intvec(1,rVar(tmpR));
  }
  else
  {
    id_Delete(&II,tmpR);
    bareiss->smNewBareiss(x, y);
    II = bareiss->smRes2Mod();
    *iv = new intvec(bareiss->smGetRed());
    bareiss->smToIntvec(*iv);
    delete bareiss;
    II = idrMoveR(II,tmpR,R);
  }
  sm_KillModifiedRing(tmpR);
  M=II;
}

sm_CallDet()

poly sm_CallDet	(	ideal	I,
		const ring	R
	)

Definition at line 302 of file sparsmat.cc.

{
  if (I->ncols != I->rank)
  {
    Werror("det of %ld x %d module (matrix)",I->rank,I->ncols);
    return NULL;
  }
  int r=id_RankFreeModule(I,R);
  if (I->ncols != r) // some 0-lines at the end
  {
    return NULL;
  }
  long bound=sm_ExpBound(I,r,r,r,R);
  number diag,h=n_Init(1,R->cf);
  poly res;
  ring tmpR;
  sparse_mat *det;
  ideal II;
 
  tmpR=sm_RingChange(R,bound);
  II = idrCopyR(I, R, tmpR);
  diag = sm_Cleardenom(II,tmpR);
  det = new sparse_mat(II,tmpR);
  id_Delete(&II,tmpR);
  if (det->smGetAct() == NULL)
  {
    delete det;
    sm_KillModifiedRing(tmpR);
    return NULL;
  }
  res=det->smDet();
  if(det->smGetSign()<0) res=p_Neg(res,tmpR);
  delete det;
  res = prMoveR(res, tmpR, R);
  sm_KillModifiedRing(tmpR);
  if (!n_Equal(diag,h,R->cf))
  {
    p_Mult_nn(res,diag,R);
    p_Normalize(res,R);
  }
  n_Delete(&diag,R->cf);
  n_Delete(&h,R->cf);
  return res;
}

sm_CallSolv()

ideal sm_CallSolv	(	ideal	I,
		const ring	R
	)

Definition at line 2316 of file sparsmat.cc.

{
  sparse_number_mat *linsolv;
  ring tmpR;
  ideal rr;
 
  if (id_IsConstant(I,R)==FALSE)
  {
    WerrorS("symbol in equation");
    return NULL;
  }
  I->rank = id_RankFreeModule(I,R);
  if (smCheckSolv(I)) return NULL;
  tmpR=sm_RingChange(R,1);
  rr=idrCopyR(I,R, tmpR);
  linsolv = new sparse_number_mat(rr,tmpR);
  rr=NULL;
  linsolv->smTriangular();
  if (linsolv->smIsSing() == 0)
  {
    linsolv->smSolv();
    rr = linsolv->smRes2Ideal();
  }
  else
    WerrorS("singular problem for linsolv");
  delete linsolv;
  if (rr!=NULL)
    rr = idrMoveR(rr,tmpR,R);
  sm_KillModifiedRing(tmpR);
  return rr;
}

sm_Cleardenom()

static number sm_Cleardenom ( ideal  id, const ring  R  )

static

Definition at line 2223 of file sparsmat.cc.

{
  poly a;
  number x,y,res=n_Init(1,R->cf);
  BOOLEAN sw=FALSE;
 
  for (int i=0; i<IDELEMS(id); i++)
  {
    a = id->m[i];
    sw = sm_HaveDenom(a,R);
    if (sw) break;
  }
  if (!sw) return res;
  for (int i=0; i<IDELEMS(id); i++)
  {
    a = id->m[i];
    if (a!=NULL)
    {
      x = n_Copy(pGetCoeff(a),R->cf);
      p_Cleardenom(a, R);
      y = n_Div(x,pGetCoeff(a),R->cf);
      n_Delete(&x,R->cf);
      x = n_Mult(res,y,R->cf);
      n_Normalize(x,R->cf);
      n_Delete(&res,R->cf);
      res = x;
    }
  }
  return res;
}

sm_CombineChain()

static void sm_CombineChain ( poly *  px, poly  r, const ring  R  )

static

Definition at line 1973 of file sparsmat.cc.

{
  poly pa = *px, pb;
  number x;
  int i;
 
  loop
  {
    pb = pNext(pa);
    if (pb == NULL)
    {
      pa = pNext(pa) = r;
      break;
    }
    i = p_LmCmp(pb, r,R);
    if (i > 0)
      pa = pb;
    else
    {
      if (i == 0)
      {
        x = n_Add(pGetCoeff(pb), pGetCoeff(r),R->cf);
        p_LmDelete(&r,R);
        if (n_IsZero(x,R->cf))
        {
          p_LmDelete(&pb,R);
          pNext(pa) = p_Add_q(pb,r,R);
        }
        else
        {
          pa = pb;
          p_SetCoeff(pa,x,R);
          pNext(pa) = p_Add_q(pNext(pa), r, R);
        }
      }
      else
      {
        pa = pNext(pa) = r;
        pNext(pa) = p_Add_q(pb, pNext(pa),R);
      }
      break;
    }
  }
  *px = pa;
}

sm_ElemDelete()

static void sm_ElemDelete ( smpoly *  r, const ring  R  )

static

Definition at line 2076 of file sparsmat.cc.

{
  smpoly a = *r, b = a->n;
 
  p_Delete(&a->m, R);
  omFreeBin((void *)a,  smprec_bin);
  *r = b;
}

sm_ExactPolyDiv()

static void sm_ExactPolyDiv ( poly  a, poly  b, const ring  R  )

static

Definition at line 1851 of file sparsmat.cc.

{
  const number x = pGetCoeff(b);
  poly tail = pNext(b), e = p_Init(R);
  poly h;
  number y, yn;
  int lt = pLength(tail);
 
  if (lt + 1 >= SM_MIN_LENGTH_BUCKET &&  !TEST_OPT_NOT_BUCKETS)
  {
    kBucket_pt bucket = kBucketCreate(R);
    kBucketInit(bucket, pNext(a), 0);
    int lh = 0;
    do
    {
      y = n_Div(pGetCoeff(a), x, R->cf);
      n_Normalize(y, R->cf);
      p_SetCoeff(a,y, R);
      yn = n_InpNeg(n_Copy(y, R->cf), R->cf);
      pSetCoeff0(e,yn);
      lh = lt;
      if (sm_IsNegQuot(e, a, b, R))
      {
        h = pp_Mult_Coeff_mm_DivSelect_MultDiv(tail, lh, e, a, b, R);
      }
      else
        h = pp_Mult_mm(tail, e, R);
      n_Delete(&yn, R->cf);
      kBucket_Add_q(bucket, h, &lh);
 
      a = pNext(a) = kBucketExtractLm(bucket);
    } while (a!=NULL);
    kBucketDestroy(&bucket);
  }
  else
  {
    do
    {
      y = n_Div(pGetCoeff(a), x, R->cf);
      n_Normalize(y, R->cf);
      p_SetCoeff(a,y, R);
      yn = n_InpNeg(n_Copy(y, R->cf), R->cf);
      pSetCoeff0(e,yn);
      if (sm_IsNegQuot(e, a, b, R))
        h = sm_SelectCopy_ExpMultDiv(tail, e, a, b, R);
      else
        h = pp_Mult_mm(tail, e, R);
      n_Delete(&yn, R->cf);
      a = pNext(a) = p_Add_q(pNext(a), h, R);
    } while (a!=NULL);
  }
  p_LmFree(e, R);
}

sm_ExpBound()

long sm_ExpBound	(	ideal	m,
		int	di,
		int	ra,
		int	t,
		const ring	currRing
	)

Definition at line 188 of file sparsmat.cc.

{
  poly p;
  long kr, kc;
  long *r, *c;
  int al, bl, i, j, k;
 
  if (ra==0) ra=1;
  al = di*sizeof(long);
  c = (long *)omAlloc(al);
  bl = ra*sizeof(long);
  r = (long *)omAlloc0(bl);
  for (i=di-1;i>=0;i--)
  {
    kc = 0;
    p = m->m[i];
    while(p!=NULL)
    {
      k = p_GetComp(p, currRing)-1;
      kr = r[k];
      for (j=currRing->N;j>0;j--)
      {
        long t=p_GetExp(p,j, currRing);
        if(t /*p_GetExp(p,j, currRing)*/ >kc)
          kc=t; /*p_GetExp(p,j, currRing);*/
        if(t /*p_GetExp(p,j, currRing)s*/ >kr)
          kr=t; /*p_GetExp(p,j, currRing);*/
      }
      r[k] = kr;
      pIter(p);
    }
    c[i] = kc;
  }
  if (t<di) smMinSelect(c, t, di);
  if (t<ra) smMinSelect(r, t, ra);
  kr = kc = 0;
  for (j=t-1;j>=0;j--)
  {
    kr += r[j];
    kc += c[j];
  }
  omFreeSize((ADDRESS)c, al);
  omFreeSize((ADDRESS)r, bl);
  if (kr<kc) kc = kr;
  if (kr<1) kr = 1;
  return kr;
}

sm_ExpMultDiv()

static void sm_ExpMultDiv ( poly  t, const poly  b, const poly  c, const ring  R  )

static

Definition at line 1931 of file sparsmat.cc.

{
  p_Test(t,R);
  p_LmTest(b,R);
  p_LmTest(c,R);
  poly bc = p_New(R);
 
  p_ExpVectorDiff(bc, b, c, R);
 
  while(t!=NULL)
  {
    p_ExpVectorAdd(t, bc, R);
    pIter(t);
  }
  p_LmFree(bc, R);
}

sm_FindRef()

static void sm_FindRef ( poly *  ref, poly *  px, poly  r, const ring  R  )

static

Definition at line 2020 of file sparsmat.cc.

{
  number x;
  int i;
  poly pa = *px, pp = NULL;
 
  loop
  {
    i = p_LmCmp(pa, r,R);
    if (i > 0)
    {
      pp = pa;
      pIter(pa);
      if (pa==NULL)
      {
        pNext(pp) = r;
        break;
      }
    }
    else
    {
      if (i == 0)
      {
        x = n_Add(pGetCoeff(pa), pGetCoeff(r),R->cf);
        p_LmDelete(&r,R);
        if (n_IsZero(x,R->cf))
        {
          p_LmDelete(&pa,R);
          if (pp!=NULL)
            pNext(pp) = p_Add_q(pa,r,R);
          else
            *px = p_Add_q(pa,r,R);
        }
        else
        {
          pp = pa;
          p_SetCoeff(pp,x,R);
          pNext(pp) = p_Add_q(pNext(pp), r, R);
        }
      }
      else
      {
        if (pp!=NULL)
          pp = pNext(pp) = r;
        else
          *px = pp = r;
        pNext(pp) = p_Add_q(pa, pNext(r),R);
      }
      break;
    }
  }
  *ref = pp;
}

sm_HaveDenom()

static BOOLEAN sm_HaveDenom ( poly  a, const ring  R  )

static

Definition at line 2204 of file sparsmat.cc.

{
  BOOLEAN sw;
  number x;
 
  while (a != NULL)
  {
    x = n_GetDenom(pGetCoeff(a),R->cf);
    sw = n_IsOne(x,R->cf);
    n_Delete(&x,R->cf);
    if (!sw)
    {
      return TRUE;
    }
    pIter(a);
  }
  return FALSE;
}

sm_IsNegQuot()

static BOOLEAN sm_IsNegQuot ( poly  a, const poly  b, const poly  c, const ring  R  )

static

Definition at line 1906 of file sparsmat.cc.

{
  if (p_LmDivisibleByNoComp(c, b,R))
  {
    p_ExpVectorDiff(a, b, c,R);
    // Hmm: here used to be a p_Setm(a): but it is unnecessary,
    // if b and c are correct
    return FALSE;
  }
  else
  {
    int i;
    for (i=rVar(R); i>0; i--)
    {
      if(p_GetExp(c,i,R) > p_GetExp(b,i,R))
        p_SetExp(a,i,p_GetExp(c,i,R)-p_GetExp(b,i,R),R);
      else
        p_SetExp(a,i,0,R);
    }
    // here we actually might need a p_Setm, if a is to be used in
    // comparisons
    return TRUE;
  }
}

sm_KillModifiedRing()

void sm_KillModifiedRing

(

ring

r

)

Definition at line 289 of file sparsmat.cc.

{
  if (r->qideal!=NULL) id_Delete(&(r->qideal),r);
  for(int i=r->N-1;i>=0;i--) omFree(r->names[i]);
  omFreeSize(r->names,r->N*sizeof(char*));
  rKillModifiedRing(r);
}

sm_MultDiv()

poly sm_MultDiv	(	poly	a,
		poly	b,
		const poly	c,
		const ring	R
	)

Definition at line 1759 of file sparsmat.cc.

{
  poly pa, e, res, r;
  BOOLEAN lead;
 
  if ((c == NULL) || p_LmIsConstantComp(c,R))
  {
    return pp_Mult_qq(a, b, R);
  }
  if (smSmaller(a, b))
  {
    r = a;
    a = b;
    b = r;
  }
  res = NULL;
  e = p_Init(R);
  lead = FALSE;
  while (!lead)
  {
    pSetCoeff0(e,pGetCoeff(b));
    if (sm_IsNegQuot(e, b, c, R))
    {
      lead = p_LmDivisibleByNoComp(e, a, R);
      r = sm_SelectCopy_ExpMultDiv(a, e, b, c, R);
    }
    else
    {
      lead = TRUE;
      r = pp_Mult_mm(a, e,R);
    }
    if (lead)
    {
      if (res != NULL)
      {
        sm_FindRef(&pa, &res, r, R);
        if (pa == NULL)
          lead = FALSE;
      }
      else
      {
        pa = res = r;
      }
    }
    else
      res = p_Add_q(res, r, R);
    pIter(b);
    if (b == NULL)
    {
      p_LmFree(e, R);
      return res;
    }
  }
  do
  {
    pSetCoeff0(e,pGetCoeff(b));
    if (sm_IsNegQuot(e, b, c, R))
    {
      r = sm_SelectCopy_ExpMultDiv(a, e, b, c, R);
      if (p_LmDivisibleByNoComp(e, a,R))
        sm_CombineChain(&pa, r, R);
      else
        pa = p_Add_q(pa,r,R);
    }
    else
    {
      r = pp_Mult_mm(a, e, R);
      sm_CombineChain(&pa, r, R);
    }
    pIter(b);
  } while (b != NULL);
  p_LmFree(e, R);
  return res;
}

sm_NumberDelete()

static void sm_NumberDelete ( smnumber *  r, const ring  R  )

static

Definition at line 2825 of file sparsmat.cc.

{
  smnumber a = *r, b = a->n;
 
  n_Delete(&a->m,R->cf);
  omFreeBin((ADDRESS)a,  smnrec_bin);
  *r = b;
}

sm_Poly2Smnumber()

static smnumber sm_Poly2Smnumber ( poly  q, const ring  R  )

static

Definition at line 2845 of file sparsmat.cc.

{
  smnumber a, res;
  poly p = q;
 
  if (p == NULL)
    return NULL;
  a = res = (smnumber)omAllocBin(smnrec_bin);
  a->pos = p_GetComp(p,R);
  a->m = pGetCoeff(p);
  pGetCoeff(p)=NULL;
  loop
  {
    pIter(p);
    if (p == NULL)
    {
      p_Delete(&q,R);
      a->n = NULL;
      return res;
    }
    a = a->n = (smnumber)omAllocBin(smnrec_bin);
    a->pos = p_GetComp(p,R);
    a->m = pGetCoeff(p);
    pGetCoeff(p)=NULL;
  }
}

sm_Poly2Smpoly()

static smpoly sm_Poly2Smpoly ( poly  q, const ring  R  )

static

Definition at line 2097 of file sparsmat.cc.

{
  poly pp;
  smpoly res, a;
  long x;
 
  if (q == NULL)
    return NULL;
  a = res = (smpoly)omAllocBin(smprec_bin);
  a->pos = x = p_GetComp(q,R);
  a->m = q;
  a->e = 0;
  loop
  {
    p_SetComp(q,0,R);
    pp = q;
    pIter(q);
    if (q == NULL)
    {
      a->n = NULL;
      return res;
    }
    if (p_GetComp(q,R) != x)
    {
      a = a->n = (smpoly)omAllocBin(smprec_bin);
      pNext(pp) = NULL;
      a->pos = x = p_GetComp(q,R);
      a->m = q;
      a->e = 0;
    }
  }
}

sm_PolyDivN()

static void sm_PolyDivN ( poly  a, const number  x, const ring  R  )

static

Definition at line 1949 of file sparsmat.cc.

{
  number y;
 
  do
  {
    y = n_Div(pGetCoeff(a),x, R->cf);
    n_Normalize(y, R->cf);
    p_SetCoeff(a,y, R);
    pIter(a);
  } while (a != NULL);
}

sm_PolyWeight()

static float sm_PolyWeight ( smpoly  a, const ring  R  )

static

Definition at line 2175 of file sparsmat.cc.

{
  poly p = a->m;
  int i;
  float res = (float)n_Size(pGetCoeff(p),R->cf);
 
  if (pNext(p) == NULL)
  {
    for(i=rVar(R); i>0; i--)
    {
      if (p_GetExp(p,i,R) != 0) return res+1.0;
    }
    return res;
  }
  else
  {
    i = 0;
    res = 0.0;
    do
    {
      i++;
      res += (float)n_Size(pGetCoeff(p),R->cf);
      pIter(p);
    }
    while (p);
    return res+(float)i;
  }
}

sm_RingChange()

ring sm_RingChange	(	const ring	origR,
		long	bound
	)

Definition at line 258 of file sparsmat.cc.

{
//  *origR =currRing;
  ring tmpR=rCopy0(origR,FALSE,FALSE);
  rRingOrder_t *ord=(rRingOrder_t*)omAlloc0(3*sizeof(rRingOrder_t));
  int *block0=(int*)omAlloc0(3*sizeof(int));
  int *block1=(int*)omAlloc0(3*sizeof(int));
  ord[0]=ringorder_c;
  ord[1]=ringorder_dp;
  tmpR->order=ord;
  tmpR->OrdSgn=1;
  block0[1]=1;
  tmpR->block0=block0;
  block1[1]=tmpR->N;
  tmpR->block1=block1;
  tmpR->bitmask = 2*bound;
  tmpR->wvhdl = (int **)omAlloc0((3) * sizeof(int*));
 
// ???
//  if (tmpR->bitmask > currRing->bitmask) tmpR->bitmask = currRing->bitmask;
 
  rComplete(tmpR,1);
  if (origR->qideal!=NULL)
  {
    tmpR->qideal= idrCopyR_NoSort(origR->qideal, origR, tmpR);
  }
  if (TEST_OPT_PROT)
    Print("[%ld:%d]", (long) tmpR->bitmask, tmpR->ExpL_Size);
  return tmpR;
}

sm_SelectCopy_ExpMultDiv()

static poly sm_SelectCopy_ExpMultDiv ( poly  p, poly  m, poly  a, poly  b, const ring  currRing  )

static

Definition at line 98 of file sparsmat.cc.

{
  int lp = 0;
  return pp_Mult_Coeff_mm_DivSelect_MultDiv(p, lp, m, a, b, currRing);
}

sm_Smnumber2Poly()

static poly sm_Smnumber2Poly ( number  a, const ring  R  )

static

Definition at line 2876 of file sparsmat.cc.

{
  poly res;
 
  if (a == NULL) return NULL;
  res = p_Init(R);
  pSetCoeff0(res, a);
  return res;
}

sm_Smpoly2Poly()

static poly sm_Smpoly2Poly ( smpoly  a, const ring  R  )

static

Definition at line 2134 of file sparsmat.cc.

{
  smpoly b;
  poly res, pp, q;
  long x;
 
  if (a == NULL)
    return NULL;
  x = a->pos;
  q = res = a->m;
  loop
  {
    p_SetComp(q,x,R);
    pp = q;
    pIter(q);
    if (q == NULL)
      break;
  }
  loop
  {
    b = a;
    a = a->n;
    omFreeBin((void *)b,  smprec_bin);
    if (a == NULL)
      return res;
    x = a->pos;
    q = pNext(pp) = a->m;
    loop
    {
      p_SetComp(q,x,R);
      pp = q;
      pIter(q);
      if (q == NULL)
        break;
    }
  }
}

sm_SpecialPolyDiv()

void sm_SpecialPolyDiv	(	poly	a,
		poly	b,
		const ring	R
	)

Definition at line 1840 of file sparsmat.cc.

{
  if (pNext(b) == NULL)
  {
    sm_PolyDivN(a, pGetCoeff(b),R);
    return;
  }
  sm_ExactPolyDiv(a, b, R);
}

smCheckSolv()

static BOOLEAN smCheckSolv ( ideal  I )

static

Definition at line 2889 of file sparsmat.cc.

{ int i = I->ncols;
  if ((i == 0) || (i != I->rank-1))
  {
    WerrorS("wrong dimensions for linsolv");
    return TRUE;
  }
  for(;i;i--)
  {
    if(I->m[i-1] == NULL)
    {
      WerrorS("singular input for linsolv");
      return TRUE;
    }
  }
  return FALSE;
}

smElemCopy()

static smpoly smElemCopy ( smpoly  a )

static

Definition at line 2085 of file sparsmat.cc.

{
  smpoly r = (smpoly)omAllocBin(smprec_bin);
  memcpy(r, a, sizeof(smprec));
/*  r->m = pCopy(r->m); */
  return r;
}

smMinSelect()

static void smMinSelect ( long *  c, int  t, int  d  )

static

Definition at line 236 of file sparsmat.cc.

{
  long m;
  int pos, i;
  do
  {
    d--;
    pos = d;
    m = c[pos];
    for (i=d-1;i>=0;i--)
    {
      if(c[i]<m)
      {
        pos = i;
        m = c[i];
      }
    }
    for (i=pos;i<d;i++) c[i] = c[i+1];
  } while (d>t);
}

smNumberCopy()

static smnumber smNumberCopy ( smnumber  a )

static

Definition at line 2834 of file sparsmat.cc.

{
  smnumber r = (smnumber)omAllocBin(smnrec_bin);
  memcpy(r, a, sizeof(smnrec));
  return r;
}

smSmaller()

static BOOLEAN smSmaller ( poly  a, poly  b  )

static

Definition at line 1962 of file sparsmat.cc.

{
  loop
  {
    pIter(b);
    if (b == NULL) return TRUE;
    pIter(a);
    if (a == NULL) return FALSE;
  }
}

Variable Documentation

smnrec_bin

STATIC_VAR omBin smnrec_bin = omGetSpecBin(sizeof(smnrec))

Definition at line 2264 of file sparsmat.cc.

smprec_bin

VAR omBin smprec_bin = omGetSpecBin(sizeof(smprec))

Definition at line 74 of file sparsmat.cc.