gen_maps.h File Reference

Go to the source code of this file.

Functions
ideal	maMapIdeal (const ideal map_id, const ring map_r, const ideal image_id, const ring image_r, const nMapFunc nMap)
	polynomial map for ideals/module/matrix map_id: the ideal to map map_r: the base ring for map_id image_id: the image of the variables image_r: the base ring for image_id nMap: map for coefficients
poly	maMapPoly (const poly map_p, const ring map_r, const ideal image_id, const ring image_r, const nMapFunc nMap)
	polynomial map for poly (vector) map_p: the poly (vector) to map map_r: the base ring for map_p image_id: the image of the variables image_r: the base ring for image_id nMap: map for coefficients
poly	p_SubstPoly (poly p, int var, poly image, const ring preimage_r, const ring image_r, const nMapFunc nMap, matrix cache=NULL)
ideal	id_SubstPoly (ideal id, int var, poly image, const ring preimage_r, const ring image_r, const nMapFunc nMap)
number	maEvalAt (const poly p, const number *pt, const ring r)
	evaluate the polynomial p at the pt given by the array pt

Function Documentation

id_SubstPoly()

ideal id_SubstPoly	(	ideal	id,
		int	var,
		poly	image,
		const ring	preimage_r,
		const ring	image_r,
		const nMapFunc	nMap )

Definition at line 78 of file subst_maps.cc.

{
  matrix cache=mpNew(preimage_r->N,maMaxDeg_Ma(id, preimage_r));
  int k=MATROWS((matrix)id)*MATCOLS((matrix)id);
  ideal res=(ideal)mpNew(MATROWS((matrix)id),MATCOLS((matrix)id));
  res->rank = id->rank;
  for(k--;k>=0;k--)
  {
    res->m[k]=p_SubstPoly(id->m[k],var,image,preimage_r,image_r,nMap,cache);
  }
  id_Delete((ideal*)&cache,image_r);
  return res;
}

maEvalAt()

number maEvalAt	(	const poly	p,
		const number *	pt,
		const ring	r )

evaluate the polynomial p at the pt given by the array pt

Definition at line 174 of file gen_maps.cc.

{
  ideal map=idInit(r->N,1);
  for(int i=r->N-1;i>=0;i--)
  {
    map->m[i]=p_NSet(n_Copy(pt[i],r->cf),r);
  }
  poly v=maMapPoly(p,r,map,r,ndCopyMap);
  id_Delete(&map,r);
  number vv;
  if (v==NULL)
    vv=n_Init(0,r->cf);
  else
  {
    vv=pGetCoeff(v);
    p_LmFree(&v,r);
  }
  return vv;
}

maMapIdeal()

ideal maMapIdeal	(	const ideal	map_id,
		const ring	map_r,
		const ideal	image_id,
		const ring	image_r,
		const nMapFunc	nMap )

polynomial map for ideals/module/matrix map_id: the ideal to map map_r: the base ring for map_id image_id: the image of the variables image_r: the base ring for image_id nMap: map for coefficients

Definition at line 88 of file gen_maps.cc.

{
  // handle special cases
  if (IDELEMS(map_id)<=0)
    return idInit(0,map_id->rank);
  if(!rIsNCRing(image_r))
  {
    // heuristic:
    // is the map a permutation ?
    matrix m=ma_ApplyPermForMap((matrix)map_id,preimage_r,image_id,image_r,nMap);
    if (m!=NULL)
    {
      if (TEST_OPT_PROT) PrintS("map is a permutation\n");
      return (ideal)m;
    }
    // ----------------------------------------------------------
    // is it a substitution of one variable ?
    {
      poly p;
      int var;
      find_subst_for_map(preimage_r,image_r,image_id,var,p);
      if (var!=0)
      {
        if (TEST_OPT_PROT) PrintS("map is a substitution\n");
        return id_SubstPoly(map_id,var,p,preimage_r,image_r,nMap);
      }
    }
    // ----------------------------------------------------------
    // long polys in the image ?: possibility of many common subexpressions
    if ((nMap==ndCopyMap) /* and !rIsPluralRing(image_r) */
    && (map_id->nrows==1) /* i.e. only for ideal/map */
    && (map_id->rank==1))
    {
      int sz=IDELEMS(image_id);
      int sz_l=0;
      int i;
      int sz_source=0;
      for(i=IDELEMS(map_id)-1;i>=0;i--)
      {
        sz_source+=pLength(map_id->m[i]);
      }
      for(i=IDELEMS(image_id)-1;i>=0;i--)
      {
        sz_l+=pLength(image_id->m[i]);
      }
      // few, but complex terms: sz_l/sz large, or few variables,
      // or sz_source small
      //printf("avg term len map:%d,N=%d, avg.image len:%d, im.len:%d\n",sz_l/sz,sz,sz_source/IDELEMS(image_id),sz_source);
      if ((sz_l > sz*5)||(sz<5)||(sz_source<100))
      {
        if (TEST_OPT_PROT) PrintS("map via common subexpressions\n");
        return fast_map_common_subexp(map_id, preimage_r, image_id, image_r);
      }
    }
  }
  // ----------------------------------------------------------
  // otherwise: try the generic method (generic map with cache)
  if (TEST_OPT_PROT) PrintS("map with cache\n");
  int C=((matrix)map_id)->cols();
  int R=((matrix)map_id)->rows();
  matrix m=mpNew(R,C);
  int N = preimage_r->N;
  matrix cache=mpNew(N,maMaxDeg_Ma(map_id,preimage_r));
  int i;
  for (i=R*C-1;i>=0;i--)
  {
    if (map_id->m[i]!=NULL)
    {
      m->m[i]=maEval((map)image_id, map_id->m[i], preimage_r, nMap, (ideal)cache, image_r);
      p_Test(m->m[i],image_r);
    }
  }
  idDelete((ideal *)&cache);
  ideal ii=(ideal)m;
  ii->rank=((ideal)map_id)->rank;
  return (ideal)m;
}

maMapPoly()

poly maMapPoly	(	const poly	map_p,
		const ring	map_r,
		const ideal	image_id,
		const ring	image_r,
		const nMapFunc	nMap )

polynomial map for poly (vector) map_p: the poly (vector) to map map_r: the base ring for map_p image_id: the image of the variables image_r: the base ring for image_id nMap: map for coefficients

Definition at line 166 of file gen_maps.cc.

{
  matrix s=mpNew(map_r->N,maMaxDeg_P(map_p, map_r));
  poly p=maEval((map)image_id, map_p, map_r, nMap, (ideal)s, image_r);
  id_Delete((ideal*)&s,image_r);
  return p;
}

p_SubstPoly()

poly p_SubstPoly	(	poly	p,
		int	var,
		poly	image,
		const ring	preimage_r,
		const ring	image_r,
		const nMapFunc	nMap,
		matrix	cache = NULL )

Definition at line 46 of file subst_maps.cc.

{
  if (p==NULL) return NULL;
 
  if (rIsNCRing(image_r))
  {
    if((image_r!=preimage_r)
    ||(preimage_r!=currRing))
    {
      WerrorS("not implemented");
      return NULL;
    }
    return pSubst(pCopy(p),var,image);
  }
  matrix org_cache=cache;
  if (cache==NULL) cache=mpNew(preimage_r->N,maMaxDeg_P(p, preimage_r));
 
  poly result = NULL;
  sBucket_pt bucket = sBucketCreate(image_r);
  while (p != NULL)
  {
    poly q=p_SubstMon(p,var,image,preimage_r,image_r,nMap,cache);
    pIter(p);
    if (q!=NULL) sBucket_Add_p(bucket,q,pLength(q));
  }
  int l_dummy;
  sBucketDestroyAdd(bucket, &result, &l_dummy);
  /*if no cache was passed,it is a local cache: */
  if (org_cache==NULL) id_Delete((ideal*)&cache,image_r);
  return result;
}