My Project
Static Public Member Functions | Static Private Attributes
CFFactory Class Reference

#include <cf_factory.h>

Static Public Member Functions

static int gettype ()
 
static void settype (int type)
 
static InternalCF * basic (int value)
 
static InternalCF * basic (long value)
 
static InternalCF * basic (int type, long value)
 
static InternalCF * basic (const char *str)
 
static InternalCF * basic (const char *str, int base)
 
static InternalCF * basic (int type, const char *const str)
 
static InternalCF * basic (int type, long value, bool nonimm)
 
static InternalCF * basic (const mpz_ptr num)
 
static InternalCF * rational (long num, long den)
 
static InternalCF * rational (const mpz_ptr num, const mpz_ptr den, bool normalize)
 
static InternalCF * poly (const Variable &v, int exp, const CanonicalForm &c)
 
static InternalCF * poly (const Variable &v, int exp=1)
 

Static Private Attributes

static int currenttype = IntegerDomain
 

Detailed Description

Definition at line 23 of file cf_factory.h.

Member Function Documentation

◆ basic() [1/8]

InternalCF * CFFactory::basic ( const char *  str)
static

Definition at line 122 of file cf_factory.cc.

123 {
124  if ( currenttype == IntegerDomain ) {
125  InternalInteger * dummy = new InternalInteger( str );
126  if ( dummy->is_imm() ) {
127  InternalCF * res = int2imm( dummy->intval() );
128  delete dummy;
129  return res;
130  }
131  else
132  return dummy;
133  }
134 // else if ( currenttype == RationalDomain ) {
135 // InternalRational * dummy = new InternalRational( str );
136 // if ( dummy->is_imm() ) {
137 // InternalCF * res = int2imm( dummy->intval() );
138 // delete dummy;
139 // return res;
140 // }
141 // else
142 // return dummy;
143 // }
144  else if ( currenttype == FiniteFieldDomain ) {
145  InternalInteger * dummy = new InternalInteger( str );
146  InternalCF * res = int2imm_p( dummy->intmod( ff_prime ) );
147  delete dummy;
148  return res;
149  }
150  else if ( currenttype == GaloisFieldDomain ) {
151  InternalInteger * dummy = new InternalInteger( str );
152  InternalCF * res = int2imm_gf( gf_int2gf( dummy->intmod( ff_prime ) ) );
153  delete dummy;
154  return res;
155  }
156  else {
157  ASSERT( 0, "illegal basic domain!" );
158  return 0;
159  }
160 }
ASSERT
#define ASSERT(expression, message)
Definition: cf_assert.h:99
FiniteFieldDomain
#define FiniteFieldDomain
Definition: cf_defs.h:19
IntegerDomain
#define IntegerDomain
Definition: cf_defs.h:21
GaloisFieldDomain
#define GaloisFieldDomain
Definition: cf_defs.h:18
CFFactory::currenttype
static int currenttype
Definition: cf_factory.h:26
InternalCF
virtual class for internal CanonicalForm's
Definition: int_cf.h:47
InternalInteger
factory's class for integers
Definition: int_int.h:41
InternalInteger::intval
long intval() const
Definition: int_int.cc:506
InternalInteger::is_imm
bool is_imm() const
Definition: int_int.cc:41
InternalInteger::intmod
int intmod(int p) const
Definition: int_int.cc:511
res
CanonicalForm res
Definition: facAbsFact.cc:60
ff_prime
VAR int ff_prime
Definition: ffops.cc:14
gf_int2gf
int gf_int2gf(int i)
Definition: gfops.h:65
int2imm_p
InternalCF * int2imm_p(long i)
Definition: imm.h:101
int2imm
static InternalCF * int2imm(long i)
Definition: imm.h:75
int2imm_gf
InternalCF * int2imm_gf(long i)
Definition: imm.h:106
LibThread::str
char * str(leftv arg)
Definition: shared.cc:704

◆ basic() [2/8]

InternalCF * CFFactory::basic ( const char *  str,
int  base 
)
static

Definition at line 163 of file cf_factory.cc.

164 {
165  if ( currenttype == IntegerDomain ) {
166  InternalInteger * dummy = new InternalInteger( str, base );
167  if ( dummy->is_imm() ) {
168  InternalCF * res = int2imm( dummy->intval() );
169  delete dummy;
170  return res;
171  }
172  else
173  return dummy;
174  }
175 // else if ( currenttype == RationalDomain ) {
176 // InternalRational * dummy = new InternalRational( str );
177 // if ( dummy->is_imm() ) {
178 // InternalCF * res = int2imm( dummy->intval() );
179 // delete dummy;
180 // return res;
181 // }
182 // else
183 // return dummy;
184 // }
185  else if ( currenttype == FiniteFieldDomain ) {
186  InternalInteger * dummy = new InternalInteger( str, base );
187  InternalCF * res = int2imm_p( dummy->intmod( ff_prime ) );
188  delete dummy;
189  return res;
190  }
191  else if ( currenttype == GaloisFieldDomain ) {
192  InternalInteger * dummy = new InternalInteger( str, base );
193  InternalCF * res = int2imm_gf( gf_int2gf( dummy->intmod( ff_prime ) ) );
194  delete dummy;
195  return res;
196  }
197  else {
198  ASSERT( 0, "illegal basic domain!" );
199  return 0;
200  }
201 }
CxxTest::base
char N base
Definition: ValueTraits.h:144

◆ basic() [3/8]

InternalCF * CFFactory::basic ( const mpz_ptr  num)
static

Definition at line 261 of file cf_factory.cc.

262 {
263  ASSERT (currenttype == IntegerDomain, "Integer domain expected");
264  return new InternalInteger( num );
265 }
num
CanonicalForm num(const CanonicalForm &f)
Definition: canonicalform.h:337

◆ basic() [4/8]

InternalCF * CFFactory::basic ( int  type,
const char *const  str 
)
static

Definition at line 204 of file cf_factory.cc.

205 {
206  if ( type == IntegerDomain ) {
207  InternalInteger * dummy = new InternalInteger( str );
208  if ( dummy->is_imm() ) {
209  InternalCF * res = int2imm( dummy->intval() );
210  delete dummy;
211  return res;
212  }
213  else
214  return dummy;
215  }
216 // else if ( type == RationalDomain ) {
217 // InternalRational * dummy = new InternalRational( str );
218 // if ( dummy->is_imm() ) {
219 // InternalCF * res = int2imm( dummy->intval() );
220 // delete dummy;
221 // return res;
222 // }
223 // else
224 // return dummy;
225 // }
226  else if ( type == FiniteFieldDomain ) {
227  InternalInteger * dummy = new InternalInteger( str );
228  InternalCF * res = int2imm( dummy->intmod( ff_prime ) );
229  delete dummy;
230  return res;
231  }
232  else if ( type == GaloisFieldDomain ) {
233  InternalInteger * dummy = new InternalInteger( str );
234  InternalCF * res = int2imm_gf( gf_int2gf( dummy->intmod( ff_prime ) ) );
235  delete dummy;
236  return res;
237  }
238  else {
239  ASSERT( 0, "illegal basic domain!" );
240  return 0;
241  }
242 }

◆ basic() [5/8]

InternalCF * CFFactory::basic ( int  type,
long  value 
)
static

Definition at line 99 of file cf_factory.cc.

100 {
101  if ( type == IntegerDomain )
102  if (LIKELY( value >= MINIMMEDIATE && value <= MAXIMMEDIATE ))
103  return int2imm( value );
104  else
105  return new InternalInteger( value );
106 // else if ( type == RationalDomain )
107 // if ( value >= MINIMMEDIATE && value <= MAXIMMEDIATE )
108 // return int2imm( value );
109 // else
110 // return new InternalRational( value );
111  else if ( type == FiniteFieldDomain )
112  return int2imm_p( ff_norm( value ) );
113  else if ( type == GaloisFieldDomain )
114  return int2imm_gf( gf_int2gf( value ) );
115  else {
116  ASSERT1( 0, "illegal basic domain (type = %d)!", type );
117  return 0;
118  }
119 }
ASSERT1
#define ASSERT1(expression, message, parameter1)
Definition: cf_assert.h:101
LIKELY
#define LIKELY(expression)
For optimizing if-branches.
Definition: cf_factory.cc:24
ff_norm
int ff_norm(const int a)
Definition: ffops.h:39
MAXIMMEDIATE
const long MAXIMMEDIATE
Definition: imm.h:55
MINIMMEDIATE
const long MINIMMEDIATE
Definition: imm.h:54

◆ basic() [6/8]

InternalCF * CFFactory::basic ( int  type,
long  value,
bool  nonimm 
)
static

Definition at line 245 of file cf_factory.cc.

246 {
247  if ( nonimm )
248  if ( type == IntegerDomain )
249  return new InternalInteger( value );
250  else if ( type == RationalDomain )
251  return new InternalRational( value );
252  else {
253  ASSERT( 0, "illegal basic domain!" );
254  return 0;
255  }
256  else
257  return CFFactory::basic( type, value );
258 }
RationalDomain
#define RationalDomain
Definition: cf_defs.h:20
CFFactory::basic
static InternalCF * basic(int value)
Definition: cf_factory.cc:61
InternalRational
factory's class for rationals
Definition: int_rat.h:39

◆ basic() [7/8]

InternalCF * CFFactory::basic ( int  value)
static

Definition at line 61 of file cf_factory.cc.

62 {
63  switch(currenttype)
64  {
65  case IntegerDomain:
66 #if SIZEOF_LONG == 8
67  return int2imm( value );
68 #else
69  if (LIKELY( value >= MINIMMEDIATE && value <= MAXIMMEDIATE ))
70  return int2imm( value );
71  else
72  return new InternalInteger( value );
73 #endif
74  case RationalDomain:
75 #if SIZEOF_LONG == 8
76  return int2imm( value );
77 #else
78  if (LIKELY( value >= MINIMMEDIATE && value <= MAXIMMEDIATE ))
79  return int2imm( value );
80  else
81  return new InternalRational( value );
82 #endif
83  case FiniteFieldDomain:
84  return int2imm_p( ff_norm( value ) );
85  case GaloisFieldDomain:
86  return int2imm_gf( gf_int2gf( value ) );
87  #ifndef HAVE_NTL
88  case PrimePowerDomain:
89  return new InternalPrimePower( value );
90  #endif
91  default: {
92  ASSERT( 0, "illegal basic domain!" );
93  return 0;
94  }
95  }
96 }
PrimePowerDomain
#define PrimePowerDomain
Definition: cf_defs.h:17

◆ basic() [8/8]

InternalCF * CFFactory::basic ( long  value)
static

Definition at line 31 of file cf_factory.cc.

32 {
33  switch(currenttype)
34  {
35  case IntegerDomain:
36  if (LIKELY( value >= MINIMMEDIATE && value <= MAXIMMEDIATE ))
37  return int2imm( value );
38  else
39  return new InternalInteger( value );
40 // else if ( currenttype == RationalDomain )
41 // if ( value >= MINIMMEDIATE && value <= MAXIMMEDIATE )
42 // return int2imm( value );
43 // else
44 // return new InternalRational( value );
45  case FiniteFieldDomain:
46  return int2imm_p( ff_norm( value ) );
47  case GaloisFieldDomain:
48  return int2imm_gf( gf_int2gf( value ) );
49  #ifndef HAVE_NTL
50  case PrimePowerDomain:
51  return new InternalPrimePower( value );
52  #endif
53  default: {
54  ASSERT( 0, "illegal basic domain!" );
55  return 0;
56  }
57  }
58 }

◆ gettype()

static int CFFactory::gettype ( )
inlinestatic

Definition at line 28 of file cf_factory.h.

28 { return currenttype; }

◆ poly() [1/2]

InternalCF * CFFactory::poly ( const Variable &  v,
int  exp,
const CanonicalForm &  c 
)
static

Definition at line 286 of file cf_factory.cc.

287 {
288  if ( v.level() == LEVELBASE )
289  return c.getval();
290  else
291  return new InternalPoly( v, exp, c );
292 }
LEVELBASE
#define LEVELBASE
Definition: cf_defs.h:25
CanonicalForm::getval
InternalCF * getval() const
Definition: canonicalform.cc:34
InternalPoly
factory's class for polynomials
Definition: int_poly.h:71
Variable::level
int level() const
Definition: factory.h:143
v
const Variable & v
< [in] a sqrfree bivariate poly
Definition: facBivar.h:39
exp
gmp_float exp(const gmp_float &a)
Definition: mpr_complex.cc:357

◆ poly() [2/2]

InternalCF * CFFactory::poly ( const Variable &  v,
int  exp = 1 
)
static

Definition at line 295 of file cf_factory.cc.

296 {
297  if ( v.level() == LEVELBASE )
298  return CFFactory::basic( 1L );
299  else
300  return new InternalPoly( v, exp, 1 );
301 }

◆ rational() [1/2]

InternalCF * CFFactory::rational ( const mpz_ptr  num,
const mpz_ptr  den,
bool  normalize 
)
static

Definition at line 275 of file cf_factory.cc.

276 {
277  if ( normalize ) {
278  InternalRational * result = new InternalRational( num, den );
279  return result->normalize_myself();
280  }
281  else
282  return new InternalRational( num, den );
283 }
den
CanonicalForm den(const CanonicalForm &f)
Definition: canonicalform.h:340
result
return result
Definition: facAbsBiFact.cc:75
normalize
static poly normalize(poly next_p, ideal add_generators, syStrategy syzstr, int *g_l, int *p_l, int crit_comp)
Definition: syz3.cc:1026

◆ rational() [2/2]

InternalCF * CFFactory::rational ( long  num,
long  den 
)
static

Definition at line 268 of file cf_factory.cc.

269 {
270  InternalRational * res = new InternalRational( num, den );
271  return res->normalize_myself();
272 }

◆ settype()

static void CFFactory::settype ( int  type)
inlinestatic

Definition at line 29 of file cf_factory.h.

30  {
31  ASSERT( type==FiniteFieldDomain || type==GaloisFieldDomain || type==IntegerDomain || type==RationalDomain || type==PrimePowerDomain, "illegal basic domain!" );
32  currenttype = type;
33  };

Field Documentation

◆ currenttype

int CFFactory::currenttype = IntegerDomain
staticprivate

Definition at line 26 of file cf_factory.h.

The documentation for this class was generated from the following files:
Generated on Tue Jul 5 2022 00:00:00 for My Project by   doxygen 1.9.1 for Singular