source: git/factory/cf_factory.cc @ 34f6d2

spielwiese
Last change on this file since 34f6d2 was 0a6f36, checked in by Hans Schoenemann <hannes@…>, 4 years ago
fix: 32bit factory
  • Property mode set to 100644
File size: 8.4 KB
Line 
1/* emacs edit mode for this file is -*- C++ -*- */
2
3
4#include "config.h"
5
6
7#include "cf_assert.h"
8
9#include "cf_defs.h"
10#include "cf_factory.h"
11#include "canonicalform.h"
12#include "int_cf.h"
13#include "int_int.h"
14#include "int_rat.h"
15#include "int_poly.h"
16#include "int_pp.h"
17#include "imm.h"
18
19/// For optimizing if-branches
20#ifdef __GNUC__
21#define LIKELY(expression) (__builtin_expect(!!(expression), 1))
22#define UNLIKELY(expression) (__builtin_expect(!!(expression), 0))
23#else
24#define LIKELY(expression) (expression)
25#define UNLIKELY(expression) (expression)
26#endif
27
28int CFFactory::currenttype = IntegerDomain;
29
30InternalCF *
31CFFactory::basic ( long value )
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}
59
60InternalCF *
61CFFactory::basic ( int value )
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}
97
98InternalCF *
99CFFactory::basic ( int type, long value )
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}
120
121InternalCF *
122CFFactory::basic ( const char * str )
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}
161
162InternalCF *
163CFFactory::basic ( const char * str, int base )
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}
202
203InternalCF *
204CFFactory::basic ( int type, const char * const str )
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}
243
244InternalCF *
245CFFactory::basic ( int type, long value, bool nonimm )
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}
259
260InternalCF *
261CFFactory::basic ( const mpz_ptr num )
262{
263  ASSERT (currenttype == IntegerDomain, "Integer domain expected");
264  return new InternalInteger( num );
265}
266
267InternalCF *
268CFFactory::rational ( long num, long den )
269{
270    InternalRational * res = new InternalRational( num, den );
271    return res->normalize_myself();
272}
273
274InternalCF *
275CFFactory::rational ( const mpz_ptr num, const mpz_ptr den, bool normalize )
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}
284
285InternalCF *
286CFFactory::poly (  const Variable & v, int exp, const CanonicalForm & c )
287{
288    if ( v.level() == LEVELBASE )
289        return c.getval();
290    else
291        return new InternalPoly( v, exp, c );
292}
293
294InternalCF *
295CFFactory::poly ( const Variable & v, int exp )
296{
297    if ( v.level() == LEVELBASE )
298        return CFFactory::basic( 1L );
299    else
300        return new InternalPoly( v, exp, 1 );
301}
302
303void getmpi ( InternalCF * value, mpz_t mpi)
304{
305    ASSERT( ! is_imm( value ) && (value->levelcoeff() == IntegerDomain || value->levelcoeff() == PrimePowerDomain), "illegal operation" );
306    mpz_init_set (mpi, ((InternalInteger*)value)->thempi);
307}
Note: See TracBrowser for help on using the repository browser.