transext.h File Reference

#include "coeffs/coeffs.h"
#include "polys/monomials/ring.h"

Go to the source code of this file.

Data Structures
struct	TransExtInfo
	struct for passing initialization parameters to naInitChar More...

Functions
nMapFunc	ntSetMap (const coeffs src, const coeffs dst)
	Get a mapping function from src into the domain of this type (n_transExt) More...
BOOLEAN	ntInitChar (coeffs cf, void *infoStruct)
	Initialize the coeffs object. More...
number	ntDiff (number a, number d, const coeffs cf)
int	ntIsParam (number, const coeffs)
	if m == var(i)/1 => return i, More...
poly	gcd_over_Q (poly f, poly g, const ring r)
	helper routine for calling singclap_gcd_r More...

---

Data Structure Documentation

TransExtInfo

struct TransExtInfo

struct for passing initialization parameters to naInitChar

Definition at line 88 of file transext.h.

Data Fields
ring	r

Function Documentation

gcd_over_Q()

poly gcd_over_Q	(	poly	f,
		poly	g,
		const ring	r
	)

helper routine for calling singclap_gcd_r

Definition at line 275 of file transext.cc.

{
  poly res;
  f=p_Copy(f,r);
  p_Cleardenom(f, r);
  g=p_Copy(g,r);
  p_Cleardenom(g, r);
  res=singclap_gcd_r(f,g,r);
  p_Delete(&f, r);
  p_Delete(&g, r);
  return res;
}

ntDiff()

number ntDiff	(	number	a,
		number	d,
		const coeffs	cf
	)

Definition at line 897 of file transext.cc.

{
  //check_N(a,cf);
  //check_N(d,cf);
  ntTest(a);
  ntTest(d);
 
  if (IS0(d))
  {
    WerrorS("ringvar expected");
    return NULL;
  }
  fraction t = (fraction) d;
  if (!DENIS1(t))
  {
    WerrorS("expected differentiation by a variable");
    return NULL;
  }
  int k=p_Var(NUM(t),ntRing);
  if (k==0)
  {
    WerrorS("expected differentiation by a variable");
    return NULL;
  }
 
  if (IS0(a)) return ntCopy(a, cf);
 
  fraction fa = (fraction)a;
  fraction result = (fraction)omAlloc0Bin(fractionObjectBin);
  if (DENIS1(fa))
  {
     NUM(result) = p_Diff(NUM(fa),k,ntRing);
     //DEN(result) = NULL; // done by ..Alloc0..
     if (NUM(result)==NULL)
     {
       omFreeBin((ADDRESS)result, fractionObjectBin);
       return(NULL);
     }
     COM(result) = COM(fa)+DIFF_COMPLEXITY;
     //check_N((number)result,cf);
     ntTest((number)result);
     return (number)result;
  }
 
  poly fg = p_Mult_q(p_Copy(DEN(fa),ntRing),p_Diff(NUM(fa),k,ntRing),ntRing);
  poly gf = p_Mult_q(p_Copy(NUM(fa),ntRing),p_Diff(DEN(fa),k,ntRing),ntRing);
  NUM(result) = p_Sub(fg,gf,ntRing);
  if (NUM(result)==NULL) return(NULL);
  DEN(result) = pp_Mult_qq(DEN(fa), DEN(fa), ntRing);
  COM(result) = COM(fa) + COM(fa) + DIFF_COMPLEXITY;
  heuristicGcdCancellation((number)result, cf);
 
  //check_N((number)result,cf);
  ntTest((number)result);
  return (number)result;
}

ntInitChar()

BOOLEAN ntInitChar	(	coeffs	cf,
		void *	infoStruct
	)

Initialize the coeffs object.

Definition at line 2544 of file transext.cc.

{
 
  assume( infoStruct != NULL );
 
  TransExtInfo *e = (TransExtInfo *)infoStruct;
 
  assume( e->r                != NULL);      // extRing;
  assume( e->r->cf            != NULL);      // extRing->cf;
  assume( e->r->qideal == NULL );
 
  assume( cf != NULL );
  assume(getCoeffType(cf) == n_transExt);                // coeff type;
 
  ring R = e->r;
  assume(R != NULL);
 
  rIncRefCnt(R); // increase the ref.counter for the ground poly. ring!
 
  cf->extRing           = R;
  /* propagate characteristic up so that it becomes
     directly accessible in cf: */
  cf->ch = R->cf->ch;
 
  cf->is_field=TRUE;
  cf->is_domain=TRUE;
  cf->rep=n_rep_rat_fct;
 
  cf->factoryVarOffset = R->cf->factoryVarOffset + rVar(R);
 
  cf->cfCoeffName =  naCoeffName; // FIXME? TODO? // extern char* naCoeffString(const coeffs r);
 
  cf->cfGreaterZero  = ntGreaterZero;
  cf->cfGreater      = ntGreater;
  cf->cfEqual        = ntEqual;
  cf->cfIsZero       = ntIsZero;
  cf->cfIsOne        = ntIsOne;
  cf->cfIsMOne       = ntIsMOne;
  cf->cfInit         = ntInit;
  cf->cfFarey        = ntFarey;
  cf->cfChineseRemainder = ntChineseRemainder;
  cf->cfInt          = ntInt;
  cf->cfAdd          = ntAdd;
  cf->cfInpNeg       = ntNeg;
  cf->cfSub          = ntSub;
  cf->cfMult         = ntMult;
  cf->cfDiv          = ntDiv;
  cf->cfExactDiv     = ntExactDiv;
  cf->cfPower        = ntPower;
  cf->cfCopy         = ntCopy;
  cf->cfWriteLong    = ntWriteLong;
  cf->cfRead         = ntRead;
  cf->cfNormalize    = ntNormalize;
  cf->cfDelete       = ntDelete;
  cf->cfSetMap       = ntSetMap;
  cf->cfGetDenom     = ntGetDenom;
  cf->cfGetNumerator = ntGetNumerator;
  //cf->cfRePart       = ntCopy;
  //cf->cfImPart       = ntImPart;
  cf->cfCoeffWrite   = ntCoeffWrite;
#ifdef LDEBUG
  cf->cfDBTest       = ntDBTest;
#endif
  //cf->cfGcd          = ntGcd_dummy;
  cf->cfSubringGcd   = ntGcd;
  cf->cfNormalizeHelper = ntNormalizeHelper;
  cf->cfSize         = ntSize;
  cf->nCoeffIsEqual  = ntCoeffIsEqual;
  cf->cfInvers       = ntInvers;
  cf->cfKillChar     = ntKillChar;
  cf->cfInitMPZ      = ntInitMPZ;
  cf->cfMPZ          = ntMPZ;
 
  if( rCanShortOut(ntRing) )
    cf->cfWriteShort = ntWriteShort;
  else
    cf->cfWriteShort = ntWriteLong;
 
  cf->convFactoryNSingN =ntConvFactoryNSingN;
  cf->convSingNFactoryN =ntConvSingNFactoryN;
  cf->cfParDeg = ntParDeg;
 
  cf->iNumberOfParameters = rVar(R);
  cf->pParameterNames = (const char**)R->names;
  cf->cfParameter = ntParameter;
  cf->has_simple_Inverse= FALSE;
  /* cf->has_simple_Alloc= FALSE; */
 
 
  if( nCoeff_is_Q(R->cf) )
    cf->cfClearContent = ntClearContent;
 
  cf->cfClearDenominators = ntClearDenominators;
 
  return FALSE;
}

ntIsParam()

int ntIsParam	(	number	m,
		const	coeffs
	)

if m == var(i)/1 => return i,

Definition at line 2216 of file transext.cc.

{
  ntTest(m);
  assume(getCoeffType(cf) == n_transExt);
 
  const ring R = cf->extRing;
  assume( R != NULL );
 
  fraction f = (fraction)m;
 
  if( DEN(f) != NULL )
    return 0;
 
  return p_Var( NUM(f), R );
}

ntSetMap()

nMapFunc ntSetMap	(	const coeffs	src,
		const coeffs	dst
	)

Get a mapping function from src into the domain of this type (n_transExt)

Q or Z --> Q(T)

Z --> K(T)

Z/p --> Q(T)

Q --> Z/p(T)

Z/p --> Z/p(T)

Z/u --> Z/p(T)

Z/p --> Z/p(T)

K(T') --> K(T)

K(T') --> K'(T)

K(T') --> K(T)

K(T') --> K'(T)

default

Definition at line 2078 of file transext.cc.

{
  /* dst is expected to be a rational function field */
  assume(getCoeffType(dst) == n_transExt);
 
  int h = 0; /* the height of the extension tower given by dst */
  coeffs bDst = nCoeff_bottom(dst, h); /* the bottom field in the tower dst */
  coeffs bSrc = nCoeff_bottom(src, h); /* the bottom field in the tower src */
 
  /* for the time being, we only provide maps if h = 1 and if b is Q or
     some field Z/pZ: */
  if (h==0)
  {
    if (((src->rep==n_rep_gap_rat) || (src->rep==n_rep_gap_gmp))
    && (nCoeff_is_Q(dst->extRing->cf) || nCoeff_is_Z(dst->extRing->cf)))
      return ntMap00;                                 /// Q or Z   -->  Q(T)
    if (src->rep==n_rep_gmp)
      return ntMapZ0;                                 /// Z   -->  K(T)
    if (nCoeff_is_Zp(src) && nCoeff_is_Q(bDst))
      return ntMapP0;                                 /// Z/p     -->  Q(T)
    if (nCoeff_is_Q_or_BI(src) && nCoeff_is_Zp(bDst))
      return ntMap0P;                                 /// Q       --> Z/p(T)
    if (nCoeff_is_Zp(src) && nCoeff_is_Zp(bDst))
    {
      if (src->ch == dst->ch) return ntMapPP;         /// Z/p     --> Z/p(T)
      else return ntMapUP;                            /// Z/u     --> Z/p(T)
    }
    if (nCoeff_is_Zn(src) && nCoeff_is_Zn(bDst))
    {
      if (mpz_cmp(src->modNumber,bDst->modNumber)==0) return ntMapPP;         /// Z/p     --> Z/p(T)
    }
  }
  if (h != 1) return NULL;
  //if ((!nCoeff_is_Zp(bDst)) && (!nCoeff_is_Q(bDst))) return NULL;
 
  /* Let T denote the sequence of transcendental extension variables, i.e.,
     K[t_1, ..., t_s] =: K[T];
     Let moreover, for any such sequence T, T' denote any subsequence of T
     of the form t_1, ..., t_w with w <= s. */
 
  if (rVar(src->extRing) > rVar(dst->extRing))
     return NULL;
 
  for (int i = 0; i < rVar(src->extRing); i++)
    if (strcmp(rRingVar(i, src->extRing), rRingVar(i, dst->extRing)) != 0)
       return NULL;
 
  if (src->type==n_transExt)
  {
     if (src->extRing->cf==dst->extRing->cf)
       return ntCopyMap;          /// K(T')   --> K(T)
     else
       return ntGenMap;          /// K(T')   --> K'(T)
  }
  else
  {
     if (src->extRing->cf==dst->extRing->cf)
       return ntCopyAlg;          /// K(T')   --> K(T)
     else
       return ntGenAlg;          /// K(T')   --> K'(T)
  }
 
  return NULL;                                 /// default
}