modulop.cc File Reference

#include <misc/auxiliary.h>
#include <omalloc/omalloc.h>
#include <factory/factory.h>
#include <misc/mylimits.h>
#include <misc/sirandom.h>
#include <reporter/reporter.h>
#include <coeffs/coeffs.h>
#include <coeffs/numbers.h>
#include <coeffs/mpr_complex.h>
#include "longrat.h"
#include "modulop.h"
#include <string.h>

Go to the source code of this file.

Macros
#define	npTest(A, r)   npDBTest(A,__FILE__,__LINE__, r)
#define	ULONG64   (unsigned long)

Functions
BOOLEAN	npGreaterZero (number k, const coeffs r)
number	npMult (number a, number b, const coeffs r)
number	npInit (long i, const coeffs r)
long	npInt (number &n, const coeffs r)
number	npAdd (number a, number b, const coeffs r)
number	npSub (number a, number b, const coeffs r)
void	npPower (number a, int i, number *result, const coeffs r)
BOOLEAN	npIsZero (number a, const coeffs r)
BOOLEAN	npIsOne (number a, const coeffs r)
BOOLEAN	npIsMOne (number a, const coeffs r)
number	npDiv (number a, number b, const coeffs r)
number	npNeg (number c, const coeffs r)
number	npInvers (number c, const coeffs r)
BOOLEAN	npGreater (number a, number b, const coeffs r)
BOOLEAN	npEqual (number a, number b, const coeffs r)
void	npWrite (number &a, const coeffs r)
void	npCoeffWrite (const coeffs r, BOOLEAN details)
const char *	npRead (const char *s, number *a, const coeffs r)
BOOLEAN	npDBTest (number a, const char *f, const int l, const coeffs r)
nMapFunc	npSetMap (const coeffs src, const coeffs dst)
number	npMapP (number from, const coeffs src, const coeffs r)
static number	nvMultM (number a, number b, const coeffs r)
number	nvMult (number a, number b, const coeffs r)
number	nvDiv (number a, number b, const coeffs r)
number	nvInvers (number c, const coeffs r)
number	npInversM (number c, const coeffs r)
static const char *	npEati (const char *s, int *i, const coeffs r)
void	npKillChar (coeffs r)
static BOOLEAN	npCoeffsEqual (const coeffs r, n_coeffType n, void *parameter)
CanonicalForm	npConvSingNFactoryN (number n, BOOLEAN setChar, const coeffs r)
number	npConvFactoryNSingN (const CanonicalForm n, const coeffs r)
static char *	npCoeffString (const coeffs r)
static void	npWriteFd (number n, FILE *f, const coeffs r)
static number	npReadFd (s_buff f, const coeffs r)
static number	npRandom (siRandProc p, number, number, const coeffs cf)
BOOLEAN	npInitChar (coeffs r, void *p)
static number	npMapLongR (number from, const coeffs, const coeffs dst_r)
number	npMapGMP (number from, const coeffs, const coeffs dst)
number	npMapZ (number from, const coeffs src, const coeffs dst)
number	npMapMachineInt (number from, const coeffs, const coeffs dst)
number	npMapCanonicalForm (number a, const coeffs, const coeffs dst)
void	nvInpMult (number &a, number b, const coeffs r)
long	nvInvMod (long a, const coeffs R)
number	nvInversM (number c, const coeffs r)

Variables
static const n_coeffType	ID = n_Zp
	Our Type! More...
long	npPminus1M
unsigned short *	npExpTable
unsigned short *	npLogTable

Macro Definition Documentation

#define npTest	(		A,
			r
	)		npDBTest(A,__FILE__,__LINE__, r)

Definition at line 50 of file modulop.cc.

#define ULONG64   (unsigned long)

Function Documentation

number npAdd	(	number	a,
		number	b,
		const coeffs	r
	)

Definition at line 153 of file modulop.cc.

{
  n_Test(a, r);
  n_Test(b, r);

  number c = npAddM(a,b, r);

  n_Test(c, r);

  return c;
}

static BOOLEAN npCoeffsEqual ( const coeffs  r, n_coeffType  n, void *  parameter  )

static

Definition at line 450 of file modulop.cc.

{
  /* test, if r is an instance of nInitCoeffs(n,parameter) */
  return (n==n_Zp) && (r->ch==(int)(long)parameter);
}

static char* npCoeffString ( const coeffs  r )

static

Definition at line 475 of file modulop.cc.

{
  char *s=(char*)omAlloc(11);
  snprintf(s,11,"%d",r->ch);
  return s;
}

void npCoeffWrite	(	const coeffs	r,
		BOOLEAN	details
	)

Definition at line 926 of file modulop.cc.

{
  Print("//   characteristic : %d\n",r->ch);
}

number npConvFactoryNSingN	(	const CanonicalForm	n,
		const coeffs	r
	)

Definition at line 462 of file modulop.cc.

{
  if (n.isImm())
  {
    return npInit(n.intval(),r);
  }
  else
  {
    assume(0);
    return NULL;
  }
}

CanonicalForm npConvSingNFactoryN	(	number	n,
		BOOLEAN	setChar,
		const coeffs	r
	)

Definition at line 455 of file modulop.cc.

{
  if (setChar) setCharacteristic( r->ch );
  CanonicalForm term(npInt( n,r ));
  return term;
}

BOOLEAN npDBTest	(	number	a,
		const char *	f,
		const int	l,
		const coeffs	r
	)

Definition at line 634 of file modulop.cc.

{
  if (((long)a<0) || ((long)a>r->ch))
  {
    Print("wrong mod p number %ld at %s,%d\n",(long)a,f,l);
    return FALSE;
  }
  return TRUE;
}

number npDiv	(	number	a,
		number	b,
		const coeffs	r
	)

Definition at line 265 of file modulop.cc.

{
  n_Test(a, r);
  n_Test(b, r);

//#ifdef NV_OPS
//  if (r->ch>NV_MAX_PRIME)
//    return nvDiv(a,b);
//#endif
  if ((long)a==0)
    return (number)0;
  number d;

#ifndef HAVE_DIV_MOD
  if ((long)b==0)
  {
    WerrorS(nDivBy0);
    return (number)0;
  }

  int s = r->npLogTable[(long)a] - r->npLogTable[(long)b];
  if (s < 0)
    s += r->npPminus1M;
  d = (number)(long)r->npExpTable[s];
#else
  number inv=npInversM(b,r);
  d = npMultM(a,inv,r);
#endif

  n_Test(d, r);
  return d;

}

static const char* npEati ( const char *  s, int *  i, const coeffs  r  )

static

Definition at line 380 of file modulop.cc.

{

  if (((*s) >= '0') && ((*s) <= '9'))
  {
    unsigned long ii=0L;
    do
    {
      ii *= 10;
      ii += *s++ - '0';
      if (ii >= (MAX_INT_VAL / 10)) ii = ii % r->ch;
    }
    while (((*s) >= '0') && ((*s) <= '9'));
    if (ii >= (unsigned long)r->ch) ii = ii % r->ch;
    *i=(int)ii;
  }
  else (*i) = 1;
  return s;
}

BOOLEAN npEqual	(	number	a,
		number	b,
		const coeffs	r
	)

Definition at line 340 of file modulop.cc.

{
  n_Test(a, r);
  n_Test(b, r);

//  return (long)a == (long)b;

  return npEqualM(a,b,r);
}

BOOLEAN npGreater	(	number	a,
		number	b,
		const coeffs	r
	)

Definition at line 331 of file modulop.cc.

{
  n_Test(a, r);
  n_Test(b, r);

  //return (long)a != (long)b;
  return (long)a > (long)b;
}

BOOLEAN npGreaterZero	(	number	k,
		const coeffs	r
	)

Definition at line 99 of file modulop.cc.

{
  n_Test(k, r);

  int h = (int)((long) k);
  return ((int)h !=0) && (h <= (r->ch>>1));
}

number npInit	(	long	i,
		const coeffs	r
	)

Definition at line 130 of file modulop.cc.

{
  long ii=i % (long)r->ch;
  if (ii <  0L)                         ii += (long)r->ch;

  number c = (number)ii;
  n_Test(c, r);
  return c;

}

BOOLEAN npInitChar	(	coeffs	r,
		void *	p
	)

Definition at line 500 of file modulop.cc.

{
  assume( getCoeffType(r) == ID );
  const int c = (int) (long) p;

  assume( c > 0 );

  int i, w;

  r->is_field=TRUE;
  r->is_domain=TRUE;
  r->rep=n_rep_int;

  r->ch = c;
  r->npPminus1M = c /*r->ch*/ - 1;

  //r->cfInitChar=npInitChar;
  r->cfKillChar=npKillChar;
  r->nCoeffIsEqual=npCoeffsEqual;
  r->cfCoeffString=npCoeffString;

  r->cfMult  = npMult;
  r->cfSub   = npSub;
  r->cfAdd   = npAdd;
  r->cfDiv   = npDiv;
  r->cfInit = npInit;
  //r->cfSize  = ndSize;
  r->cfInt  = npInt;
  #ifdef HAVE_RINGS
  //r->cfDivComp = NULL; // only for ring stuff
  //r->cfIsUnit = NULL; // only for ring stuff
  //r->cfGetUnit = NULL; // only for ring stuff
  //r->cfExtGcd = NULL; // only for ring stuff
  // r->cfDivBy = NULL; // only for ring stuff
  #endif
  r->cfInpNeg   = npNeg;
  r->cfInvers= npInvers;
  //r->cfCopy  = ndCopy;
  //r->cfRePart = ndCopy;
  //r->cfImPart = ndReturn0;
  r->cfWriteLong = npWrite;
  r->cfRead = npRead;
  //r->cfNormalize=ndNormalize;
  r->cfGreater = npGreater;
  r->cfEqual = npEqual;
  r->cfIsZero = npIsZero;
  r->cfIsOne = npIsOne;
  r->cfIsMOne = npIsMOne;
  r->cfGreaterZero = npGreaterZero;
  //r->cfPower = npPower;
  //r->cfGetDenom = ndGetDenom;
  //r->cfGetNumerator = ndGetNumerator;
  //r->cfGcd  = ndGcd;
  //r->cfLcm  = ndGcd;
  //r->cfDelete= ndDelete;
  r->cfSetMap = npSetMap;
  //r->cfName = ndName;
  //r->cfInpMult=ndInpMult;
#ifdef NV_OPS
  if (c>NV_MAX_PRIME)
  {
    r->cfMult  = nvMult;
    r->cfDiv   = nvDiv;
    r->cfExactDiv= nvDiv;
    r->cfInvers= nvInvers;
    //r->cfPower= nvPower;
  }
#endif
  r->cfCoeffWrite=npCoeffWrite;
#ifdef LDEBUG
  // debug stuff
  r->cfDBTest=npDBTest;
#endif

  r->convSingNFactoryN=npConvSingNFactoryN;
  r->convFactoryNSingN=npConvFactoryNSingN;

  r->cfRandom=npRandom;

  // io via ssi
  r->cfWriteFd=npWriteFd;
  r->cfReadFd=npReadFd;

  // the variables:
  r->nNULL = (number)0;
  r->type = n_Zp;
  r->ch = c;
  r->has_simple_Alloc=TRUE;
  r->has_simple_Inverse=TRUE;

  // the tables
#ifdef NV_OPS
  if (r->ch <=NV_MAX_PRIME)
#endif
  {
#if !defined(HAVE_DIV_MOD) || !defined(HAVE_MULT_MOD)
    r->npExpTable=(unsigned short *)omAlloc( r->ch*sizeof(unsigned short) );
    r->npLogTable=(unsigned short *)omAlloc( r->ch*sizeof(unsigned short) );
    r->npExpTable[0] = 1;
    r->npLogTable[0] = 0;
    if (r->ch > 2)
    {
      w = 1;
      loop
      {
        r->npLogTable[1] = 0;
        w++;
        i = 0;
        loop
        {
          i++;
          r->npExpTable[i] =(int)(((long)w * (long)r->npExpTable[i-1]) % r->ch);
          r->npLogTable[r->npExpTable[i]] = i;
          if /*(i == r->ch - 1 ) ||*/ (/*(*/ r->npExpTable[i] == 1 /*)*/)
            break;
        }
        if (i == r->ch - 1)
          break;
      }
    }
    else
    {
      r->npExpTable[1] = 1;
      r->npLogTable[1] = 0;
    }
#endif
#ifdef HAVE_DIV_MOD
    r->npInvTable=(unsigned short*)omAlloc0( r->ch*sizeof(unsigned short) );
#endif
  }
  return FALSE;
}

long npInt	(	number &	n,
		const coeffs	r
	)

Definition at line 145 of file modulop.cc.

{
  n_Test(n, r);

  if ((long)n > (((long)r->ch) >>1)) return ((long)n -((long)r->ch));
  else                               return ((long)n);
}

number npInvers	(	number	c,
		const coeffs	r
	)

Definition at line 298 of file modulop.cc.

{
  n_Test(c, r);

  if ((long)c==0)
  {
    WerrorS("1/0");
    return (number)0;
  }
  number d = npInversM(c,r);

  n_Test(d, r);
  return d;

}

number npInversM ( number  c, const coeffs  r  )

inline

Definition at line 246 of file modulop.cc.

{
  n_Test(c, r);
#ifndef HAVE_DIV_MOD
  number d = (number)(long)r->npExpTable[r->npPminus1M - r->npLogTable[(long)c]];
#else
  long inv=(long)r->npInvTable[(long)c];
  if (inv==0)
  {
    inv=InvMod((long)c,r);
    r->npInvTable[(long)c]=inv;
  }
  number d = (number)inv;
#endif
  n_Test(d, r);
  return d;

}

BOOLEAN npIsMOne	(	number	a,
		const coeffs	r
	)

Definition at line 191 of file modulop.cc.

{
  n_Test(a, r);

  return ((r->npPminus1M == (long)a)&&((long)1!=(long)a));
}

BOOLEAN npIsOne	(	number	a,
		const coeffs	r
	)

Definition at line 184 of file modulop.cc.

{
  n_Test(a, r);

  return 1 == (long)a;
}

BOOLEAN npIsZero	(	number	a,
		const coeffs	r
	)

Definition at line 177 of file modulop.cc.

{
  n_Test(a, r);

  return 0 == (long)a;
}

void npKillChar

(

coeffs

r

)

Definition at line 434 of file modulop.cc.

{
  #ifdef HAVE_DIV_MOD
  if (r->npInvTable!=NULL)
  omFreeSize( (void *)r->npInvTable, r->ch*sizeof(unsigned short) );
  r->npInvTable=NULL;
  #else
  if (r->npExpTable!=NULL)
  {
    omFreeSize( (void *)r->npExpTable, r->ch*sizeof(unsigned short) );
    omFreeSize( (void *)r->npLogTable, r->ch*sizeof(unsigned short) );
    r->npExpTable=NULL; r->npLogTable=NULL;
  }
  #endif
}

number npMapCanonicalForm	(	number	a,
		const coeffs	,
		const coeffs	dst
	)

Definition at line 766 of file modulop.cc.

{
  setCharacteristic (dst ->ch);
  CanonicalForm f= CanonicalForm ((InternalCF*)(a));
  return (number) (f.intval());
}

number npMapGMP	(	number	from,
		const coeffs	,
		const coeffs	dst
	)

Definition at line 733 of file modulop.cc.

{
  mpz_ptr erg = (mpz_ptr) omAlloc(sizeof(mpz_t)); // evtl. spaeter mit bin
  mpz_init(erg);

  mpz_mod_ui(erg, (mpz_ptr) from, dst->ch);
  number r = (number) mpz_get_si(erg);

  mpz_clear(erg);
  omFree((void *) erg);
  return (number) r;
}

static number npMapLongR ( number  from, const coeffs  , const coeffs  dst_r  )

static

Definition at line 657 of file modulop.cc.

{
  gmp_float *ff=(gmp_float*)from;
  mpf_t *f=ff->_mpfp();
  number res;
  mpz_ptr dest,ndest;
  int size,i;
  int e,al,bl;
  long iz;
  mp_ptr qp,dd,nn;

  size = (*f)[0]._mp_size;
  if (size == 0)
    return npInit(0,dst_r);
  if(size<0)
    size = -size;

  qp = (*f)[0]._mp_d;
  while(qp[0]==0)
  {
    qp++;
    size--;
  }

  if(dst_r->ch>2)
    e=(*f)[0]._mp_exp-size;
  else
    e=0;
  res = ALLOC_RNUMBER();
#if defined(LDEBUG)
  res->debug=123456;
#endif
  dest = res->z;

  long in=0;
  if (e<0)
  {
    al = dest->_mp_size = size;
    if (al<2) al = 2;
    dd = (mp_ptr)omAlloc(sizeof(mp_limb_t)*al);
    for (i=0;i<size;i++) dd[i] = qp[i];
    bl = 1-e;
    nn = (mp_ptr)omAlloc(sizeof(mp_limb_t)*bl);
    nn[bl-1] = 1;
    for (i=bl-2;i>=0;i--) nn[i] = 0;
    ndest = res->n;
    ndest->_mp_d = nn;
    ndest->_mp_alloc = ndest->_mp_size = bl;
    res->s = 0;
    in=mpz_fdiv_ui(ndest,dst_r->ch);
    mpz_clear(ndest);
  }
  else
  {
    al = dest->_mp_size = size+e;
    if (al<2) al = 2;
    dd = (mp_ptr)omAlloc(sizeof(mp_limb_t)*al);
    for (i=0;i<size;i++) dd[i+e] = qp[i];
    for (i=0;i<e;i++) dd[i] = 0;
    res->s = 3;
  }

  dest->_mp_d = dd;
  dest->_mp_alloc = al;
  iz=mpz_fdiv_ui(dest,dst_r->ch);
  mpz_clear(dest);
  if(res->s==0)
    iz=(long)npDiv((number)iz,(number)in,dst_r);
  FREE_RNUMBER(res); // Q!?
  return (number)iz;
}

number npMapMachineInt	(	number	from,
		const coeffs	,
		const coeffs	dst
	)

Definition at line 759 of file modulop.cc.

{
  long i = (long) (((unsigned long) from) % dst->ch);
  return (number) i;
}

number npMapP	(	number	from,
		const coeffs	src,
		const coeffs	r
	)

Definition at line 645 of file modulop.cc.

{
  long i = (long)from;
  if (i>src->ch/2)
  {
    i-=src->ch;
    while (i < 0) i+=dst_r->ch;
  }
  i%=dst_r->ch;
  return (number)i;
}

number npMapZ	(	number	from,
		const coeffs	src,
		const coeffs	dst
	)

Definition at line 746 of file modulop.cc.

{
  if (SR_HDL(from) & SR_INT)
  {
    long f_i=SR_TO_INT(from);
    return npInit(f_i,dst);
  }
  return npMapGMP(from,src,dst);
}

number npMult	(	number	a,
		number	b,
		const coeffs	r
	)

Definition at line 115 of file modulop.cc.

{
  n_Test(a, r);
  n_Test(b, r);

  if (((long)a == 0) || ((long)b == 0))
    return (number)0;
  number c = npMultM(a,b, r);
  n_Test(c, r);
  return c;
}

number npNeg	(	number	c,
		const coeffs	r
	)

Definition at line 314 of file modulop.cc.

{
  n_Test(c, r);

  if ((long)c==0) return c;

#if 0
  number d = npNegM(c,r);
  n_Test(d, r);
  return d;
#else
  c = npNegM(c,r);
  n_Test(c, r);
  return c;
#endif
}

void npPower	(	number	a,
		int	i,
		number *	result,
		const coeffs	r
	)

static number npRandom ( siRandProc  p, number  , number  , const coeffs  cf  )

static

Definition at line 495 of file modulop.cc.

{
  return npInit(p(),cf);
}

const char * npRead	(	const char *	s,
		number *	a,
		const coeffs	r
	)

Definition at line 400 of file modulop.cc.

{
  int z;
  int n=1;

  s = npEati(s, &z, r);
  if ((*s) == '/')
  {
    s++;
    s = npEati(s, &n, r);
  }
  if (n == 1)
    *a = (number)(long)z;
  else
  {
    if ((z==0)&&(n==0)) WerrorS(nDivBy0);
    else
    {
#ifdef NV_OPS
      if (r->ch>NV_MAX_PRIME)
        *a = nvDiv((number)(long)z,(number)(long)n,r);
      else
#endif
        *a = npDiv((number)(long)z,(number)(long)n,r);
    }
  }
  n_Test(*a, r);
  return s;
}

static number npReadFd ( s_buff  f, const coeffs  r  )

static

Definition at line 487 of file modulop.cc.

{
  // read int
  int dd;
  dd=s_readint(f);
  return (number)(long)dd;
}

nMapFunc npSetMap	(	const coeffs	src,
		const coeffs	dst
	)

Definition at line 773 of file modulop.cc.

{
#ifdef HAVE_RINGS
  if ((src->rep==n_rep_int) && nCoeff_is_Ring_2toM(src))
  {
    return npMapMachineInt;
  }
  if (src->rep==n_rep_gmp) //nCoeff_is_Ring_Z(src) || nCoeff_is_Ring_PtoM(src) || nCoeff_is_Ring_ModN(src))
  {
    return npMapGMP;
  }
  if (src->rep==n_rep_gap_gmp) //nCoeff_is_Ring_Z(src)
  {
    return npMapZ;
  }
#endif
  if (src->rep==n_rep_gap_rat)  /* Q, Z */
  {
    return nlModP; // npMap0; // FIXME? TODO? // extern number nlModP(number q, const coeffs Q, const coeffs Zp); // Map q \in QQ \to Zp // FIXME!
  }
  if ((src->rep==n_rep_int) &&  nCoeff_is_Zp(src) )
  {
    if (n_GetChar(src) == n_GetChar(dst))
    {
      return ndCopyMap;
    }
    else
    {
      return npMapP;
    }
  }
  if ((src->rep==n_rep_gmp_float) && nCoeff_is_long_R(src))
  {
    return npMapLongR;
  }
  if (nCoeff_is_CF (src))
  {
    return npMapCanonicalForm;
  }
  return NULL;      /* default */
}

number npSub	(	number	a,
		number	b,
		const coeffs	r
	)

Definition at line 165 of file modulop.cc.

{
  n_Test(a, r);
  n_Test(b, r);

  number c = npSubM(a,b,r);

  n_Test(c, r);

  return c;
}

void npWrite	(	number &	a,
		const coeffs	r
	)

Definition at line 350 of file modulop.cc.

{
  n_Test(a, r);

  if ((long)a>(((long)r->ch) >>1)) StringAppend("-%d",(int)(((long)r->ch)-((long)a)));
  else                             StringAppend("%d",(int)((long)a));
}

static void npWriteFd ( number  n, FILE *  f, const coeffs  r  )

static

Definition at line 482 of file modulop.cc.

{
  fprintf(f,"%d ",(int)(long)n);
}

number nvDiv	(	number	a,
		number	b,
		const coeffs	r
	)

Definition at line 881 of file modulop.cc.

{
  if ((long)a==0)
    return (number)0;
  else if ((long)b==0)
  {
    WerrorS(nDivBy0);
    return (number)0;
  }
  else
  {
    number inv=nvInversM(b,r);
    return nvMultM(a,inv,r);
  }
}

void nvInpMult	(	number &	a,
		number	b,
		const coeffs	r
	)

Definition at line 828 of file modulop.cc.

{
  number n=nvMultM(a,b,r);
  a=n;
}

number nvInvers	(	number	c,
		const coeffs	r
	)

Definition at line 896 of file modulop.cc.

{
  if ((long)c==0)
  {
    WerrorS(nDivBy0);
    return (number)0;
  }
  return nvInversM(c,r);
}

number nvInversM ( number  c, const coeffs  r  )

inline

Definition at line 875 of file modulop.cc.

{
  long inv=nvInvMod((long)c,r);
  return (number)inv;
}

long nvInvMod ( long  a, const coeffs  R  )

inline

TODO: use "long InvMod(long a, const coeffs R)"?!

Definition at line 835 of file modulop.cc.

{
#ifdef HAVE_DIV_MOD
  return InvMod(a, R);
#else
/// TODO: use "long InvMod(long a, const coeffs R)"?!

   long  s;

   long  u, u0, u1, u2, q, r; // v0, v1, v2,

   u1=1; // v1=0;
   u2=0; // v2=1;
   u = a;

   long v = R->ch;

   while (v != 0)
   {
      q = u / v;
      r = u % v;
      u = v;
      v = r;
      u0 = u2;
//      v0 = v2;
      u2 = u1 - q*u2;
//      v2 = v1 - q*v2;
      u1 = u0;
//      v1 = v0;
   }

   s = u1;
   //t = v1;
   if (s < 0)
      return s + R->ch;
   else
     return s;
#endif
}

number nvMult	(	number	a,
		number	b,
		const coeffs	r
	)

Definition at line 820 of file modulop.cc.

{
  //if (((long)a == 0) || ((long)b == 0))
  //  return (number)0;
  //else
    return nvMultM(a,b,r);
}

static number nvMultM ( number  a, number  b, const coeffs  r  )

inlinestatic

Definition at line 78 of file modulop.cc.

{
  assume( getCoeffType(r) == ID );

#if SIZEOF_LONG == 4
#define ULONG64 (unsigned long long)(unsigned long)
#else
#define ULONG64 (unsigned long)
#endif
  return (number)
      (unsigned long)((ULONG64 a)*(ULONG64 b) % (ULONG64 r->ch));
}

Variable Documentation

const n_coeffType ID = n_Zp

static

Our Type!

Definition at line 28 of file modulop.cc.

unsigned short* npExpTable

unsigned short* npLogTable

long npPminus1M