source: git/factory/cf_factory.cc @ 464b18

spielwiese
Last change on this file since 464b18 was 362fc67, checked in by Martin Lee <martinlee84@…>, 12 years ago
chg: remove $Id$
  • Property mode set to 100644
File size: 8.4 KB
Line 
1/* emacs edit mode for this file is -*- C++ -*- */
2
3#include "config.h"
4
5#include "cf_assert.h"
6
7#include "cf_defs.h"
8#include "cf_factory.h"
9#include "canonicalform.h"
10#include "int_cf.h"
11#include "int_int.h"
12#include "int_rat.h"
13#include "int_poly.h"
14#include "int_pp.h"
15#include "imm.h"
16
17int CFFactory::currenttype = IntegerDomain;
18
19void
20CFFactory::settype ( int type )
21{
22    ASSERT( type==FiniteFieldDomain || type==GaloisFieldDomain || type==IntegerDomain || type==RationalDomain || type==PrimePowerDomain, "illegal basic domain!" );
23    currenttype = type;
24}
25
26InternalCF *
27CFFactory::basic ( int value )
28{
29    if ( currenttype == IntegerDomain )
30        if ( value >= MINIMMEDIATE && value <= MAXIMMEDIATE )
31            return int2imm( value );
32        else
33            return new InternalInteger( value );
34//     else  if ( currenttype == RationalDomain )
35//         if ( value >= MINIMMEDIATE && value <= MAXIMMEDIATE )
36//             return int2imm( value );
37//         else
38//             return new InternalRational( value );
39    else  if ( currenttype == FiniteFieldDomain )
40        return int2imm_p( ff_norm( value ) );
41    else  if ( currenttype == GaloisFieldDomain )
42        return int2imm_gf( gf_int2gf( value ) );
43    else  if ( currenttype == PrimePowerDomain )
44        return new InternalPrimePower( value );
45    else {
46        ASSERT( 0, "illegal basic domain!" );
47        return 0;
48    }
49}
50
51InternalCF *
52CFFactory::basic ( int type, int value )
53{
54    if ( type == IntegerDomain )
55        if ( value >= MINIMMEDIATE && value <= MAXIMMEDIATE )
56            return int2imm( value );
57        else
58            return new InternalInteger( value );
59//     else  if ( type == RationalDomain )
60//         if ( value >= MINIMMEDIATE && value <= MAXIMMEDIATE )
61//             return int2imm( value );
62//         else
63//             return new InternalRational( value );
64    else  if ( type == FiniteFieldDomain )
65        return int2imm_p( ff_norm( value ) );
66    else  if ( type == GaloisFieldDomain )
67        return int2imm_gf( gf_int2gf( value ) );
68    else  if ( type == PrimePowerDomain )
69        return new InternalPrimePower( value );
70    else {
71        ASSERT1( 0, "illegal basic domain (type = %d)!", type );
72        return 0;
73    }
74}
75
76InternalCF *
77CFFactory::basic ( const char * str )
78{
79    if ( currenttype == IntegerDomain ) {
80        InternalInteger * dummy = new InternalInteger( str );
81        if ( dummy->is_imm() ) {
82            InternalCF * res = int2imm( dummy->intval() );
83            delete dummy;
84            return res;
85        }
86        else
87            return dummy;
88    }
89//     else  if ( currenttype == RationalDomain ) {
90//         InternalRational * dummy = new InternalRational( str );
91//         if ( dummy->is_imm() ) {
92//             InternalCF * res = int2imm( dummy->intval() );
93//             delete dummy;
94//             return res;
95//         }
96//         else
97//             return dummy;
98//     }
99    else  if ( currenttype == FiniteFieldDomain ) {
100        InternalInteger * dummy = new InternalInteger( str );
101        InternalCF * res = int2imm_p( dummy->intmod( ff_prime ) );
102        delete dummy;
103        return res;
104    }
105    else  if ( currenttype == GaloisFieldDomain ) {
106        InternalInteger * dummy = new InternalInteger( str );
107        InternalCF * res = int2imm_gf( gf_int2gf( dummy->intmod( ff_prime ) ) );
108        delete dummy;
109        return res;
110    }
111    else  if ( currenttype == PrimePowerDomain )
112        return new InternalPrimePower( str );
113    else {
114        ASSERT( 0, "illegal basic domain!" );
115        return 0;
116    }
117}
118
119InternalCF *
120CFFactory::basic ( const char * str, int base )
121{
122    if ( currenttype == IntegerDomain ) {
123        InternalInteger * dummy = new InternalInteger( str, base );
124        if ( dummy->is_imm() ) {
125            InternalCF * res = int2imm( dummy->intval() );
126            delete dummy;
127            return res;
128        }
129        else
130            return dummy;
131    }
132//     else  if ( currenttype == RationalDomain ) {
133//         InternalRational * dummy = new InternalRational( str );
134//         if ( dummy->is_imm() ) {
135//             InternalCF * res = int2imm( dummy->intval() );
136//             delete dummy;
137//             return res;
138//         }
139//         else
140//             return dummy;
141//     }
142    else  if ( currenttype == FiniteFieldDomain ) {
143        InternalInteger * dummy = new InternalInteger( str, base );
144        InternalCF * res = int2imm_p( dummy->intmod( ff_prime ) );
145        delete dummy;
146        return res;
147    }
148    else  if ( currenttype == GaloisFieldDomain ) {
149        InternalInteger * dummy = new InternalInteger( str, base );
150        InternalCF * res = int2imm_gf( gf_int2gf( dummy->intmod( ff_prime ) ) );
151        delete dummy;
152        return res;
153    }
154    else  if ( currenttype == PrimePowerDomain )
155        return new InternalPrimePower( str, base );
156    else {
157        ASSERT( 0, "illegal basic domain!" );
158        return 0;
159    }
160}
161
162InternalCF *
163CFFactory::basic ( int type, const char * const str )
164{
165    if ( type == IntegerDomain ) {
166        InternalInteger * dummy = new InternalInteger( str );
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 ( type == 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 ( type == FiniteFieldDomain ) {
186        InternalInteger * dummy = new InternalInteger( str );
187        InternalCF * res = int2imm( dummy->intmod( ff_prime ) );
188        delete dummy;
189        return res;
190    }
191    else  if ( type == GaloisFieldDomain ) {
192        InternalInteger * dummy = new InternalInteger( str );
193        InternalCF * res = int2imm_gf( gf_int2gf( dummy->intmod( ff_prime ) ) );
194        delete dummy;
195        return res;
196    }
197    else  if ( type == PrimePowerDomain )
198        return new InternalPrimePower( str );
199    else {
200        ASSERT( 0, "illegal basic domain!" );
201        return 0;
202    }
203}
204
205InternalCF *
206CFFactory::basic ( int type, int value, bool nonimm )
207{
208    if ( nonimm )
209        if ( type == IntegerDomain )
210            return new InternalInteger( value );
211         else  if ( type == RationalDomain )
212             return new InternalRational( value );
213        else {
214            ASSERT( 0, "illegal basic domain!" );
215            return 0;
216        }
217    else
218        return CFFactory::basic( type, value );
219}
220
221InternalCF *
222CFFactory::basic ( const mpz_ptr num )
223{
224    if ( currenttype != IntegerDomain ) {
225        InternalPrimePower * dummy = new InternalPrimePower( num );
226        return (InternalCF*)(dummy->normalize_myself());
227    }
228    else
229        return new InternalInteger( num );
230}
231
232InternalCF *
233CFFactory::rational ( int num, int den )
234{
235    InternalRational * res = new InternalRational( num, den );
236    return res->normalize_myself();
237}
238
239InternalCF *
240CFFactory::rational ( const mpz_ptr num, const mpz_ptr den, bool normalize )
241{
242    if ( normalize ) {
243        InternalRational * result = new InternalRational( num, den );
244        return result->normalize_myself();
245    }
246    else
247        return new InternalRational( num, den );
248}
249
250InternalCF *
251CFFactory::poly (  const Variable & v, int exp, const CanonicalForm & c )
252{
253    if ( v.level() == LEVELBASE )
254        return c.getval();
255    else
256        return new InternalPoly( v, exp, c );
257}
258
259InternalCF *
260CFFactory::poly ( const Variable & v, int exp )
261{
262    if ( v.level() == LEVELBASE )
263        return CFFactory::basic( 1 );
264    else
265        return new InternalPoly( v, exp, 1 );
266}
267
268mpz_ptr getmpi ( InternalCF * value, bool symmetric )
269{
270    ASSERT( ! is_imm( value ) && ( value->levelcoeff() == PrimePowerDomain || value->levelcoeff() == IntegerDomain ), "illegal operation" );
271    mpz_ptr dummy= new mpz_t;
272    if ( value->levelcoeff() == IntegerDomain )
273        mpz_init_set( dummy, InternalInteger::MPI( value ) );
274    else  if ( symmetric ) {
275        mpz_init( dummy );
276        if ( mpz_cmp( InternalPrimePower::primepowhalf, InternalPrimePower::MPI( value ) ) < 0 )
277            mpz_sub( dummy, InternalPrimePower::MPI( value ), InternalPrimePower::primepow );
278        else
279            mpz_set( dummy, InternalPrimePower::MPI( value ) );
280    }
281    else
282        mpz_init_set( dummy, InternalPrimePower::MPI( value ) );
283    return dummy;
284}
Note: See TracBrowser for help on using the repository browser.