My Project
Macros | Functions | Variables
ffields.cc File Reference
#include "misc/auxiliary.h"
#include "misc/mylimits.h"
#include "misc/sirandom.h"
#include "misc/prime.h"
#include "reporter/reporter.h"
#include "coeffs/coeffs.h"
#include "coeffs/numbers.h"
#include "coeffs/longrat.h"
#include "coeffs/ffields.h"
#include "coeffs/modulop.h"
#include <cmath>
#include <errno.h>

Go to the source code of this file.

Macros

#define nfTest(N, R)   nfDBTest(N,__FILE__,__LINE__, R)
 
#define sixteenlog2   11.09035489
 

Functions

BOOLEAN nfDBTest (number a, const char *f, const int l, const coeffs r)
 
static BOOLEAN nfIsZero (number a, const coeffs r)
 
static BOOLEAN nfIsMOne (number a, const coeffs r)
 
static BOOLEAN nfGreaterZero (number k, const coeffs r)
 
static number nfMult (number a, number b, const coeffs r)
 
static number nfInit (long i, const coeffs r)
 
static number nfParameter (int i, const coeffs)
 
static int nfParDeg (number n, const coeffs r)
 
static long nfInt (number &n, const coeffs r)
 
static number nfAdd (number a, number b, const coeffs R)
 
static number nfNeg (number c, const coeffs r)
 
static number nfSub (number a, number b, const coeffs r)
 
static BOOLEAN nfIsOne (number a, const coeffs r)
 
static number nfDiv (number a, number b, const coeffs r)
 
static number nfInvers (number c, const coeffs r)
 
static BOOLEAN nfGreater (number a, number b, const coeffs r)
 
static BOOLEAN nfEqual (number a, number b, const coeffs r)
 
static void nfWriteLong (number a, const coeffs r)
 
static void nfWriteShort (number a, const coeffs r)
 
static void nfPower (number a, int i, number *result, const coeffs r)
 
static const char * nfEati (const char *s, int *i, const coeffs r)
 
static const char * nfRead (const char *s, number *a, const coeffs r)
 
int gf_tab_numdigits62 (int q)
 
int convertback62 (char *p, int n)
 
void nfShowMipo (const coeffs r)
 Show the mininimal polynom.... NOTE: this is used by char * sleftv::String(void *d, BOOLEAN typed, int dim) (from Singular/subexpr.cc) for printing minpoly. More...
 
static void nfReadMipo (char *s)
 
static void nfReadTable (const int c, const coeffs r)
 
static number nfMapP (number c, const coeffs, const coeffs dst)
 
static number nfMapGG (number c, const coeffs src, const coeffs)
 
static number nfMapGGrev (number c, const coeffs src, const coeffs)
 
static number nfMapMPZ (number c, const coeffs, const coeffs dst)
 
static number nfInitMPZ (mpz_t m, const coeffs cf)
 
static number nfMapViaInt (number c, const coeffs src, const coeffs dst)
 
static nMapFunc nfSetMap (const coeffs src, const coeffs dst)
 
static BOOLEAN nfCoeffIsEqual (const coeffs, n_coeffType, void *)
 
static void nfKillChar (coeffs r)
 
static char * nfCoeffName (const coeffs r)
 
static number nfRandom (siRandProc p, number, number, const coeffs cf)
 
static void nfCoeffWrite (const coeffs r, BOOLEAN details)
 
BOOLEAN nfInitChar (coeffs r, void *parameter)
 

Variables

const unsigned short fftable []
 
STATIC_VAR int nfMinPoly [16]
 
STATIC_VAR int nfMapGG_factor
 

Macro Definition Documentation

◆ nfTest

#define nfTest (   N,
  R 
)    nfDBTest(N,__FILE__,__LINE__, R)

Definition at line 131 of file ffields.cc.

◆ sixteenlog2

#define sixteenlog2   11.09035489

Function Documentation

◆ convertback62()

int convertback62 ( char *  p,
int  n 
)

Definition at line 50 of file gf_tabutil.cc.

51 {
52  int r = 0;
53  for ( int j = 0; j < n; j++ )
54  r = r * 62 + convback62( p[j] );
55  return r;
56 }
int p
Definition: cfModGcd.cc:4080
int j
Definition: facHensel.cc:110
int convback62(char c)
Definition: gf_tabutil.cc:40

◆ gf_tab_numdigits62()

int gf_tab_numdigits62 ( int  q)

Definition at line 12 of file gf_tabutil.cc.

13 {
14  if ( q < 62 )
15  return 1;
16  else if ( q < 62*62 )
17  return 2;
18  else
19  return 3;
20 }

◆ nfAdd()

static number nfAdd ( number  a,
number  b,
const coeffs  R 
)
static

Definition at line 258 of file ffields.cc.

259 {
260 /*4 z^a+z^b=z^b*(z^(a-b)+1), if a>=b; *
261 * =z^a*(z^(b-a)+1) if a<b */
262 #ifdef LDEBUG
263  nfTest(a, R);
264  nfTest(b, R);
265 #endif
266  if ((long)R->m_nfCharQ == (long)a) return b;
267  if ((long)R->m_nfCharQ == (long)b) return a;
268  long zb,zab,r;
269  if ((long)a >= (long)b)
270  {
271  zb = (long)b;
272  zab = (long)a-(long)b;
273  }
274  else
275  {
276  zb = (long)a;
277  zab = (long)b-(long)a;
278  }
279 #ifdef LDEBUG
280  nfTest((number)zab, R);
281 #endif
282  if (R->m_nfPlus1Table[zab]==R->m_nfCharQ) r=(long)R->m_nfCharQ; /*if z^(a-b)+1 =0*/
283  else
284  {
285  r= zb+(long)R->m_nfPlus1Table[zab];
286  if(r>=(long)R->m_nfCharQ1) r-=(long)R->m_nfCharQ1;
287  }
288 #ifdef LDEBUG
289  nfTest((number)r, R);
290 #endif
291  return (number)r;
292 }
CanonicalForm b
Definition: cfModGcd.cc:4105
#define nfTest(N, R)
Definition: ffields.cc:131
#define R
Definition: sirandom.c:27

◆ nfCoeffIsEqual()

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

Definition at line 848 of file ffields.cc.

849 {
850  if (n==n_GF) {
851  GFInfo* p = (GFInfo *)(parameter);
852  int c = (int)pow ((double)p->GFChar, (double)p->GFDegree);
853  if ((c == r->m_nfCharQ) && (strcmp(n_ParameterNames(r)[0], p->GFPar_name) == 0))
854  return TRUE;
855  }
856  return FALSE;
857 }
Rational pow(const Rational &a, int e)
Definition: GMPrat.cc:411
#define TRUE
Definition: auxiliary.h:100
#define FALSE
Definition: auxiliary.h:96
@ n_GF
\GF{p^n < 2^16}
Definition: coeffs.h:33
static FORCE_INLINE char const ** n_ParameterNames(const coeffs r)
Returns a (const!) pointer to (const char*) names of parameters.
Definition: coeffs.h:802
Creation data needed for finite fields.
Definition: coeffs.h:94

◆ nfCoeffName()

static char* nfCoeffName ( const coeffs  r)
static

Definition at line 820 of file ffields.cc.

821 {
822  STATIC_VAR char nfCoeffName_buf[32];
823  const char *p=n_ParameterNames(r)[0];
824  nfCoeffName_buf[31]='\0';
825  snprintf(nfCoeffName_buf,31,"%d,%s",r->m_nfCharQ,p);
826  return nfCoeffName_buf;
827 }
#define STATIC_VAR
Definition: globaldefs.h:7

◆ nfCoeffWrite()

static void nfCoeffWrite ( const coeffs  r,
BOOLEAN  details 
)
static

Definition at line 834 of file ffields.cc.

835 {
836  // m_nfCharQ = p^k where p is the characteristic (r->CharP) and k is GFDegree
837  Print("ZZ/%d[%s]",r->m_nfCharQ,n_ParameterNames(r)[0]);
838  if ( details )
839  {
840  StringSetS("\n// minpoly : ");
841  nfShowMipo(r);
842  StringAppendS("");
843  char *s=StringEndS(); PrintS(s); omFree(s);
844  }
845  else PrintS("// minpoly : ...");
846 }
#define Print
Definition: emacs.cc:80
const CanonicalForm int s
Definition: facAbsFact.cc:51
void nfShowMipo(const coeffs r)
Show the mininimal polynom.... NOTE: this is used by char * sleftv::String(void *d,...
Definition: ffields.cc:551
#define omFree(addr)
Definition: omAllocDecl.h:261
void StringSetS(const char *st)
Definition: reporter.cc:128
void StringAppendS(const char *st)
Definition: reporter.cc:107
void PrintS(const char *s)
Definition: reporter.cc:284
char * StringEndS()
Definition: reporter.cc:151

◆ nfDBTest()

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

Definition at line 111 of file ffields.cc.

112 {
113  assume( r->m_nfPlus1Table != NULL );
114  if (((long)a<0L) || ((long)a>(long)r->m_nfCharQ))
115  {
116  Print("wrong %d in %s:%d\n",(int)((long)a),f,l);
117  return FALSE;
118  }
119  int i=0;
120  do
121  {
122  if (r->m_nfPlus1Table[i]>r->m_nfCharQ)
123  {
124  Print("wrong table %d=%d in %s:%d\n",i,r->m_nfPlus1Table[i],f,l);
125  return FALSE;
126  }
127  i++;
128  } while (i<r->m_nfCharQ);
129  return TRUE;
130 }
int l
Definition: cfEzgcd.cc:100
int i
Definition: cfEzgcd.cc:132
FILE * f
Definition: checklibs.c:9
#define assume(x)
Definition: mod2.h:387
#define NULL
Definition: omList.c:12

◆ nfDiv()

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

Definition at line 335 of file ffields.cc.

336 {
337 #ifdef LDEBUG
338  nfTest(b, r);
339 #endif
340  if ((long)b==(long)r->m_nfCharQ)
341  {
342  WerrorS(nDivBy0);
343  return (number)((long)r->m_nfCharQ);
344  }
345 #ifdef LDEBUG
346  nfTest(a, r);
347 #endif
348  if ((long)a==(long)r->m_nfCharQ)
349  return (number)((long)r->m_nfCharQ);
350  /*else*/
351  long s = (long)a - (long)b;
352  if (s < 0L)
353  s += (long)r->m_nfCharQ1;
354 #ifdef LDEBUG
355  nfTest((number)s, r);
356 #endif
357  return (number)s;
358 }
void WerrorS(const char *s)
Definition: feFopen.cc:24
#define LDEBUG
Definition: mod2.h:305
const char *const nDivBy0
Definition: numbers.h:87

◆ nfEati()

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

Definition at line 501 of file ffields.cc.

502 {
503  return nEati((char *)s,i,r->m_nfCharP);
504 }
char * nEati(char *s, int *i, int m)
divide by the first (leading) number and return it, i.e. make monic
Definition: numbers.cc:633

◆ nfEqual()

static BOOLEAN nfEqual ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 394 of file ffields.cc.

395 {
396 #ifdef LDEBUG
397  nfTest(a, r);
398  nfTest(b, r);
399 #endif
400  return (long)a == (long)b;
401 }

◆ nfGreater()

static BOOLEAN nfGreater ( number  a,
number  b,
const coeffs  r 
)
static

Definition at line 382 of file ffields.cc.

383 {
384 #ifdef LDEBUG
385  nfTest(a, r);
386  nfTest(b, r);
387 #endif
388  return (long)a != (long)b;
389 }

◆ nfGreaterZero()

static BOOLEAN nfGreaterZero ( number  k,
const coeffs  r 
)
static

Definition at line 160 of file ffields.cc.

161 {
162 #ifdef LDEBUG
163  nfTest(k, r);
164 #endif
165  return !nfIsZero(k, r) && !nfIsMOne(k, r);
166 }
int k
Definition: cfEzgcd.cc:99
static BOOLEAN nfIsMOne(number a, const coeffs r)
Definition: ffields.cc:148
static BOOLEAN nfIsZero(number a, const coeffs r)
Definition: ffields.cc:137

◆ nfInit()

static number nfInit ( long  i,
const coeffs  r 
)
static

Definition at line 191 of file ffields.cc.

192 {
193  assume( r->m_nfPlus1Table != NULL );
194  // Hmm .. this is just to prevent initialization
195  // from nfInitChar to go into an infinite loop
196  if (i==0) return (number)(long)r->m_nfCharQ;
197  while (i < 0) i += r->m_nfCharP;
198  while (i >= r->m_nfCharP) i -= r->m_nfCharP;
199  if (i==0) return (number)(long)r->m_nfCharQ;
200  unsigned short c=0;
201  while (i>1)
202  {
203  c=r->m_nfPlus1Table[c];
204  i--;
205  }
206 #ifdef LDEBUG
207  nfTest((number)(long)c, r);
208 #endif
209  return (number)(long)c;
210 }
while(1)
Definition: libparse.cc:1444

◆ nfInitChar()

BOOLEAN nfInitChar ( coeffs  r,
void *  parameter 
)

Definition at line 858 of file ffields.cc.

859 {
860  // the variables:
861  assume( getCoeffType(r) == n_GF );
862 
863  GFInfo* p = (GFInfo *)(parameter);
864  assume (p->GFChar > 0);
865  assume (p->GFDegree > 0);
866  if ((IsPrime(p->GFChar)==p->GFChar)&&(p->GFDegree==1)) /* for oscar-system/Singular.jl/issues/177 */
867  {
868  return npInitChar(r,(void*)(long)p->GFChar);
869  }
870  if(p->GFChar > (2<<15))
871  {
872 #ifndef SING_NDEBUG
873  WarnS("illegal characteristic");
874 #endif
875  return TRUE;
876  }
877 
878  const double check= log ((double) (p->GFChar));
879 
880  #define sixteenlog2 11.09035489
881  if( (p->GFDegree * check) > sixteenlog2 )
882  {
883 #ifndef SING_NDEBUG
884  Warn("Sorry: illegal size: %u ^ %u", p->GFChar, p->GFDegree );
885 #endif
886  return TRUE;
887  }
888 
889  r->is_field=TRUE;
890  r->is_domain=TRUE;
891  r->rep=n_rep_gf;
892  //r->cfInitChar=npInitChar;
893  r->cfKillChar=nfKillChar;
894  r->nCoeffIsEqual=nfCoeffIsEqual;
895  r->cfCoeffName=nfCoeffName;
896 
897  r->cfMult = nfMult;
898  r->cfSub = nfSub;
899  r->cfAdd = nfAdd;
900  r->cfDiv = nfDiv;
901  //r->cfIntMod= ndIntMod;
902  r->cfExactDiv= nfDiv;
903  r->cfInit = nfInit;
904  r->cfInitMPZ = nfInitMPZ;
905  //r->cfSize = ndSize;
906  r->cfInt = nfInt;
907  #ifdef HAVE_RINGS
908  //r->cfDivComp = NULL; // only for ring stuff
909  //r->cfIsUnit = NULL; // only for ring stuff
910  //r->cfGetUnit = NULL; // only for ring stuff
911  //r->cfExtGcd = NULL; // only for ring stuff
912  // r->cfDivBy = NULL; // only for ring stuff
913  #endif
914  r->cfInpNeg = nfNeg;
915  r->cfInvers= nfInvers;
916  //r->cfCopy = ndCopy;
917  //r->cfRePart = ndCopy;
918  //r->cfImPart = ndReturn0;
919 
920  r->cfWriteLong = nfWriteLong;
921  r->cfRead = nfRead;
922  //r->cfNormalize=ndNormalize;
923  r->cfGreater = nfGreater;
924  r->cfEqual = nfEqual;
925  r->cfIsZero = nfIsZero;
926  r->cfIsOne = nfIsOne;
927  r->cfIsMOne = nfIsMOne;
928  r->cfGreaterZero = nfGreaterZero;
929  r->cfPower = nfPower;
930  //r->cfGcd = ndGcd;
931  //r->cfLcm = ndGcd;
932  //r->cfDelete= ndDelete;
933  r->cfSetMap = nfSetMap;
934  //r->cfName = ndName;
935  // debug stuff
936  r->cfCoeffWrite=nfCoeffWrite;
937 
938  r->cfParDeg = nfParDeg;
939 
940  r->cfRandom = nfRandom;
941 
942 #ifdef LDEBUG
943  r->cfDBTest=nfDBTest;
944 #endif
945 
946 
947  const char * name = p->GFPar_name;
948 
949  r->m_nfCharQ = 0;
950  r->m_nfCharP = p->GFChar;
951  r->m_nfCharQ1 = 0;
952 
953  r->iNumberOfParameters = 1;
954  r->cfParameter = nfParameter;
955 
956  char ** pParameterNames = (char **) omAlloc(sizeof(char *));
957  assume( pParameterNames != NULL );
958  pParameterNames[0] = omStrDup(name);
959  assume( pParameterNames[0] != NULL );
960 
961  r->pParameterNames = (const char**)pParameterNames;
962 
963  r->m_nfPlus1Table= NULL;
964 
965  if (strlen(name) > 1)
966  r->cfWriteShort = nfWriteLong;
967  else
968  r->cfWriteShort = nfWriteShort;
969 
970  r->has_simple_Alloc=TRUE;
971  r->has_simple_Inverse=TRUE;
972 
973  int c = (int)pow ((double)p->GFChar, (double)p->GFDegree);
974 
975  nfReadTable(c, r);
976 
977  if( r->m_nfPlus1Table == NULL )
978  {
979  Werror("reading table for field with %d elements failed",c);
980  return TRUE;
981  }
982 
983 
984  assume (r -> m_nfCharQ > 0);
985 
986  r->ch = r->m_nfCharP;
987  assume( r->m_nfPlus1Table != NULL );
988 
989  return FALSE;
990 }
static FORCE_INLINE n_coeffType getCoeffType(const coeffs r)
Returns the type of coeffs domain.
Definition: coeffs.h:422
@ n_rep_gf
(int), see ffields.h
Definition: coeffs.h:120
#define Warn
Definition: emacs.cc:77
#define WarnS
Definition: emacs.cc:78
char name(const Variable &v)
Definition: factory.h:196
static number nfInitMPZ(mpz_t m, const coeffs cf)
Definition: ffields.cc:732
static number nfAdd(number a, number b, const coeffs R)
Definition: ffields.cc:258
static nMapFunc nfSetMap(const coeffs src, const coeffs dst)
Definition: ffields.cc:753
static number nfInit(long i, const coeffs r)
Definition: ffields.cc:191
BOOLEAN nfDBTest(number a, const char *f, const int l, const coeffs r)
Definition: ffields.cc:111
static void nfKillChar(coeffs r)
Definition: ffields.cc:812
static int nfParDeg(number n, const coeffs r)
Definition: ffields.cc:228
static long nfInt(number &n, const coeffs r)
Definition: ffields.cc:240
#define sixteenlog2
static number nfMult(number a, number b, const coeffs r)
Definition: ffields.cc:171
static BOOLEAN nfGreaterZero(number k, const coeffs r)
Definition: ffields.cc:160
static void nfWriteShort(number a, const coeffs r)
Definition: ffields.cc:440
static char * nfCoeffName(const coeffs r)
Definition: ffields.cc:820
static number nfSub(number a, number b, const coeffs r)
Definition: ffields.cc:315
static number nfRandom(siRandProc p, number, number, const coeffs cf)
Definition: ffields.cc:829
static BOOLEAN nfIsOne(number a, const coeffs r)
Definition: ffields.cc:324
static void nfCoeffWrite(const coeffs r, BOOLEAN details)
Definition: ffields.cc:834
static const char * nfRead(const char *s, number *a, const coeffs r)
Definition: ffields.cc:509
static BOOLEAN nfGreater(number a, number b, const coeffs r)
Definition: ffields.cc:382
static number nfNeg(number c, const coeffs r)
Definition: ffields.cc:297
static BOOLEAN nfCoeffIsEqual(const coeffs, n_coeffType, void *)
Definition: ffields.cc:848
static BOOLEAN nfEqual(number a, number b, const coeffs r)
Definition: ffields.cc:394
static void nfReadTable(const int c, const coeffs r)
Definition: ffields.cc:592
static void nfWriteLong(number a, const coeffs r)
Definition: ffields.cc:406
static number nfDiv(number a, number b, const coeffs r)
Definition: ffields.cc:335
static number nfParameter(int i, const coeffs)
Definition: ffields.cc:215
static number nfInvers(number c, const coeffs r)
Definition: ffields.cc:363
static void nfPower(number a, int i, number *result, const coeffs r)
Definition: ffields.cc:473
VAR int check
Definition: libparse.cc:1106
BOOLEAN npInitChar(coeffs r, void *p)
Definition: modulop.cc:340
gmp_float log(const gmp_float &a)
Definition: mpr_complex.cc:343
#define omStrDup(s)
Definition: omAllocDecl.h:263
#define omAlloc(size)
Definition: omAllocDecl.h:210
int IsPrime(int p)
Definition: prime.cc:61
void Werror(const char *fmt,...)
Definition: reporter.cc:189

◆ nfInitMPZ()

static number nfInitMPZ ( mpz_t  m,
const coeffs  cf 
)
static

Definition at line 732 of file ffields.cc.

733 {
734  mpz_t tmp;
735  mpz_init(tmp);
736  mpz_mod_ui(tmp,m,cf->m_nfCharP);
737  long l=mpz_get_si(tmp);
738  return nfInit(l,cf);
739 }
int m
Definition: cfEzgcd.cc:128
CanonicalForm cf
Definition: cfModGcd.cc:4085

◆ nfInt()

static long nfInt ( number &  n,
const coeffs  r 
)
static

Definition at line 240 of file ffields.cc.

241 {
242  unsigned short c=0;
243  unsigned short nn=(unsigned short)(long)n;
244  if (nn==r->m_nfCharQ) return 0;
245  long i=1; /* 1==a^0 */
246  while ((c!=nn)&&(i<r->m_nfCharP))
247  {
248  c=r->m_nfPlus1Table[c];
249  i++;
250  }
251  if (c==nn) return i;
252  else return 0;
253 }

◆ nfInvers()

static number nfInvers ( number  c,
const coeffs  r 
)
static

Definition at line 363 of file ffields.cc.

364 {
365 #ifdef LDEBUG
366  nfTest(c, r);
367 #endif
368  if ((long)c==(long)r->m_nfCharQ)
369  {
370  WerrorS(nDivBy0);
371  return (number)((long)r->m_nfCharQ);
372  }
373 #ifdef LDEBUG
374  nfTest(((number)((long)r->m_nfCharQ1-(long)c)), r);
375 #endif
376  return (number)((long)r->m_nfCharQ1-(long)c);
377 }

◆ nfIsMOne()

static BOOLEAN nfIsMOne ( number  a,
const coeffs  r 
)
static

Definition at line 148 of file ffields.cc.

149 {
150 #ifdef LDEBUG
151  nfTest(a, r);
152 #endif
153  if (0L == (long)a) return FALSE; /* special handling of char 2*/
154  return (long)r->m_nfM1 == (long)a;
155 }

◆ nfIsOne()

static BOOLEAN nfIsOne ( number  a,
const coeffs  r 
)
static

Definition at line 324 of file ffields.cc.

325 {
326 #ifdef LDEBUG
327  nfTest(a, r);
328 #endif
329  return 0L == (long)a;
330 }

◆ nfIsZero()

static BOOLEAN nfIsZero ( number  a,
const coeffs  r 
)
static

Definition at line 137 of file ffields.cc.

138 {
139 #ifdef LDEBUG
140  nfTest(a, r);
141 #endif
142  return (long)r->m_nfCharQ == (long)a;
143 }

◆ nfKillChar()

static void nfKillChar ( coeffs  r)
static

Definition at line 812 of file ffields.cc.

813 {
814  char** p = (char**)n_ParameterNames(r);
815  /* only one parameter */
816  omFree( (ADDRESS)p[0] );
817  omFreeSize((ADDRESS)p, sizeof(char*));
818 }
void * ADDRESS
Definition: auxiliary.h:119
#define omFreeSize(addr, size)
Definition: omAllocDecl.h:260

◆ nfMapGG()

static number nfMapGG ( number  c,
const coeffs  src,
const  coeffs 
)
static

Definition at line 704 of file ffields.cc.

705 {
706  int i=(long)c;
707  i*= nfMapGG_factor;
708  while (i >src->m_nfCharQ1) i-=src->m_nfCharQ1;
709  return (number)((long)i);
710 }
STATIC_VAR int nfMapGG_factor
Definition: ffields.cc:703

◆ nfMapGGrev()

static number nfMapGGrev ( number  c,
const coeffs  src,
const  coeffs 
)
static

Definition at line 714 of file ffields.cc.

715 {
716  int ex=(int)((long)c);
717  if ((ex % nfMapGG_factor)==0)
718  return (number)(((long)ex) / ((long)nfMapGG_factor));
719  else
720  return (number)(long)src->m_nfCharQ; /* 0 */
721 }

◆ nfMapMPZ()

static number nfMapMPZ ( number  c,
const  coeffs,
const coeffs  dst 
)
static

Definition at line 723 of file ffields.cc.

724 {
725  mpz_t tmp;
726  mpz_init(tmp);
727  mpz_mod_ui(tmp,(mpz_ptr)c,dst->m_nfCharP);
728  long l=mpz_get_si(tmp);
729  return nfInit(l,dst);
730 }

◆ nfMapP()

static number nfMapP ( number  c,
const  coeffs,
const coeffs  dst 
)
static

Definition at line 695 of file ffields.cc.

696 {
697  return nfInit((int)((long)c), dst);
698 }

◆ nfMapViaInt()

static number nfMapViaInt ( number  c,
const coeffs  src,
const coeffs  dst 
)
static

Definition at line 741 of file ffields.cc.

742 {
743  long i=src->cfInt(c,src);
744  if (i==0) return (number)(long)dst->m_nfCharQ;
745  while (i < 0) i += dst->m_nfCharP;
746  while (i >= dst->m_nfCharP) i -= dst->m_nfCharP;
747  return nfInit(i,dst);
748 }

◆ nfMult()

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

Definition at line 171 of file ffields.cc.

172 {
173 #ifdef LDEBUG
174  nfTest(a, r);
175  nfTest(b, r);
176 #endif
177  if (((long)a == (long)r->m_nfCharQ) || ((long)b == (long)r->m_nfCharQ))
178  return (number)(long)r->m_nfCharQ;
179  /*else*/
180  int i=(int)((long)a+(long)b);
181  if (i>=r->m_nfCharQ1) i-=r->m_nfCharQ1;
182 #ifdef LDEBUG
183  nfTest((number)(long)i, r);
184 #endif
185  return (number)(long)i;
186 }

◆ nfNeg()

static number nfNeg ( number  c,
const coeffs  r 
)
static

Definition at line 297 of file ffields.cc.

298 {
299 /*4 -z^c=z^c*(-1)=z^c*nfM1*/
300 #ifdef LDEBUG
301  nfTest(c, r);
302 #endif
303  if ((long)r->m_nfCharQ == (long)c) return c;
304  long i=(long)c+(long)r->m_nfM1;
305  if (i>=(long)r->m_nfCharQ1) i-=(long)r->m_nfCharQ1;
306 #ifdef LDEBUG
307  nfTest((number)i, r);
308 #endif
309  return (number)i;
310 }

◆ nfParameter()

static number nfParameter ( int  i,
const  coeffs 
)
static

Definition at line 215 of file ffields.cc.

216 {
217  assume(i==1);
218 
219  if( i == 1 )
220  return (number)1;
221 
222  return NULL;
223 }

◆ nfParDeg()

static int nfParDeg ( number  n,
const coeffs  r 
)
static

Definition at line 228 of file ffields.cc.

229 {
230 #ifdef LDEBUG
231  nfTest(n, r);
232 #endif
233  if((long)r->m_nfCharQ == (long)n) return -1;
234  return (int)((long)n);
235 }

◆ nfPower()

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

Definition at line 473 of file ffields.cc.

474 {
475 #ifdef LDEBUG
476  nfTest(a, r);
477 #endif
478  if (i==0)
479  {
480  *result = (number)0L;
481  }
482  else if (i==1)
483  {
484  *result = a;
485  }
486  else
487  {
488  long rl;
489  if ((long)a == (long)r->m_nfCharQ) rl=(long)r->m_nfCharQ;
490  else rl=((long)a*(long)i) % (long)r->m_nfCharQ1;
491  *result = (number)rl;
492  }
493 #ifdef LDEBUG
494  nfTest(*result, r);
495 #endif
496 }
return result
Definition: facAbsBiFact.cc:75

◆ nfRandom()

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

Definition at line 829 of file ffields.cc.

830 {
831  return (number)(long)(p() %(cf->m_nfCharQ+1));
832 }

◆ nfRead()

static const char* nfRead ( const char *  s,
number *  a,
const coeffs  r 
)
static

Definition at line 509 of file ffields.cc.

510 {
511  int i;
512  number z;
513  number n;
514 
515  s = nfEati(s, &i, r);
516  z=nfInit(i, r);
517  *a=z;
518  if (*s == '/')
519  {
520  s++;
521  s = nfEati(s, &i, r);
522  n=nfInit(i, r);
523  *a = nfDiv(z,n,r);
524  }
525  const char * const nf_Parameter = n_ParameterNames(r)[0];
526  const int N = strlen(nf_Parameter);
527  if (strncmp(s,nf_Parameter, N)==0)
528  {
529  s += N;
530  if ((*s >= '0') && (*s <= '9'))
531  {
532  s=eati(s,&i);
533  while (i>=r->m_nfCharQ1) i-=r->m_nfCharQ1;
534  }
535  else
536  i=1;
537  z=(number)(long)i;
538  *a=nfMult(*a,z,r);
539  }
540 #ifdef LDEBUG
541  nfTest(*a, r);
542 #endif
543  return s;
544 }
const CanonicalForm CFMap CFMap & N
Definition: cfEzgcd.cc:56
const char * eati(const char *s, int *i)
Definition: reporter.cc:373
static const char * nfEati(const char *s, int *i, const coeffs r)
Definition: ffields.cc:501

◆ nfReadMipo()

static void nfReadMipo ( char *  s)
static

Definition at line 567 of file ffields.cc.

568 {
569  const char *l=strchr(s,';')+1;
570  char *n;
571  int i=strtol(l,&n,10);
572  l=n;
573  int j=1;
574  nfMinPoly[0]=i;
575  while(i>=0)
576  {
577  nfMinPoly[j]=strtol(l,&n,10);
578  if (l==n) break;
579  l=n;
580  j++;
581  i--;
582  }
583  if (i>=0)
584  {
585  WerrorS("error in reading minpoly from gftables");
586  }
587 }
STATIC_VAR int nfMinPoly[16]
Definition: ffields.cc:549

◆ nfReadTable()

static void nfReadTable ( const int  c,
const coeffs  r 
)
static

Definition at line 592 of file ffields.cc.

593 {
594  //Print("GF(%d)\n",c);
595  if ((c==r->m_nfCharQ)||(c== -r->m_nfCharQ))
596  /*this field is already set*/ return;
597  int i=0;
598 
599  if ((c>255) ||(c!=IsPrime(c)))
600  {
601  while ((fftable[i]!=c) && (fftable[i]!=0))
602  i++;
603 
604  if (fftable[i]==0)
605  {
606  // illegal GF-table size: c
607  return;
608  }
609  }
610 
611  if (r->m_nfCharQ > 1)
612  {
613  omFreeSize( (ADDRESS)r->m_nfPlus1Table,(r->m_nfCharQ+1)*sizeof(unsigned short) );
614  r->m_nfPlus1Table=NULL;
615  }
616  if ((c>1) || (c<0))
617  {
618  if (c>1) r->m_nfCharQ = c;
619  else r->m_nfCharQ = -c;
620  char buf[100];
621  sprintf(buf,"gftables/%d",r->m_nfCharQ);
622  FILE * fp = feFopen(buf,"r",NULL,TRUE);
623  if (fp==NULL)
624  {
625  return;
626  }
627  if(!fgets( buf, sizeof(buf), fp)) return;
628  if(strcmp(buf,"@@ factory GF(q) table @@\n")!=0)
629  {
630  goto err;
631  }
632  if(!fgets( buf, sizeof(buf), fp))
633  {
634  goto err;
635  }
636  int q;
637  int res = -1;
638  do
639  {
640  res = sscanf(buf,"%d %d",&r->m_nfCharP,&q);
641  }
642  while((res < 0) and (errno == EINTR));
643 
644  nfReadMipo(buf);
645  r->m_nfCharQ1=r->m_nfCharQ-1;
646  //Print("nfCharQ=%d,nfCharQ1=%d,mipo=>>%s<<\n",nfCharQ,nfCharQ1,buf);
647  r->m_nfPlus1Table= (unsigned short *)omAlloc0( (r->m_nfCharQ+1)*sizeof(unsigned short) );
648  int digs = gf_tab_numdigits62( r->m_nfCharQ );
649  char * bufptr;
650  int i = 1;
651  int k;
652  while ( i < r->m_nfCharQ )
653  {
654  (void)fgets( buf, sizeof(buf), fp);
655  //( strlen( buffer ) == (size_t)digs * 30, "illegal table" );
656  bufptr = buf;
657  k = 0;
658  while ( (i < r->m_nfCharQ) && (k < 30) )
659  {
660  r->m_nfPlus1Table[i] = convertback62( bufptr, digs );
661  if(r->m_nfPlus1Table[i]>r->m_nfCharQ)
662  {
663  Print("wrong entry %d: %d(%c%c%c)\n",i,r->m_nfPlus1Table[i],bufptr[0],bufptr[1],bufptr[2]);
664  }
665  bufptr += digs;
666  if (r->m_nfPlus1Table[i]==r->m_nfCharQ)
667  {
668  if(i==r->m_nfCharQ1)
669  {
670  r->m_nfM1=0;
671  }
672  else
673  {
674  r->m_nfM1=i;
675  }
676  }
677  i++; k++;
678  }
679  }
680  r->m_nfPlus1Table[0]=r->m_nfPlus1Table[r->m_nfCharQ1];
681  }
682  else
683  r->m_nfCharQ=0;
684 #ifdef LDEBUG
685  nfTest((number)0, r);
686 #endif
687  return;
688 err:
689  Werror("illegal GF-table %d",r->m_nfCharQ);
690 }
CanonicalForm fp
Definition: cfModGcd.cc:4104
CanonicalForm res
Definition: facAbsFact.cc:60
FILE * feFopen(const char *path, const char *mode, char *where, short useWerror, short path_only)
Definition: feFopen.cc:47
int convertback62(char *p, int n)
Definition: gf_tabutil.cc:50
static void nfReadMipo(char *s)
Definition: ffields.cc:567
int gf_tab_numdigits62(int q)
Definition: gf_tabutil.cc:12
const unsigned short fftable[]
Definition: ffields.cc:31
#define omAlloc0(size)
Definition: omAllocDecl.h:211
int status int void * buf
Definition: si_signals.h:59

◆ nfSetMap()

static nMapFunc nfSetMap ( const coeffs  src,
const coeffs  dst 
)
static

Definition at line 753 of file ffields.cc.

754 {
755  if (nCoeff_is_GF(src))
756  {
757  const coeffs r = dst;
758  int q=src->ch;
759  if ((src->m_nfCharQ % q)==0) /* GF(p,n1) -> GF(p,n2), n2 > n1 */
760  {
761  // check if n2 is a multiple of n1
762  int n1=1;
763  int qq=r->m_nfCharP;
764  while(qq!=q) { qq *= r->m_nfCharP; n1++; }
765  int n2=1;
766  qq=r->m_nfCharP;
767  while(qq!=src->m_nfCharQ) { qq *= r->m_nfCharP; n2++; }
768  //Print("map %d^%d -> %d^%d\n",r->m_nfCharP,n1,r->m_nfCharP,n2);
769  if ((n2 % n1)==0)
770  {
771  int save_ch=r->m_nfCharQ;
772  nfReadTable(src->m_nfCharQ, r);
773  int nn=r->m_nfPlus1Table[0];
774  nfReadTable(save_ch, r);
775  nfMapGG_factor= r->m_nfPlus1Table[0] / nn;
776  //Print("nfMapGG_factor=%d (%d / %d)\n",nfMapGG_factor, r->m_nfPlus1Table[0], nn);
777  return nfMapGG;
778  }
779  else if ((n1 % n2)==0)
780  {
781  nfMapGG_factor= (n1/n2);
782  return nfMapGGrev;
783  }
784  else
785  return NULL;
786  }
787  }
788  if ((src->rep==n_rep_int) && nCoeff_is_Zp(src,dst->m_nfCharP))
789  {
790  return nfMapP; /* Z/p -> GF(p,n) */
791  }
792 
793  if (src->rep==n_rep_gap_rat) /*Q, bigint */
794  {
795  return nlModP; // FIXME? TODO? // extern number nlModP(number q, const coeffs Q, const coeffs Zp); // Map q \in QQ \to Zp // FIXME!
796  }
797  if (nCoeff_is_Z(src)) /* Z*/
798  {
799  return nfMapMPZ;
800  }
801  if (nCoeff_is_Zp(src) && (src->ch==dst->m_nfCharP)) /* Zp*/
802  {
803  return nfMapViaInt;
804  }
805 
806 
807  return NULL; /* default */
808 }
static FORCE_INLINE BOOLEAN nCoeff_is_GF(const coeffs r)
Definition: coeffs.h:863
static FORCE_INLINE BOOLEAN nCoeff_is_Z(const coeffs r)
Definition: coeffs.h:840
static FORCE_INLINE BOOLEAN nCoeff_is_Zp(const coeffs r)
Definition: coeffs.h:824
@ n_rep_gap_rat
(number), see longrat.h
Definition: coeffs.h:112
@ n_rep_int
(int), see modulop.h
Definition: coeffs.h:111
static number nfMapViaInt(number c, const coeffs src, const coeffs dst)
Definition: ffields.cc:741
static number nfMapMPZ(number c, const coeffs, const coeffs dst)
Definition: ffields.cc:723
static number nfMapGGrev(number c, const coeffs src, const coeffs)
Definition: ffields.cc:714
static number nfMapP(number c, const coeffs, const coeffs dst)
Definition: ffields.cc:695
static number nfMapGG(number c, const coeffs src, const coeffs)
Definition: ffields.cc:704
number nlModP(number q, const coeffs, const coeffs Zp)
Definition: longrat.cc:1538
The main handler for Singular numbers which are suitable for Singular polynomials.

◆ nfShowMipo()

void nfShowMipo ( const coeffs  r)

Show the mininimal polynom.... NOTE: this is used by char * sleftv::String(void *d, BOOLEAN typed, int dim) (from Singular/subexpr.cc) for printing minpoly.

Definition at line 551 of file ffields.cc.

552 {
553  int i=nfMinPoly[0];
554  int j=0;
555  loop
556  {
557  j++;
558  if (nfMinPoly[j]!=0)
559  StringAppend("%d*%s^%d",nfMinPoly[j],n_ParameterNames(r)[0],i);
560  i--;
561  if(i<0) break;
562  if (nfMinPoly[j]!=0)
563  StringAppendS("+");
564  }
565 }
#define StringAppend
Definition: emacs.cc:79
#define loop
Definition: structs.h:80

◆ nfSub()

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

Definition at line 315 of file ffields.cc.

316 {
317  number mb = nfNeg(b, r);
318  return nfAdd(a,mb,r);
319 }

◆ nfWriteLong()

static void nfWriteLong ( number  a,
const coeffs  r 
)
static

Definition at line 406 of file ffields.cc.

407 {
408 #ifdef LDEBUG
409  nfTest(a, r);
410 #endif
411  if ((long)a==(long)r->m_nfCharQ) StringAppendS("0");
412  else if ((long)a==0L) StringAppendS("1");
413  else if (nfIsMOne(a, r)) StringAppendS("-1");
414  else
415  {
416  int i=1; /* 1==a^0 */
417  unsigned short c=0;
418  unsigned short nn=(unsigned short)(long)a;
419  while ((c!=nn)&&(i<r->m_nfCharQ))
420  {
421  c=r->m_nfPlus1Table[c];
422  i++;
423  }
424  if (c==nn) StringAppend("%d",i);
425  else
426  {
428  if ((long)a!=1L)
429  {
430  StringAppend("^%d",(int)((long)a)); // long output!
431  }
432  }
433  }
434 }

◆ nfWriteShort()

static void nfWriteShort ( number  a,
const coeffs  r 
)
static

Definition at line 440 of file ffields.cc.

441 {
442 #ifdef LDEBUG
443  nfTest(a, r);
444 #endif
445  if ((long)a==(long)r->m_nfCharQ) StringAppendS("0");
446  else if ((long)a==0L) StringAppendS("1");
447  else if (nfIsMOne(a, r)) StringAppendS("-1");
448  else
449  {
450  int i=1; /* 1==a^0 */
451  unsigned short c=0;
452  unsigned short nn=(unsigned short)(long)a;
453  while ((c!=nn)&&(i<r->m_nfCharQ))
454  {
455  c=r->m_nfPlus1Table[c];
456  i++;
457  }
458  if (c==nn) StringAppend("%d",i);
459  else
460  {
462  if ((long)a!=1L)
463  {
464  StringAppend("%d",(int)((long)a));
465  }
466  }
467  }
468 }

Variable Documentation

◆ fftable

const unsigned short fftable[]

Definition at line 31 of file ffields.cc.

◆ nfMapGG_factor

STATIC_VAR int nfMapGG_factor

Definition at line 703 of file ffields.cc.

◆ nfMinPoly

STATIC_VAR int nfMinPoly[16]

Definition at line 549 of file ffields.cc.